drivers/base/regmap/regcache-maple.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 //
   3 // Register cache access API - maple tree based cache
   4 //
   5 // Copyright 2023 Arm, Ltd
   6 //
   7 // Author: Mark Brown <broonie@kernel.org>
   8
   9 #include <linux/debugfs.h>
  10 #include <linux/device.h>
  11 #include <linux/maple_tree.h>
  12 #include <linux/slab.h>
  13
  14 #include "internal.h"
  15
  16 static int regcache_maple_read(struct regmap *map,
  17                                unsigned int reg, unsigned int *value)
  18 {
  19         struct maple_tree *mt = map->cache;
  20         MA_STATE(mas, mt, reg, reg);
  21         unsigned long *entry;
  22
  23         rcu_read_lock();
  24
  25         entry = mas_walk(&mas);
  26         if (!entry) {
  27                 rcu_read_unlock();
  28                 return -ENOENT;
  29         }
  30
  31         *value = entry[reg - mas.index];
  32
  33         rcu_read_unlock();
  34
  35         return 0;
  36 }
  37
  38 static int regcache_maple_write(struct regmap *map, unsigned int reg,
  39                                 unsigned int val)
  40 {
  41         struct maple_tree *mt = map->cache;
  42         MA_STATE(mas, mt, reg, reg);
  43         unsigned long *entry, *upper, *lower;
  44         unsigned long index, last;
  45         size_t lower_sz, upper_sz;
  46         int ret;
  47
  48         rcu_read_lock();
  49
  50         entry = mas_walk(&mas);
  51         if (entry) {
  52                 entry[reg - mas.index] = val;
  53                 rcu_read_unlock();
  54                 return 0;
  55         }
  56
  57         /* Any adjacent entries to extend/merge? */
  58         mas_set_range(&mas, reg - 1, reg + 1);
  59         index = reg;
  60         last = reg;
  61
  62         lower = mas_find(&mas, reg - 1);
  63         if (lower) {
  64                 index = mas.index;
  65                 lower_sz = (mas.last - mas.index + 1) * sizeof(unsigned long);
  66         }
  67
  68         upper = mas_find(&mas, reg + 1);
  69         if (upper) {
  70                 last = mas.last;
  71                 upper_sz = (mas.last - mas.index + 1) * sizeof(unsigned long);
  72         }
  73
  74         rcu_read_unlock();
  75
  76         entry = kmalloc((last - index + 1) * sizeof(unsigned long),
  77                         GFP_KERNEL);
  78         if (!entry)
  79                 return -ENOMEM;
  80
  81         if (lower)
  82                 memcpy(entry, lower, lower_sz);
  83         entry[reg - index] = val;
  84         if (upper)
  85                 memcpy(&entry[reg - index + 1], upper, upper_sz);
  86
  87         /*
  88          * This is safe because the regmap lock means the Maple lock
  89          * is redundant, but we need to take it due to lockdep asserts
  90          * in the maple tree code.
  91          */
  92         mas_lock(&mas);
  93
  94         mas_set_range(&mas, index, last);
  95         ret = mas_store_gfp(&mas, entry, GFP_KERNEL);
  96
  97         mas_unlock(&mas);
  98
  99         if (ret == 0) {
 100                 kfree(lower);
 101                 kfree(upper);
 102         }
 103
 104         return ret;
 105 }
 106
 107 static int regcache_maple_drop(struct regmap *map, unsigned int min,
 108                                unsigned int max)
 109 {
 110         struct maple_tree *mt = map->cache;
 111         MA_STATE(mas, mt, min, max);
 112         unsigned long *entry, *lower, *upper;
 113         unsigned long lower_index, lower_last;
 114         unsigned long upper_index, upper_last;
 115         int ret;
 116
 117         lower = NULL;
 118         upper = NULL;
 119
 120         mas_lock(&mas);
 121
 122         mas_for_each(&mas, entry, max) {
 123                 /*
 124                  * This is safe because the regmap lock means the
 125                  * Maple lock is redundant, but we need to take it due
 126                  * to lockdep asserts in the maple tree code.
 127                  */
 128                 mas_unlock(&mas);
 129
 130                 /* Do we need to save any of this entry? */
 131                 if (mas.index < min) {
 132                         lower_index = mas.index;
 133                         lower_last = min -1;
 134
 135                         lower = kmemdup(entry, ((min - mas.index) *
 136                                                 sizeof(unsigned long)),
 137                                         GFP_KERNEL);
 138                         if (!lower) {
 139                                 ret = -ENOMEM;
 140                                 goto out_unlocked;
 141                         }
 142                 }
 143
 144                 if (mas.last > max) {
 145                         upper_index = max + 1;
 146                         upper_last = mas.last;
 147
 148                         upper = kmemdup(&entry[max + 1],
 149                                         ((mas.last - max) *
 150                                          sizeof(unsigned long)),
 151                                         GFP_KERNEL);
 152                         if (!upper) {
 153                                 ret = -ENOMEM;
 154                                 goto out_unlocked;
 155                         }
 156                 }
 157
 158                 kfree(entry);
 159                 mas_lock(&mas);
 160                 mas_erase(&mas);
 161
 162                 /* Insert new nodes with the saved data */
 163                 if (lower) {
 164                         mas_set_range(&mas, lower_index, lower_last);
 165                         ret = mas_store_gfp(&mas, lower, GFP_KERNEL);
 166                         if (ret != 0)
 167                                 goto out;
 168                         lower = NULL;
 169                 }
 170
 171                 if (upper) {
 172                         mas_set_range(&mas, upper_index, upper_last);
 173                         ret = mas_store_gfp(&mas, upper, GFP_KERNEL);
 174                         if (ret != 0)
 175                                 goto out;
 176                         upper = NULL;
 177                 }
 178         }
 179
 180 out:
 181         mas_unlock(&mas);
 182 out_unlocked:
 183         kfree(lower);
 184         kfree(upper);
 185
 186         return ret;
 187 }
 188
 189 static int regcache_maple_sync(struct regmap *map, unsigned int min,
 190                                unsigned int max)
 191 {
 192         struct maple_tree *mt = map->cache;
 193         unsigned long *entry;
 194         MA_STATE(mas, mt, min, max);
 195         unsigned long lmin = min;
 196         unsigned long lmax = max;
 197         unsigned int r;
 198         int ret;
 199
 200         map->cache_bypass = true;
 201
 202         rcu_read_lock();
 203
 204         mas_for_each(&mas, entry, max) {
 205                 for (r = max(mas.index, lmin); r <= min(mas.last, lmax); r++) {
 206                         ret = regcache_sync_val(map, r, entry[r - mas.index]);
 207                         if (ret != 0)
 208                                 goto out;
 209                 }
 210         }
 211
 212 out:
 213         rcu_read_unlock();
 214
 215         map->cache_bypass = false;
 216
 217         return ret;
 218 }
 219
 220 static int regcache_maple_exit(struct regmap *map)
 221 {
 222         struct maple_tree *mt = map->cache;
 223         MA_STATE(mas, mt, 0, UINT_MAX);
 224         unsigned int *entry;;
 225
 226         /* if we've already been called then just return */
 227         if (!mt)
 228                 return 0;
 229
 230         mas_lock(&mas);
 231         mas_for_each(&mas, entry, UINT_MAX)
 232                 kfree(entry);
 233         __mt_destroy(mt);
 234         mas_unlock(&mas);
 235
 236         kfree(mt);
 237         map->cache = NULL;
 238
 239         return 0;
 240 }
 241
 242 static int regcache_maple_init(struct regmap *map)
 243 {
 244         struct maple_tree *mt;
 245         int i;
 246         int ret;
 247
 248         mt = kmalloc(sizeof(*mt), GFP_KERNEL);
 249         if (!mt)
 250                 return -ENOMEM;
 251         map->cache = mt;
 252
 253         mt_init(mt);
 254
 255         for (i = 0; i < map->num_reg_defaults; i++) {
 256                 ret = regcache_maple_write(map,
 257                                            map->reg_defaults[i].reg,
 258                                            map->reg_defaults[i].def);
 259                 if (ret)
 260                         goto err;
 261         }
 262
 263         return 0;
 264
 265 err:
 266         regcache_maple_exit(map);
 267         return ret;
 268 }
 269
 270 struct regcache_ops regcache_maple_ops = {
 271         .type = REGCACHE_MAPLE,
 272         .name = "maple",
 273         .init = regcache_maple_init,
 274         .exit = regcache_maple_exit,
 275         .read = regcache_maple_read,
 276         .write = regcache_maple_write,
 277         .drop = regcache_maple_drop,
 278         .sync = regcache_maple_sync,
 279 };