drivers/base/regmap/regcache.c

   1 /*
   2  * Register cache access API
   3  *
   4  * Copyright 2011 Wolfson Microelectronics plc
   5  *
   6  * Author: Dimitris Papastamos <dp@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/export.h>
  15 #include <trace/events/regmap.h>
  16 #include <linux/bsearch.h>
  17 #include <linux/sort.h>
  18
  19 #include "internal.h"
  20
  21 static const struct regcache_ops *cache_types[] = {
  22         &regcache_indexed_ops,
  23         &regcache_rbtree_ops,
  24         &regcache_lzo_ops,
  25 };
  26
  27 static int regcache_hw_init(struct regmap *map)
  28 {
  29         int i, j;
  30         int ret;
  31         int count;
  32         unsigned int val;
  33         void *tmp_buf;
  34
  35         if (!map->num_reg_defaults_raw)
  36                 return -EINVAL;
  37
  38         if (!map->reg_defaults_raw) {
  39                 dev_warn(map->dev, "No cache defaults, reading back from HW\n");
  40                 tmp_buf = kmalloc(map->cache_size_raw, GFP_KERNEL);
  41                 if (!tmp_buf)
  42                         return -EINVAL;
  43                 ret = regmap_bulk_read(map, 0, tmp_buf,
  44                                        map->num_reg_defaults_raw);
  45                 if (ret < 0) {
  46                         kfree(tmp_buf);
  47                         return ret;
  48                 }
  49                 map->reg_defaults_raw = tmp_buf;
  50                 map->cache_free = 1;
  51         }
  52
  53         /* calculate the size of reg_defaults */
  54         for (count = 0, i = 0; i < map->num_reg_defaults_raw; i++) {
  55                 val = regcache_get_val(map->reg_defaults_raw,
  56                                        i, map->cache_word_size);
  57                 if (!val)
  58                         continue;
  59                 count++;
  60         }
  61
  62         map->reg_defaults = kmalloc(count * sizeof(struct reg_default),
  63                                       GFP_KERNEL);
  64         if (!map->reg_defaults) {
  65                 ret = -ENOMEM;
  66                 goto err_free;
  67         }
  68
  69         /* fill the reg_defaults */
  70         map->num_reg_defaults = count;
  71         for (i = 0, j = 0; i < map->num_reg_defaults_raw; i++) {
  72                 val = regcache_get_val(map->reg_defaults_raw,
  73                                        i, map->cache_word_size);
  74                 if (!val)
  75                         continue;
  76                 map->reg_defaults[j].reg = i;
  77                 map->reg_defaults[j].def = val;
  78                 j++;
  79         }
  80
  81         return 0;
  82
  83 err_free:
  84         if (map->cache_free)
  85                 kfree(map->reg_defaults_raw);
  86
  87         return ret;
  88 }
  89
  90 int regcache_init(struct regmap *map, const struct regmap_config *config)
  91 {
  92         int ret;
  93         int i;
  94         void *tmp_buf;
  95
  96         if (map->cache_type == REGCACHE_NONE) {
  97                 map->cache_bypass = true;
  98                 return 0;
  99         }
 100
 101         for (i = 0; i < ARRAY_SIZE(cache_types); i++)
 102                 if (cache_types[i]->type == map->cache_type)
 103                         break;
 104
 105         if (i == ARRAY_SIZE(cache_types)) {
 106                 dev_err(map->dev, "Could not match compress type: %d\n",
 107                         map->cache_type);
 108                 return -EINVAL;
 109         }
 110
 111         map->num_reg_defaults = config->num_reg_defaults;
 112         map->num_reg_defaults_raw = config->num_reg_defaults_raw;
 113         map->reg_defaults_raw = config->reg_defaults_raw;
 114         map->cache_size_raw = (config->val_bits / 8) * config->num_reg_defaults_raw;
 115         map->cache_word_size = config->val_bits / 8;
 116
 117         map->cache = NULL;
 118         map->cache_ops = cache_types[i];
 119
 120         if (!map->cache_ops->read ||
 121             !map->cache_ops->write ||
 122             !map->cache_ops->name)
 123                 return -EINVAL;
 124
 125         /* We still need to ensure that the reg_defaults
 126          * won't vanish from under us.  We'll need to make
 127          * a copy of it.
 128          */
 129         if (config->reg_defaults) {
 130                 if (!map->num_reg_defaults)
 131                         return -EINVAL;
 132                 tmp_buf = kmemdup(config->reg_defaults, map->num_reg_defaults *
 133                                   sizeof(struct reg_default), GFP_KERNEL);
 134                 if (!tmp_buf)
 135                         return -ENOMEM;
 136                 map->reg_defaults = tmp_buf;
 137         } else if (map->num_reg_defaults_raw) {
 138                 /* Some devices such as PMICs don't have cache defaults,
 139                  * we cope with this by reading back the HW registers and
 140                  * crafting the cache defaults by hand.
 141                  */
 142                 ret = regcache_hw_init(map);
 143                 if (ret < 0)
 144                         return ret;
 145         }
 146
 147         if (!map->max_register)
 148                 map->max_register = map->num_reg_defaults_raw;
 149
 150         if (map->cache_ops->init) {
 151                 dev_dbg(map->dev, "Initializing %s cache\n",
 152                         map->cache_ops->name);
 153                 ret = map->cache_ops->init(map);
 154                 if (ret)
 155                         goto err_free;
 156         }
 157         return 0;
 158
 159 err_free:
 160         kfree(map->reg_defaults);
 161         if (map->cache_free)
 162                 kfree(map->reg_defaults_raw);
 163
 164         return ret;
 165 }
 166
 167 void regcache_exit(struct regmap *map)
 168 {
 169         if (map->cache_type == REGCACHE_NONE)
 170                 return;
 171
 172         BUG_ON(!map->cache_ops);
 173
 174         kfree(map->reg_defaults);
 175         if (map->cache_free)
 176                 kfree(map->reg_defaults_raw);
 177
 178         if (map->cache_ops->exit) {
 179                 dev_dbg(map->dev, "Destroying %s cache\n",
 180                         map->cache_ops->name);
 181                 map->cache_ops->exit(map);
 182         }
 183 }
 184
 185 /**
 186  * regcache_read: Fetch the value of a given register from the cache.
 187  *
 188  * @map: map to configure.
 189  * @reg: The register index.
 190  * @value: The value to be returned.
 191  *
 192  * Return a negative value on failure, 0 on success.
 193  */
 194 int regcache_read(struct regmap *map,
 195                   unsigned int reg, unsigned int *value)
 196 {
 197         if (map->cache_type == REGCACHE_NONE)
 198                 return -ENOSYS;
 199
 200         BUG_ON(!map->cache_ops);
 201
 202         if (!regmap_readable(map, reg))
 203                 return -EIO;
 204
 205         if (!regmap_volatile(map, reg))
 206                 return map->cache_ops->read(map, reg, value);
 207
 208         return -EINVAL;
 209 }
 210 EXPORT_SYMBOL_GPL(regcache_read);
 211
 212 /**
 213  * regcache_write: Set the value of a given register in the cache.
 214  *
 215  * @map: map to configure.
 216  * @reg: The register index.
 217  * @value: The new register value.
 218  *
 219  * Return a negative value on failure, 0 on success.
 220  */
 221 int regcache_write(struct regmap *map,
 222                    unsigned int reg, unsigned int value)
 223 {
 224         if (map->cache_type == REGCACHE_NONE)
 225                 return 0;
 226
 227         BUG_ON(!map->cache_ops);
 228
 229         if (!regmap_writeable(map, reg))
 230                 return -EIO;
 231
 232         if (!regmap_volatile(map, reg))
 233                 return map->cache_ops->write(map, reg, value);
 234
 235         return 0;
 236 }
 237 EXPORT_SYMBOL_GPL(regcache_write);
 238
 239 /**
 240  * regcache_sync: Sync the register cache with the hardware.
 241  *
 242  * @map: map to configure.
 243  *
 244  * Any registers that should not be synced should be marked as
 245  * volatile.  In general drivers can choose not to use the provided
 246  * syncing functionality if they so require.
 247  *
 248  * Return a negative value on failure, 0 on success.
 249  */
 250 int regcache_sync(struct regmap *map)
 251 {
 252         int ret = 0;
 253         unsigned int val;
 254         unsigned int i;
 255         const char *name;
 256         unsigned int bypass;
 257
 258         BUG_ON(!map->cache_ops);
 259
 260         mutex_lock(&map->lock);
 261         /* Remember the initial bypass state */
 262         bypass = map->cache_bypass;
 263         dev_dbg(map->dev, "Syncing %s cache\n",
 264                 map->cache_ops->name);
 265         name = map->cache_ops->name;
 266         trace_regcache_sync(map->dev, name, "start");
 267         if (!map->cache_dirty)
 268                 goto out;
 269         if (map->cache_ops->sync) {
 270                 ret = map->cache_ops->sync(map);
 271         } else {
 272                 for (i = 0; i < map->num_reg_defaults; i++) {
 273                         ret = regcache_read(map, i, &val);
 274                         if (ret < 0)
 275                                 goto out;
 276                         map->cache_bypass = 1;
 277                         ret = _regmap_write(map, i, val);
 278                         map->cache_bypass = 0;
 279                         if (ret < 0)
 280                                 goto out;
 281                         dev_dbg(map->dev, "Synced register %#x, value %#x\n",
 282                                 map->reg_defaults[i].reg,
 283                                 map->reg_defaults[i].def);
 284                 }
 285
 286         }
 287 out:
 288         trace_regcache_sync(map->dev, name, "stop");
 289         /* Restore the bypass state */
 290         map->cache_bypass = bypass;
 291         mutex_unlock(&map->lock);
 292
 293         return ret;
 294 }
 295 EXPORT_SYMBOL_GPL(regcache_sync);
 296
 297 /**
 298  * regcache_cache_only: Put a register map into cache only mode
 299  *
 300  * @map: map to configure
 301  * @cache_only: flag if changes should be written to the hardware
 302  *
 303  * When a register map is marked as cache only writes to the register
 304  * map API will only update the register cache, they will not cause
 305  * any hardware changes.  This is useful for allowing portions of
 306  * drivers to act as though the device were functioning as normal when
 307  * it is disabled for power saving reasons.
 308  */
 309 void regcache_cache_only(struct regmap *map, bool enable)
 310 {
 311         mutex_lock(&map->lock);
 312         WARN_ON(map->cache_bypass && enable);
 313         map->cache_only = enable;
 314         mutex_unlock(&map->lock);
 315 }
 316 EXPORT_SYMBOL_GPL(regcache_cache_only);
 317
 318 /**
 319  * regcache_mark_dirty: Mark the register cache as dirty
 320  *
 321  * @map: map to mark
 322  *
 323  * Mark the register cache as dirty, for example due to the device
 324  * having been powered down for suspend.  If the cache is not marked
 325  * as dirty then the cache sync will be suppressed.
 326  */
 327 void regcache_mark_dirty(struct regmap *map)
 328 {
 329         mutex_lock(&map->lock);
 330         map->cache_dirty = true;
 331         mutex_unlock(&map->lock);
 332 }
 333 EXPORT_SYMBOL_GPL(regcache_mark_dirty);
 334
 335 /**
 336  * regcache_cache_bypass: Put a register map into cache bypass mode
 337  *
 338  * @map: map to configure
 339  * @cache_bypass: flag if changes should not be written to the hardware
 340  *
 341  * When a register map is marked with the cache bypass option, writes
 342  * to the register map API will only update the hardware and not the
 343  * the cache directly.  This is useful when syncing the cache back to
 344  * the hardware.
 345  */
 346 void regcache_cache_bypass(struct regmap *map, bool enable)
 347 {
 348         mutex_lock(&map->lock);
 349         WARN_ON(map->cache_only && enable);
 350         map->cache_bypass = enable;
 351         mutex_unlock(&map->lock);
 352 }
 353 EXPORT_SYMBOL_GPL(regcache_cache_bypass);
 354
 355 bool regcache_set_val(void *base, unsigned int idx,
 356                       unsigned int val, unsigned int word_size)
 357 {
 358         switch (word_size) {
 359         case 1: {
 360                 u8 *cache = base;
 361                 if (cache[idx] == val)
 362                         return true;
 363                 cache[idx] = val;
 364                 break;
 365         }
 366         case 2: {
 367                 u16 *cache = base;
 368                 if (cache[idx] == val)
 369                         return true;
 370                 cache[idx] = val;
 371                 break;
 372         }
 373         default:
 374                 BUG();
 375         }
 376         /* unreachable */
 377         return false;
 378 }
 379
 380 unsigned int regcache_get_val(const void *base, unsigned int idx,
 381                               unsigned int word_size)
 382 {
 383         if (!base)
 384                 return -EINVAL;
 385
 386         switch (word_size) {
 387         case 1: {
 388                 const u8 *cache = base;
 389                 return cache[idx];
 390         }
 391         case 2: {
 392                 const u16 *cache = base;
 393                 return cache[idx];
 394         }
 395         default:
 396                 BUG();
 397         }
 398         /* unreachable */
 399         return -1;
 400 }
 401
 402 static int regcache_default_cmp(const void *a, const void *b)
 403 {
 404         const struct reg_default *_a = a;
 405         const struct reg_default *_b = b;
 406
 407         return _a->reg - _b->reg;
 408 }
 409
 410 int regcache_lookup_reg(struct regmap *map, unsigned int reg)
 411 {
 412         struct reg_default key;
 413         struct reg_default *r;
 414
 415         key.reg = reg;
 416         key.def = 0;
 417
 418         r = bsearch(&key, map->reg_defaults, map->num_reg_defaults,
 419                     sizeof(struct reg_default), regcache_default_cmp);
 420
 421         if (r)
 422                 return r - map->reg_defaults;
 423         else
 424                 return -ENOENT;
 425 }
 426
 427 int regcache_insert_reg(struct regmap *map, unsigned int reg,
 428                         unsigned int val)
 429 {
 430         void *tmp;
 431
 432         tmp = krealloc(map->reg_defaults,
 433                        (map->num_reg_defaults + 1) * sizeof(struct reg_default),
 434                        GFP_KERNEL);
 435         if (!tmp)
 436                 return -ENOMEM;
 437         map->reg_defaults = tmp;
 438         map->num_reg_defaults++;
 439         map->reg_defaults[map->num_reg_defaults - 1].reg = reg;
 440         map->reg_defaults[map->num_reg_defaults - 1].def = val;
 441         sort(map->reg_defaults, map->num_reg_defaults,
 442              sizeof(struct reg_default), regcache_default_cmp, NULL);
 443         return 0;
 444 }