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 			map->alloc_flags);
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, map->alloc_flags);
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 = 0;
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 					map->alloc_flags);
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 - mas.index + 1],
149 					((mas.last - max) *
150 					 sizeof(unsigned long)),
151 					map->alloc_flags);
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, map->alloc_flags);
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, map->alloc_flags);
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_block(struct regmap *map, unsigned long *entry,
190 				     struct ma_state *mas,
191 				     unsigned int min, unsigned int max)
192 {
193 	void *buf;
194 	unsigned long r;
195 	size_t val_bytes = map->format.val_bytes;
196 	int ret = 0;
197 
198 	mas_pause(mas);
199 	rcu_read_unlock();
200 
201 	/*
202 	 * Use a raw write if writing more than one register to a
203 	 * device that supports raw writes to reduce transaction
204 	 * overheads.
205 	 */
206 	if (max - min > 1 && regmap_can_raw_write(map)) {
207 		buf = kmalloc(val_bytes * (max - min), map->alloc_flags);
208 		if (!buf) {
209 			ret = -ENOMEM;
210 			goto out;
211 		}
212 
213 		/* Render the data for a raw write */
214 		for (r = min; r < max; r++) {
215 			regcache_set_val(map, buf, r - min,
216 					 entry[r - mas->index]);
217 		}
218 
219 		ret = _regmap_raw_write(map, min, buf, (max - min) * val_bytes,
220 					false);
221 
222 		kfree(buf);
223 	} else {
224 		for (r = min; r < max; r++) {
225 			ret = _regmap_write(map, r,
226 					    entry[r - mas->index]);
227 			if (ret != 0)
228 				goto out;
229 		}
230 	}
231 
232 out:
233 	rcu_read_lock();
234 
235 	return ret;
236 }
237 
238 static int regcache_maple_sync(struct regmap *map, unsigned int min,
239 			       unsigned int max)
240 {
241 	struct maple_tree *mt = map->cache;
242 	unsigned long *entry;
243 	MA_STATE(mas, mt, min, max);
244 	unsigned long lmin = min;
245 	unsigned long lmax = max;
246 	unsigned int r, v, sync_start;
247 	int ret = 0;
248 	bool sync_needed = false;
249 
250 	map->cache_bypass = true;
251 
252 	rcu_read_lock();
253 
254 	mas_for_each(&mas, entry, max) {
255 		for (r = max(mas.index, lmin); r <= min(mas.last, lmax); r++) {
256 			v = entry[r - mas.index];
257 
258 			if (regcache_reg_needs_sync(map, r, v)) {
259 				if (!sync_needed) {
260 					sync_start = r;
261 					sync_needed = true;
262 				}
263 				continue;
264 			}
265 
266 			if (!sync_needed)
267 				continue;
268 
269 			ret = regcache_maple_sync_block(map, entry, &mas,
270 							sync_start, r);
271 			if (ret != 0)
272 				goto out;
273 			sync_needed = false;
274 		}
275 
276 		if (sync_needed) {
277 			ret = regcache_maple_sync_block(map, entry, &mas,
278 							sync_start, r);
279 			if (ret != 0)
280 				goto out;
281 			sync_needed = false;
282 		}
283 	}
284 
285 out:
286 	rcu_read_unlock();
287 
288 	map->cache_bypass = false;
289 
290 	return ret;
291 }
292 
293 static int regcache_maple_exit(struct regmap *map)
294 {
295 	struct maple_tree *mt = map->cache;
296 	MA_STATE(mas, mt, 0, UINT_MAX);
297 	unsigned int *entry;;
298 
299 	/* if we've already been called then just return */
300 	if (!mt)
301 		return 0;
302 
303 	mas_lock(&mas);
304 	mas_for_each(&mas, entry, UINT_MAX)
305 		kfree(entry);
306 	__mt_destroy(mt);
307 	mas_unlock(&mas);
308 
309 	kfree(mt);
310 	map->cache = NULL;
311 
312 	return 0;
313 }
314 
315 static int regcache_maple_insert_block(struct regmap *map, int first,
316 					int last)
317 {
318 	struct maple_tree *mt = map->cache;
319 	MA_STATE(mas, mt, first, last);
320 	unsigned long *entry;
321 	int i, ret;
322 
323 	entry = kcalloc(last - first + 1, sizeof(unsigned long), map->alloc_flags);
324 	if (!entry)
325 		return -ENOMEM;
326 
327 	for (i = 0; i < last - first + 1; i++)
328 		entry[i] = map->reg_defaults[first + i].def;
329 
330 	mas_lock(&mas);
331 
332 	mas_set_range(&mas, map->reg_defaults[first].reg,
333 		      map->reg_defaults[last].reg);
334 	ret = mas_store_gfp(&mas, entry, map->alloc_flags);
335 
336 	mas_unlock(&mas);
337 
338 	if (ret)
339 		kfree(entry);
340 
341 	return ret;
342 }
343 
344 static int regcache_maple_init(struct regmap *map)
345 {
346 	struct maple_tree *mt;
347 	int i;
348 	int ret;
349 	int range_start;
350 
351 	mt = kmalloc(sizeof(*mt), GFP_KERNEL);
352 	if (!mt)
353 		return -ENOMEM;
354 	map->cache = mt;
355 
356 	mt_init(mt);
357 
358 	if (!map->num_reg_defaults)
359 		return 0;
360 
361 	range_start = 0;
362 
363 	/* Scan for ranges of contiguous registers */
364 	for (i = 1; i < map->num_reg_defaults; i++) {
365 		if (map->reg_defaults[i].reg !=
366 		    map->reg_defaults[i - 1].reg + 1) {
367 			ret = regcache_maple_insert_block(map, range_start,
368 							  i - 1);
369 			if (ret != 0)
370 				goto err;
371 
372 			range_start = i;
373 		}
374 	}
375 
376 	/* Add the last block */
377 	ret = regcache_maple_insert_block(map, range_start,
378 					  map->num_reg_defaults - 1);
379 	if (ret != 0)
380 		goto err;
381 
382 	return 0;
383 
384 err:
385 	regcache_maple_exit(map);
386 	return ret;
387 }
388 
389 struct regcache_ops regcache_maple_ops = {
390 	.type = REGCACHE_MAPLE,
391 	.name = "maple",
392 	.init = regcache_maple_init,
393 	.exit = regcache_maple_exit,
394 	.read = regcache_maple_read,
395 	.write = regcache_maple_write,
396 	.drop = regcache_maple_drop,
397 	.sync = regcache_maple_sync,
398 };
399