1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright (c) 2016 NextThing Co 4 * Copyright (c) 2016 Free Electrons 5 */ 6 7 #include <common.h> 8 #include <command.h> 9 #include <errno.h> 10 #include <fdt_support.h> 11 #include <malloc.h> 12 13 #include <linux/sizes.h> 14 15 #include <test/ut.h> 16 #include <test/overlay.h> 17 #include <test/suites.h> 18 19 /* 4k ought to be enough for anybody */ 20 #define FDT_COPY_SIZE (4 * SZ_1K) 21 22 extern u32 __dtb_test_fdt_base_begin; 23 extern u32 __dtb_test_fdt_overlay_begin; 24 extern u32 __dtb_test_fdt_overlay_stacked_begin; 25 26 static int ut_fdt_getprop_u32_by_index(void *fdt, const char *path, 27 const char *name, int index, 28 u32 *out) 29 { 30 const fdt32_t *val; 31 int node_off; 32 int len; 33 34 node_off = fdt_path_offset(fdt, path); 35 if (node_off < 0) 36 return node_off; 37 38 val = fdt_getprop(fdt, node_off, name, &len); 39 if (!val || (len < (sizeof(uint32_t) * (index + 1)))) 40 return -FDT_ERR_NOTFOUND; 41 42 *out = fdt32_to_cpu(*(val + index)); 43 44 return 0; 45 } 46 47 static int ut_fdt_getprop_u32(void *fdt, const char *path, const char *name, 48 u32 *out) 49 { 50 return ut_fdt_getprop_u32_by_index(fdt, path, name, 0, out); 51 } 52 53 static int fdt_getprop_str(void *fdt, const char *path, const char *name, 54 const char **out) 55 { 56 int node_off; 57 int len; 58 59 node_off = fdt_path_offset(fdt, path); 60 if (node_off < 0) 61 return node_off; 62 63 *out = fdt_stringlist_get(fdt, node_off, name, 0, &len); 64 65 return len < 0 ? len : 0; 66 } 67 68 static int fdt_overlay_change_int_property(struct unit_test_state *uts) 69 { 70 void *fdt = uts->priv; 71 u32 val = 0; 72 73 ut_assertok(ut_fdt_getprop_u32(fdt, "/test-node", "test-int-property", 74 &val)); 75 ut_asserteq(43, val); 76 77 return CMD_RET_SUCCESS; 78 } 79 OVERLAY_TEST(fdt_overlay_change_int_property, 0); 80 81 static int fdt_overlay_change_str_property(struct unit_test_state *uts) 82 { 83 void *fdt = uts->priv; 84 const char *val = NULL; 85 86 ut_assertok(fdt_getprop_str(fdt, "/test-node", "test-str-property", 87 &val)); 88 ut_asserteq_str("foobar", val); 89 90 return CMD_RET_SUCCESS; 91 } 92 OVERLAY_TEST(fdt_overlay_change_str_property, 0); 93 94 static int fdt_overlay_add_str_property(struct unit_test_state *uts) 95 { 96 void *fdt = uts->priv; 97 const char *val = NULL; 98 99 ut_assertok(fdt_getprop_str(fdt, "/test-node", "test-str-property-2", 100 &val)); 101 ut_asserteq_str("foobar2", val); 102 103 return CMD_RET_SUCCESS; 104 } 105 OVERLAY_TEST(fdt_overlay_add_str_property, 0); 106 107 static int fdt_overlay_add_node_by_phandle(struct unit_test_state *uts) 108 { 109 void *fdt = uts->priv; 110 int off; 111 112 off = fdt_path_offset(fdt, "/test-node/new-node"); 113 ut_assert(off >= 0); 114 115 ut_assertnonnull(fdt_getprop(fdt, off, "new-property", NULL)); 116 117 return CMD_RET_SUCCESS; 118 } 119 OVERLAY_TEST(fdt_overlay_add_node_by_phandle, 0); 120 121 static int fdt_overlay_add_node_by_path(struct unit_test_state *uts) 122 { 123 void *fdt = uts->priv; 124 int off; 125 126 off = fdt_path_offset(fdt, "/new-node"); 127 ut_assert(off >= 0); 128 129 ut_assertnonnull(fdt_getprop(fdt, off, "new-property", NULL)); 130 131 return CMD_RET_SUCCESS; 132 } 133 OVERLAY_TEST(fdt_overlay_add_node_by_path, 0); 134 135 static int fdt_overlay_add_subnode_property(struct unit_test_state *uts) 136 { 137 void *fdt = uts->priv; 138 int off; 139 140 off = fdt_path_offset(fdt, "/test-node/sub-test-node"); 141 ut_assert(off >= 0); 142 143 ut_assertnonnull(fdt_getprop(fdt, off, "sub-test-property", NULL)); 144 ut_assertnonnull(fdt_getprop(fdt, off, "new-sub-test-property", NULL)); 145 146 return CMD_RET_SUCCESS; 147 } 148 OVERLAY_TEST(fdt_overlay_add_subnode_property, 0); 149 150 static int fdt_overlay_local_phandle(struct unit_test_state *uts) 151 { 152 uint32_t local_phandle; 153 void *fdt = uts->priv; 154 u32 val = 0; 155 int off; 156 157 off = fdt_path_offset(fdt, "/new-local-node"); 158 ut_assert(off >= 0); 159 160 local_phandle = fdt_get_phandle(fdt, off); 161 ut_assert(local_phandle); 162 163 ut_assertok(ut_fdt_getprop_u32_by_index(fdt, "/", "test-several-phandle", 164 0, &val)); 165 ut_asserteq(local_phandle, val); 166 167 ut_assertok(ut_fdt_getprop_u32_by_index(fdt, "/", "test-several-phandle", 168 1, &val)); 169 ut_asserteq(local_phandle, val); 170 171 return CMD_RET_SUCCESS; 172 } 173 OVERLAY_TEST(fdt_overlay_local_phandle, 0); 174 175 static int fdt_overlay_local_phandles(struct unit_test_state *uts) 176 { 177 uint32_t local_phandle, test_phandle; 178 void *fdt = uts->priv; 179 u32 val = 0; 180 int off; 181 182 off = fdt_path_offset(fdt, "/new-local-node"); 183 ut_assert(off >= 0); 184 185 local_phandle = fdt_get_phandle(fdt, off); 186 ut_assert(local_phandle); 187 188 off = fdt_path_offset(fdt, "/test-node"); 189 ut_assert(off >= 0); 190 191 test_phandle = fdt_get_phandle(fdt, off); 192 ut_assert(test_phandle); 193 194 ut_assertok(ut_fdt_getprop_u32_by_index(fdt, "/", "test-phandle", 0, 195 &val)); 196 ut_asserteq(test_phandle, val); 197 198 ut_assertok(ut_fdt_getprop_u32_by_index(fdt, "/", "test-phandle", 1, 199 &val)); 200 ut_asserteq(local_phandle, val); 201 202 return CMD_RET_SUCCESS; 203 } 204 OVERLAY_TEST(fdt_overlay_local_phandles, 0); 205 206 static int fdt_overlay_stacked(struct unit_test_state *uts) 207 { 208 void *fdt = uts->priv; 209 u32 val = 0; 210 211 ut_assertok(ut_fdt_getprop_u32(fdt, "/new-local-node", 212 "stacked-test-int-property", &val)); 213 ut_asserteq(43, val); 214 215 return CMD_RET_SUCCESS; 216 } 217 OVERLAY_TEST(fdt_overlay_stacked, 0); 218 219 int do_ut_overlay(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) 220 { 221 struct unit_test *tests = ll_entry_start(struct unit_test, 222 overlay_test); 223 const int n_ents = ll_entry_count(struct unit_test, overlay_test); 224 struct unit_test_state *uts; 225 void *fdt_base = &__dtb_test_fdt_base_begin; 226 void *fdt_overlay = &__dtb_test_fdt_overlay_begin; 227 void *fdt_overlay_stacked = &__dtb_test_fdt_overlay_stacked_begin; 228 void *fdt_base_copy, *fdt_overlay_copy, *fdt_overlay_stacked_copy; 229 int ret = -ENOMEM; 230 231 uts = calloc(1, sizeof(*uts)); 232 if (!uts) 233 return -ENOMEM; 234 235 ut_assertok(fdt_check_header(fdt_base)); 236 ut_assertok(fdt_check_header(fdt_overlay)); 237 238 fdt_base_copy = malloc(FDT_COPY_SIZE); 239 if (!fdt_base_copy) 240 goto err1; 241 uts->priv = fdt_base_copy; 242 243 fdt_overlay_copy = malloc(FDT_COPY_SIZE); 244 if (!fdt_overlay_copy) 245 goto err2; 246 247 fdt_overlay_stacked_copy = malloc(FDT_COPY_SIZE); 248 if (!fdt_overlay_stacked_copy) 249 goto err3; 250 251 /* 252 * Resize the FDT to 4k so that we have room to operate on 253 * 254 * (and relocate it since the memory might be mapped 255 * read-only) 256 */ 257 ut_assertok(fdt_open_into(fdt_base, fdt_base_copy, FDT_COPY_SIZE)); 258 259 /* 260 * Resize the overlay to 4k so that we have room to operate on 261 * 262 * (and relocate it since the memory might be mapped 263 * read-only) 264 */ 265 ut_assertok(fdt_open_into(fdt_overlay, fdt_overlay_copy, 266 FDT_COPY_SIZE)); 267 268 /* 269 * Resize the stacked overlay to 4k so that we have room to operate on 270 * 271 * (and relocate it since the memory might be mapped 272 * read-only) 273 */ 274 ut_assertok(fdt_open_into(fdt_overlay_stacked, fdt_overlay_stacked_copy, 275 FDT_COPY_SIZE)); 276 277 /* Apply the overlay */ 278 ut_assertok(fdt_overlay_apply(fdt_base_copy, fdt_overlay_copy)); 279 280 /* Apply the stacked overlay */ 281 ut_assertok(fdt_overlay_apply(fdt_base_copy, fdt_overlay_stacked_copy)); 282 283 ret = cmd_ut_category("overlay", tests, n_ents, argc, argv); 284 285 free(fdt_overlay_stacked_copy); 286 err3: 287 free(fdt_overlay_copy); 288 err2: 289 free(fdt_base_copy); 290 err1: 291 free(uts); 292 293 return ret; 294 } 295