1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
|
// SPDX-License-Identifier: GPL-2.0
/*
* KUnit tests for OF APIs
*/
#include <linux/ioport.h>
#include <linux/module.h>
#include <linux/of.h>
#include <kunit/test.h>
#include "of_private.h"
/*
* Test that the root node "/" can be found by path.
*/
static void of_dtb_root_node_found_by_path(struct kunit *test)
{
struct device_node *np;
np = of_find_node_by_path("/");
KUNIT_EXPECT_NOT_ERR_OR_NULL(test, np);
of_node_put(np);
}
/*
* Test that the 'of_root' global variable is always populated when DT code is
* enabled. Remove this test once of_root is removed from global access.
*/
static void of_dtb_root_node_populates_of_root(struct kunit *test)
{
KUNIT_EXPECT_NOT_ERR_OR_NULL(test, of_root);
}
static struct kunit_case of_dtb_test_cases[] = {
KUNIT_CASE(of_dtb_root_node_found_by_path),
KUNIT_CASE(of_dtb_root_node_populates_of_root),
{}
};
static int of_dtb_test_init(struct kunit *test)
{
of_root_kunit_skip(test);
if (!IS_ENABLED(CONFIG_OF_EARLY_FLATTREE))
kunit_skip(test, "requires CONFIG_OF_EARLY_FLATTREE");
return 0;
}
/*
* Test suite to confirm a DTB is loaded.
*/
static struct kunit_suite of_dtb_suite = {
.name = "of_dtb",
.test_cases = of_dtb_test_cases,
.init = of_dtb_test_init,
};
struct of_address_resource_bounds_case {
u64 start;
u64 size;
int ret;
u64 res_start;
u64 res_end;
};
static void of_address_resource_bounds_case_desc(const struct of_address_resource_bounds_case *p,
char *name)
{
snprintf(name, KUNIT_PARAM_DESC_SIZE, "start=0x%016llx,size=0x%016llx", p->start, p->size);
}
static const struct of_address_resource_bounds_case of_address_resource_bounds_cases[] = {
{
.start = 0,
.size = 0,
.ret = 0,
.res_start = 0,
.res_end = -1,
},
{
.start = 0,
.size = 0x1000,
.ret = 0,
.res_start = 0,
.res_end = 0xfff,
},
{
.start = 0x1000,
.size = 0,
.ret = 0,
.res_start = 0x1000,
.res_end = 0xfff,
},
{
.start = 0x1000,
.size = 0x1000,
.ret = 0,
.res_start = 0x1000,
.res_end = 0x1fff,
},
{
.start = 1,
.size = RESOURCE_SIZE_MAX,
.ret = 0,
.res_start = 1,
.res_end = RESOURCE_SIZE_MAX,
},
{
.start = RESOURCE_SIZE_MAX,
.size = 1,
.ret = 0,
.res_start = RESOURCE_SIZE_MAX,
.res_end = RESOURCE_SIZE_MAX,
},
{
.start = 2,
.size = RESOURCE_SIZE_MAX,
.ret = -EOVERFLOW,
},
{
.start = RESOURCE_SIZE_MAX,
.size = 2,
.ret = -EOVERFLOW,
},
{
.start = ULL(0x100000000),
.size = 1,
.ret = sizeof(resource_size_t) > sizeof(u32) ? 0 : -EOVERFLOW,
.res_start = ULL(0x100000000),
.res_end = ULL(0x100000000),
},
{
.start = 0x1000,
.size = 0xffffffff,
.ret = sizeof(resource_size_t) > sizeof(u32) ? 0 : -EOVERFLOW,
.res_start = 0x1000,
.res_end = ULL(0x100000ffe),
},
};
KUNIT_ARRAY_PARAM(of_address_resource_bounds,
of_address_resource_bounds_cases, of_address_resource_bounds_case_desc);
static void of_address_resource_bounds(struct kunit *test)
{
const struct of_address_resource_bounds_case *param = test->param_value;
struct resource r; /* Intentionally uninitialized */
int ret;
if (!IS_ENABLED(CONFIG_OF_ADDRESS))
kunit_skip(test, "CONFIG_OF_ADDRESS not enabled\n");
ret = __of_address_resource_bounds(&r, param->start, param->size);
KUNIT_EXPECT_EQ(test, param->ret, ret);
if (ret == 0) {
KUNIT_EXPECT_EQ(test, (resource_size_t)param->res_start, r.start);
KUNIT_EXPECT_EQ(test, (resource_size_t)param->res_end, r.end);
KUNIT_EXPECT_EQ(test, param->size, resource_size(&r));
}
}
static struct kunit_case of_address_test_cases[] = {
KUNIT_CASE_PARAM(of_address_resource_bounds, of_address_resource_bounds_gen_params),
{}
};
static struct kunit_suite of_address_suite = {
.name = "of_address",
.test_cases = of_address_test_cases,
};
kunit_test_suites(
&of_dtb_suite, &of_address_suite,
);
MODULE_DESCRIPTION("KUnit tests for OF APIs");
MODULE_IMPORT_NS("EXPORTED_FOR_KUNIT_TESTING");
MODULE_LICENSE("GPL");
|
