]> git.sur5r.net Git - u-boot/blob - test/dm/regmap.c
sunxi: Enable eMMC on Libre Computer Board ALL-H3-CC boards
[u-boot] / test / dm / regmap.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright (C) 2015 Google, Inc
4  */
5
6 #include <common.h>
7 #include <dm.h>
8 #include <mapmem.h>
9 #include <regmap.h>
10 #include <syscon.h>
11 #include <asm/test.h>
12 #include <dm/test.h>
13 #include <test/ut.h>
14
15 /* Base test of register maps */
16 static int dm_test_regmap_base(struct unit_test_state *uts)
17 {
18         struct udevice *dev;
19         struct regmap *map;
20         ofnode node;
21         int i;
22
23         ut_assertok(uclass_get_device(UCLASS_SYSCON, 0, &dev));
24         map = syscon_get_regmap(dev);
25         ut_assertok_ptr(map);
26         ut_asserteq(1, map->range_count);
27         ut_asserteq(0x10, map->ranges[0].start);
28         ut_asserteq(4, map->ranges[0].size);
29         ut_asserteq(0x10, map_to_sysmem(regmap_get_range(map, 0)));
30
31         ut_assertok(uclass_get_device(UCLASS_SYSCON, 1, &dev));
32         map = syscon_get_regmap(dev);
33         ut_assertok_ptr(map);
34         ut_asserteq(4, map->range_count);
35         ut_asserteq(0x20, map->ranges[0].start);
36         for (i = 0; i < 4; i++) {
37                 const unsigned long addr = 0x20 + 8 * i;
38
39                 ut_asserteq(addr, map->ranges[i].start);
40                 ut_asserteq(5 + i, map->ranges[i].size);
41                 ut_asserteq(addr, map_to_sysmem(regmap_get_range(map, i)));
42         }
43
44         /* Check that we can't pretend a different device is a syscon */
45         ut_assertok(uclass_get_device(UCLASS_I2C, 0, &dev));
46         map = syscon_get_regmap(dev);
47         ut_asserteq_ptr(ERR_PTR(-ENOEXEC), map);
48
49         /* A different device can be a syscon by using Linux-compat API */
50         node = ofnode_path("/syscon@2");
51         ut_assert(ofnode_valid(node));
52
53         map = syscon_node_to_regmap(node);
54         ut_assertok_ptr(map);
55         ut_asserteq(4, map->range_count);
56         ut_asserteq(0x40, map->ranges[0].start);
57         for (i = 0; i < 4; i++) {
58                 const unsigned long addr = 0x40 + 8 * i;
59
60                 ut_asserteq(addr, map->ranges[i].start);
61                 ut_asserteq(5 + i, map->ranges[i].size);
62                 ut_asserteq(addr, map_to_sysmem(regmap_get_range(map, i)));
63         }
64
65         return 0;
66 }
67 DM_TEST(dm_test_regmap_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
68
69 /* Test we can access a regmap through syscon */
70 static int dm_test_regmap_syscon(struct unit_test_state *uts)
71 {
72         struct regmap *map;
73
74         map = syscon_get_regmap_by_driver_data(SYSCON0);
75         ut_assertok_ptr(map);
76         ut_asserteq(1, map->range_count);
77
78         map = syscon_get_regmap_by_driver_data(SYSCON1);
79         ut_assertok_ptr(map);
80         ut_asserteq(4, map->range_count);
81
82         map = syscon_get_regmap_by_driver_data(SYSCON_COUNT);
83         ut_asserteq_ptr(ERR_PTR(-ENODEV), map);
84
85         ut_asserteq(0x10, map_to_sysmem(syscon_get_first_range(SYSCON0)));
86         ut_asserteq(0x20, map_to_sysmem(syscon_get_first_range(SYSCON1)));
87         ut_asserteq_ptr(ERR_PTR(-ENODEV),
88                         syscon_get_first_range(SYSCON_COUNT));
89
90         return 0;
91 }
92
93 DM_TEST(dm_test_regmap_syscon, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
94
95 /* Read/Write/Modify test */
96 static int dm_test_regmap_rw(struct unit_test_state *uts)
97 {
98         struct udevice *dev;
99         struct regmap *map;
100         uint reg;
101
102         ut_assertok(uclass_get_device(UCLASS_SYSCON, 0, &dev));
103         map = syscon_get_regmap(dev);
104         ut_assertok_ptr(map);
105
106         ut_assertok(regmap_write(map, 0, 0xcacafafa));
107         ut_assertok(regmap_write(map, 3, 0x55aa2211));
108
109         ut_assertok(regmap_read(map, 0, &reg));
110         ut_assertok(regmap_read(map, 3, &reg));
111
112         ut_assertok(regmap_update_bits(map, 0, 0xff00ff00, 0x55aa2211));
113         ut_assertok(regmap_update_bits(map, 3, 0x00ff00ff, 0xcacafada));
114
115         return 0;
116 }
117
118 DM_TEST(dm_test_regmap_rw, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);