1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (c) 2015 Google, Inc
4 * Written by Simon Glass <sjg@chromium.org>
5 */
6
7 #include <common.h>
8 #include <dm.h>
9 #include <errno.h>
10 #include <log.h>
11 #include <asm/global_data.h>
12 #include <linux/libfdt.h>
13 #include <malloc.h>
14 #include <mapmem.h>
15 #include <regmap.h>
16 #include <asm/io.h>
17 #include <dm/of_addr.h>
18 #include <dm/devres.h>
19 #include <linux/ioport.h>
20 #include <linux/compat.h>
21 #include <linux/err.h>
22 #include <linux/bitops.h>
23
24 /*
25 * Internal representation of a regmap field. Instead of storing the MSB and
26 * LSB, store the shift and mask. This makes the code a bit cleaner and faster
27 * because the shift and mask don't have to be calculated every time.
28 */
29 struct regmap_field {
30 struct regmap *regmap;
31 unsigned int mask;
32 /* lsb */
33 unsigned int shift;
34 unsigned int reg;
35 };
36
37 DECLARE_GLOBAL_DATA_PTR;
38
39 /**
40 * regmap_alloc() - Allocate a regmap with a given number of ranges.
41 *
42 * @count: Number of ranges to be allocated for the regmap.
43 *
44 * The default regmap width is set to REGMAP_SIZE_32. Callers can override it
45 * if they need.
46 *
47 * Return: A pointer to the newly allocated regmap, or NULL on error.
48 */
regmap_alloc(int count)49 static struct regmap *regmap_alloc(int count)
50 {
51 struct regmap *map;
52 size_t size = sizeof(*map) + sizeof(map->ranges[0]) * count;
53
54 map = calloc(1, size);
55 if (!map)
56 return NULL;
57 map->range_count = count;
58 map->width = REGMAP_SIZE_32;
59
60 return map;
61 }
62
63 #if CONFIG_IS_ENABLED(OF_PLATDATA)
regmap_init_mem_plat(struct udevice * dev,fdt_val_t * reg,int count,struct regmap ** mapp)64 int regmap_init_mem_plat(struct udevice *dev, fdt_val_t *reg, int count,
65 struct regmap **mapp)
66 {
67 struct regmap_range *range;
68 struct regmap *map;
69
70 map = regmap_alloc(count);
71 if (!map)
72 return -ENOMEM;
73
74 for (range = map->ranges; count > 0; reg += 2, range++, count--) {
75 range->start = *reg;
76 range->size = reg[1];
77 }
78
79 *mapp = map;
80
81 return 0;
82 }
83 #else
84 /**
85 * init_range() - Initialize a single range of a regmap
86 * @node: Device node that will use the map in question
87 * @range: Pointer to a regmap_range structure that will be initialized
88 * @addr_len: The length of the addr parts of the reg property
89 * @size_len: The length of the size parts of the reg property
90 * @index: The index of the range to initialize
91 *
92 * This function will read the necessary 'reg' information from the device tree
93 * (the 'addr' part, and the 'length' part), and initialize the range in
94 * quesion.
95 *
96 * Return: 0 if OK, -ve on error
97 */
init_range(ofnode node,struct regmap_range * range,int addr_len,int size_len,int index)98 static int init_range(ofnode node, struct regmap_range *range, int addr_len,
99 int size_len, int index)
100 {
101 fdt_size_t sz;
102 struct resource r;
103
104 if (of_live_active()) {
105 int ret;
106
107 ret = of_address_to_resource(ofnode_to_np(node),
108 index, &r);
109 if (ret) {
110 debug("%s: Could not read resource of range %d (ret = %d)\n",
111 ofnode_get_name(node), index, ret);
112 return ret;
113 }
114
115 range->start = r.start;
116 range->size = r.end - r.start + 1;
117 } else {
118 int offset = ofnode_to_offset(node);
119
120 range->start = fdtdec_get_addr_size_fixed(gd->fdt_blob, offset,
121 "reg", index,
122 addr_len, size_len,
123 &sz, true);
124 if (range->start == FDT_ADDR_T_NONE) {
125 debug("%s: Could not read start of range %d\n",
126 ofnode_get_name(node), index);
127 return -EINVAL;
128 }
129
130 range->size = sz;
131 }
132
133 return 0;
134 }
135
regmap_init_mem_index(ofnode node,struct regmap ** mapp,int index)136 int regmap_init_mem_index(ofnode node, struct regmap **mapp, int index)
137 {
138 struct regmap *map;
139 int addr_len, size_len;
140 int ret;
141
142 addr_len = ofnode_read_simple_addr_cells(ofnode_get_parent(node));
143 if (addr_len < 0) {
144 debug("%s: Error while reading the addr length (ret = %d)\n",
145 ofnode_get_name(node), addr_len);
146 return addr_len;
147 }
148
149 size_len = ofnode_read_simple_size_cells(ofnode_get_parent(node));
150 if (size_len < 0) {
151 debug("%s: Error while reading the size length: (ret = %d)\n",
152 ofnode_get_name(node), size_len);
153 return size_len;
154 }
155
156 map = regmap_alloc(1);
157 if (!map)
158 return -ENOMEM;
159
160 ret = init_range(node, map->ranges, addr_len, size_len, index);
161 if (ret)
162 goto err;
163
164 if (ofnode_read_bool(node, "little-endian"))
165 map->endianness = REGMAP_LITTLE_ENDIAN;
166 else if (ofnode_read_bool(node, "big-endian"))
167 map->endianness = REGMAP_BIG_ENDIAN;
168 else if (ofnode_read_bool(node, "native-endian"))
169 map->endianness = REGMAP_NATIVE_ENDIAN;
170 else /* Default: native endianness */
171 map->endianness = REGMAP_NATIVE_ENDIAN;
172
173 *mapp = map;
174
175 return 0;
176 err:
177 regmap_uninit(map);
178
179 return ret;
180 }
181
regmap_init_mem_range(ofnode node,ulong r_start,ulong r_size,struct regmap ** mapp)182 int regmap_init_mem_range(ofnode node, ulong r_start, ulong r_size,
183 struct regmap **mapp)
184 {
185 struct regmap *map;
186 struct regmap_range *range;
187
188 map = regmap_alloc(1);
189 if (!map)
190 return -ENOMEM;
191
192 range = &map->ranges[0];
193 range->start = r_start;
194 range->size = r_size;
195
196 if (ofnode_read_bool(node, "little-endian"))
197 map->endianness = REGMAP_LITTLE_ENDIAN;
198 else if (ofnode_read_bool(node, "big-endian"))
199 map->endianness = REGMAP_BIG_ENDIAN;
200 else if (ofnode_read_bool(node, "native-endian"))
201 map->endianness = REGMAP_NATIVE_ENDIAN;
202 else /* Default: native endianness */
203 map->endianness = REGMAP_NATIVE_ENDIAN;
204
205 *mapp = map;
206 return 0;
207 }
208
regmap_init_mem(ofnode node,struct regmap ** mapp)209 int regmap_init_mem(ofnode node, struct regmap **mapp)
210 {
211 struct regmap_range *range;
212 struct regmap *map;
213 int count;
214 int addr_len, size_len, both_len;
215 int len;
216 int index;
217 int ret;
218
219 addr_len = ofnode_read_simple_addr_cells(ofnode_get_parent(node));
220 if (addr_len < 0) {
221 debug("%s: Error while reading the addr length (ret = %d)\n",
222 ofnode_get_name(node), addr_len);
223 return addr_len;
224 }
225
226 size_len = ofnode_read_simple_size_cells(ofnode_get_parent(node));
227 if (size_len < 0) {
228 debug("%s: Error while reading the size length: (ret = %d)\n",
229 ofnode_get_name(node), size_len);
230 return size_len;
231 }
232
233 both_len = addr_len + size_len;
234 if (!both_len) {
235 debug("%s: Both addr and size length are zero\n",
236 ofnode_get_name(node));
237 return -EINVAL;
238 }
239
240 len = ofnode_read_size(node, "reg");
241 if (len < 0) {
242 debug("%s: Error while reading reg size (ret = %d)\n",
243 ofnode_get_name(node), len);
244 return len;
245 }
246 len /= sizeof(fdt32_t);
247 count = len / both_len;
248 if (!count) {
249 debug("%s: Not enough data in reg property\n",
250 ofnode_get_name(node));
251 return -EINVAL;
252 }
253
254 map = regmap_alloc(count);
255 if (!map)
256 return -ENOMEM;
257
258 for (range = map->ranges, index = 0; count > 0;
259 count--, range++, index++) {
260 ret = init_range(node, range, addr_len, size_len, index);
261 if (ret)
262 goto err;
263 }
264
265 if (ofnode_read_bool(node, "little-endian"))
266 map->endianness = REGMAP_LITTLE_ENDIAN;
267 else if (ofnode_read_bool(node, "big-endian"))
268 map->endianness = REGMAP_BIG_ENDIAN;
269 else if (ofnode_read_bool(node, "native-endian"))
270 map->endianness = REGMAP_NATIVE_ENDIAN;
271 else /* Default: native endianness */
272 map->endianness = REGMAP_NATIVE_ENDIAN;
273
274 *mapp = map;
275
276 return 0;
277 err:
278 regmap_uninit(map);
279
280 return ret;
281 }
282
devm_regmap_release(struct udevice * dev,void * res)283 static void devm_regmap_release(struct udevice *dev, void *res)
284 {
285 regmap_uninit(*(struct regmap **)res);
286 }
287
devm_regmap_init(struct udevice * dev,const struct regmap_bus * bus,void * bus_context,const struct regmap_config * config)288 struct regmap *devm_regmap_init(struct udevice *dev,
289 const struct regmap_bus *bus,
290 void *bus_context,
291 const struct regmap_config *config)
292 {
293 int rc;
294 struct regmap **mapp, *map;
295
296 /* this looks like a leak, but devres takes care of it */
297 mapp = devres_alloc(devm_regmap_release, sizeof(struct regmap *),
298 __GFP_ZERO);
299 if (unlikely(!mapp))
300 return ERR_PTR(-ENOMEM);
301
302 if (config && config->r_size != 0)
303 rc = regmap_init_mem_range(dev_ofnode(dev), config->r_start,
304 config->r_size, mapp);
305 else
306 rc = regmap_init_mem(dev_ofnode(dev), mapp);
307 if (rc)
308 return ERR_PTR(rc);
309
310 map = *mapp;
311 if (config) {
312 map->width = config->width;
313 map->reg_offset_shift = config->reg_offset_shift;
314 }
315
316 devres_add(dev, mapp);
317 return *mapp;
318 }
319 #endif
320
regmap_get_range(struct regmap * map,unsigned int range_num)321 void *regmap_get_range(struct regmap *map, unsigned int range_num)
322 {
323 struct regmap_range *range;
324
325 if (range_num >= map->range_count)
326 return NULL;
327 range = &map->ranges[range_num];
328
329 return map_sysmem(range->start, range->size);
330 }
331
regmap_uninit(struct regmap * map)332 int regmap_uninit(struct regmap *map)
333 {
334 free(map);
335
336 return 0;
337 }
338
__read_8(u8 * addr,enum regmap_endianness_t endianness)339 static inline u8 __read_8(u8 *addr, enum regmap_endianness_t endianness)
340 {
341 return readb(addr);
342 }
343
__read_16(u16 * addr,enum regmap_endianness_t endianness)344 static inline u16 __read_16(u16 *addr, enum regmap_endianness_t endianness)
345 {
346 switch (endianness) {
347 case REGMAP_LITTLE_ENDIAN:
348 return in_le16(addr);
349 case REGMAP_BIG_ENDIAN:
350 return in_be16(addr);
351 case REGMAP_NATIVE_ENDIAN:
352 return readw(addr);
353 }
354
355 return readw(addr);
356 }
357
__read_32(u32 * addr,enum regmap_endianness_t endianness)358 static inline u32 __read_32(u32 *addr, enum regmap_endianness_t endianness)
359 {
360 switch (endianness) {
361 case REGMAP_LITTLE_ENDIAN:
362 return in_le32(addr);
363 case REGMAP_BIG_ENDIAN:
364 return in_be32(addr);
365 case REGMAP_NATIVE_ENDIAN:
366 return readl(addr);
367 }
368
369 return readl(addr);
370 }
371
372 #if defined(in_le64) && defined(in_be64) && defined(readq)
__read_64(u64 * addr,enum regmap_endianness_t endianness)373 static inline u64 __read_64(u64 *addr, enum regmap_endianness_t endianness)
374 {
375 switch (endianness) {
376 case REGMAP_LITTLE_ENDIAN:
377 return in_le64(addr);
378 case REGMAP_BIG_ENDIAN:
379 return in_be64(addr);
380 case REGMAP_NATIVE_ENDIAN:
381 return readq(addr);
382 }
383
384 return readq(addr);
385 }
386 #endif
387
regmap_raw_read_range(struct regmap * map,uint range_num,uint offset,void * valp,size_t val_len)388 int regmap_raw_read_range(struct regmap *map, uint range_num, uint offset,
389 void *valp, size_t val_len)
390 {
391 struct regmap_range *range;
392 void *ptr;
393
394 if (range_num >= map->range_count) {
395 debug("%s: range index %d larger than range count\n",
396 __func__, range_num);
397 return -ERANGE;
398 }
399 range = &map->ranges[range_num];
400
401 offset <<= map->reg_offset_shift;
402 if (offset + val_len > range->size) {
403 debug("%s: offset/size combination invalid\n", __func__);
404 return -ERANGE;
405 }
406
407 ptr = map_physmem(range->start + offset, val_len, MAP_NOCACHE);
408
409 switch (val_len) {
410 case REGMAP_SIZE_8:
411 *((u8 *)valp) = __read_8(ptr, map->endianness);
412 break;
413 case REGMAP_SIZE_16:
414 *((u16 *)valp) = __read_16(ptr, map->endianness);
415 break;
416 case REGMAP_SIZE_32:
417 *((u32 *)valp) = __read_32(ptr, map->endianness);
418 break;
419 #if defined(in_le64) && defined(in_be64) && defined(readq)
420 case REGMAP_SIZE_64:
421 *((u64 *)valp) = __read_64(ptr, map->endianness);
422 break;
423 #endif
424 default:
425 debug("%s: regmap size %zu unknown\n", __func__, val_len);
426 return -EINVAL;
427 }
428
429 return 0;
430 }
431
regmap_raw_read(struct regmap * map,uint offset,void * valp,size_t val_len)432 int regmap_raw_read(struct regmap *map, uint offset, void *valp, size_t val_len)
433 {
434 return regmap_raw_read_range(map, 0, offset, valp, val_len);
435 }
436
regmap_read(struct regmap * map,uint offset,uint * valp)437 int regmap_read(struct regmap *map, uint offset, uint *valp)
438 {
439 union {
440 u8 v8;
441 u16 v16;
442 u32 v32;
443 u64 v64;
444 } u;
445 int res;
446
447 res = regmap_raw_read(map, offset, &u, map->width);
448 if (res)
449 return res;
450
451 switch (map->width) {
452 case REGMAP_SIZE_8:
453 *valp = u.v8;
454 break;
455 case REGMAP_SIZE_16:
456 *valp = u.v16;
457 break;
458 case REGMAP_SIZE_32:
459 *valp = u.v32;
460 break;
461 case REGMAP_SIZE_64:
462 *valp = u.v64;
463 break;
464 default:
465 unreachable();
466 }
467
468 return 0;
469 }
470
__write_8(u8 * addr,const u8 * val,enum regmap_endianness_t endianness)471 static inline void __write_8(u8 *addr, const u8 *val,
472 enum regmap_endianness_t endianness)
473 {
474 writeb(*val, addr);
475 }
476
__write_16(u16 * addr,const u16 * val,enum regmap_endianness_t endianness)477 static inline void __write_16(u16 *addr, const u16 *val,
478 enum regmap_endianness_t endianness)
479 {
480 switch (endianness) {
481 case REGMAP_NATIVE_ENDIAN:
482 writew(*val, addr);
483 break;
484 case REGMAP_LITTLE_ENDIAN:
485 out_le16(addr, *val);
486 break;
487 case REGMAP_BIG_ENDIAN:
488 out_be16(addr, *val);
489 break;
490 }
491 }
492
__write_32(u32 * addr,const u32 * val,enum regmap_endianness_t endianness)493 static inline void __write_32(u32 *addr, const u32 *val,
494 enum regmap_endianness_t endianness)
495 {
496 switch (endianness) {
497 case REGMAP_NATIVE_ENDIAN:
498 writel(*val, addr);
499 break;
500 case REGMAP_LITTLE_ENDIAN:
501 out_le32(addr, *val);
502 break;
503 case REGMAP_BIG_ENDIAN:
504 out_be32(addr, *val);
505 break;
506 }
507 }
508
509 #if defined(out_le64) && defined(out_be64) && defined(writeq)
__write_64(u64 * addr,const u64 * val,enum regmap_endianness_t endianness)510 static inline void __write_64(u64 *addr, const u64 *val,
511 enum regmap_endianness_t endianness)
512 {
513 switch (endianness) {
514 case REGMAP_NATIVE_ENDIAN:
515 writeq(*val, addr);
516 break;
517 case REGMAP_LITTLE_ENDIAN:
518 out_le64(addr, *val);
519 break;
520 case REGMAP_BIG_ENDIAN:
521 out_be64(addr, *val);
522 break;
523 }
524 }
525 #endif
526
regmap_raw_write_range(struct regmap * map,uint range_num,uint offset,const void * val,size_t val_len)527 int regmap_raw_write_range(struct regmap *map, uint range_num, uint offset,
528 const void *val, size_t val_len)
529 {
530 struct regmap_range *range;
531 void *ptr;
532
533 if (range_num >= map->range_count) {
534 debug("%s: range index %d larger than range count\n",
535 __func__, range_num);
536 return -ERANGE;
537 }
538 range = &map->ranges[range_num];
539
540 offset <<= map->reg_offset_shift;
541 if (offset + val_len > range->size) {
542 debug("%s: offset/size combination invalid\n", __func__);
543 return -ERANGE;
544 }
545
546 ptr = map_physmem(range->start + offset, val_len, MAP_NOCACHE);
547
548 switch (val_len) {
549 case REGMAP_SIZE_8:
550 __write_8(ptr, val, map->endianness);
551 break;
552 case REGMAP_SIZE_16:
553 __write_16(ptr, val, map->endianness);
554 break;
555 case REGMAP_SIZE_32:
556 __write_32(ptr, val, map->endianness);
557 break;
558 #if defined(out_le64) && defined(out_be64) && defined(writeq)
559 case REGMAP_SIZE_64:
560 __write_64(ptr, val, map->endianness);
561 break;
562 #endif
563 default:
564 debug("%s: regmap size %zu unknown\n", __func__, val_len);
565 return -EINVAL;
566 }
567
568 return 0;
569 }
570
regmap_raw_write(struct regmap * map,uint offset,const void * val,size_t val_len)571 int regmap_raw_write(struct regmap *map, uint offset, const void *val,
572 size_t val_len)
573 {
574 return regmap_raw_write_range(map, 0, offset, val, val_len);
575 }
576
regmap_write(struct regmap * map,uint offset,uint val)577 int regmap_write(struct regmap *map, uint offset, uint val)
578 {
579 union {
580 u8 v8;
581 u16 v16;
582 u32 v32;
583 u64 v64;
584 } u;
585
586 switch (map->width) {
587 case REGMAP_SIZE_8:
588 u.v8 = val;
589 break;
590 case REGMAP_SIZE_16:
591 u.v16 = val;
592 break;
593 case REGMAP_SIZE_32:
594 u.v32 = val;
595 break;
596 case REGMAP_SIZE_64:
597 u.v64 = val;
598 break;
599 default:
600 debug("%s: regmap size %zu unknown\n", __func__,
601 (size_t)map->width);
602 return -EINVAL;
603 }
604
605 return regmap_raw_write(map, offset, &u, map->width);
606 }
607
regmap_update_bits(struct regmap * map,uint offset,uint mask,uint val)608 int regmap_update_bits(struct regmap *map, uint offset, uint mask, uint val)
609 {
610 uint reg;
611 int ret;
612
613 ret = regmap_read(map, offset, ®);
614 if (ret)
615 return ret;
616
617 reg &= ~mask;
618
619 return regmap_write(map, offset, reg | (val & mask));
620 }
621
regmap_field_read(struct regmap_field * field,unsigned int * val)622 int regmap_field_read(struct regmap_field *field, unsigned int *val)
623 {
624 int ret;
625 unsigned int reg_val;
626
627 ret = regmap_read(field->regmap, field->reg, ®_val);
628 if (ret != 0)
629 return ret;
630
631 reg_val &= field->mask;
632 reg_val >>= field->shift;
633 *val = reg_val;
634
635 return ret;
636 }
637
regmap_field_write(struct regmap_field * field,unsigned int val)638 int regmap_field_write(struct regmap_field *field, unsigned int val)
639 {
640 return regmap_update_bits(field->regmap, field->reg, field->mask,
641 val << field->shift);
642 }
643
regmap_field_init(struct regmap_field * rm_field,struct regmap * regmap,struct reg_field reg_field)644 static void regmap_field_init(struct regmap_field *rm_field,
645 struct regmap *regmap,
646 struct reg_field reg_field)
647 {
648 rm_field->regmap = regmap;
649 rm_field->reg = reg_field.reg;
650 rm_field->shift = reg_field.lsb;
651 rm_field->mask = GENMASK(reg_field.msb, reg_field.lsb);
652 }
653
devm_regmap_field_alloc(struct udevice * dev,struct regmap * regmap,struct reg_field reg_field)654 struct regmap_field *devm_regmap_field_alloc(struct udevice *dev,
655 struct regmap *regmap,
656 struct reg_field reg_field)
657 {
658 struct regmap_field *rm_field = devm_kzalloc(dev, sizeof(*rm_field),
659 GFP_KERNEL);
660 if (!rm_field)
661 return ERR_PTR(-ENOMEM);
662
663 regmap_field_init(rm_field, regmap, reg_field);
664
665 return rm_field;
666 }
667
devm_regmap_field_free(struct udevice * dev,struct regmap_field * field)668 void devm_regmap_field_free(struct udevice *dev, struct regmap_field *field)
669 {
670 devm_kfree(dev, field);
671 }
672
regmap_field_alloc(struct regmap * regmap,struct reg_field reg_field)673 struct regmap_field *regmap_field_alloc(struct regmap *regmap,
674 struct reg_field reg_field)
675 {
676 struct regmap_field *rm_field = kzalloc(sizeof(*rm_field), GFP_KERNEL);
677
678 if (!rm_field)
679 return ERR_PTR(-ENOMEM);
680
681 regmap_field_init(rm_field, regmap, reg_field);
682
683 return rm_field;
684 }
685
regmap_field_free(struct regmap_field * field)686 void regmap_field_free(struct regmap_field *field)
687 {
688 kfree(field);
689 }
690