Thierry Reding | a0dbc13 | 2019-04-15 11:32:28 +0200 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0+ |
| 2 | /* |
| 3 | * Copyright (c) 2016-2018, NVIDIA CORPORATION. |
| 4 | */ |
| 5 | |
| 6 | #include <common.h> |
Thierry Reding | 34e12e0 | 2019-04-15 11:32:30 +0200 | [diff] [blame^] | 7 | #include <environment.h> |
Thierry Reding | a0dbc13 | 2019-04-15 11:32:28 +0200 | [diff] [blame] | 8 | #include <fdt_support.h> |
| 9 | #include <fdtdec.h> |
| 10 | #include <stdlib.h> |
| 11 | |
| 12 | #include <linux/sizes.h> |
| 13 | |
| 14 | #include <asm/arch/tegra.h> |
| 15 | #include <asm/arch-tegra/cboot.h> |
| 16 | #include <asm/armv8/mmu.h> |
| 17 | |
| 18 | /* |
| 19 | * Size of a region that's large enough to hold the relocated U-Boot and all |
| 20 | * other allocations made around it (stack, heap, page tables, etc.) |
| 21 | * In practice, running "bdinfo" at the shell prompt, the stack reaches about |
| 22 | * 5MB from the address selected for ram_top as of the time of writing, |
| 23 | * so a 16MB region should be plenty. |
| 24 | */ |
| 25 | #define MIN_USABLE_RAM_SIZE SZ_16M |
| 26 | /* |
| 27 | * The amount of space we expect to require for stack usage. Used to validate |
| 28 | * that all reservations fit into the region selected for the relocation target |
| 29 | */ |
| 30 | #define MIN_USABLE_STACK_SIZE SZ_1M |
| 31 | |
| 32 | DECLARE_GLOBAL_DATA_PTR; |
| 33 | |
| 34 | extern struct mm_region tegra_mem_map[]; |
| 35 | |
| 36 | /* |
| 37 | * These variables are written to before relocation, and hence cannot be |
| 38 | * in.bss, since .bss overlaps the DTB that's appended to the U-Boot binary. |
| 39 | * The section attribute forces this into .data and avoids this issue. This |
| 40 | * also has the nice side-effect of the content being valid after relocation. |
| 41 | */ |
| 42 | |
| 43 | /* The number of valid entries in ram_banks[] */ |
| 44 | static int ram_bank_count __attribute__((section(".data"))); |
| 45 | |
| 46 | /* |
| 47 | * The usable top-of-RAM for U-Boot. This is both: |
| 48 | * a) Below 4GB to avoid issues with peripherals that use 32-bit addressing. |
| 49 | * b) At the end of a region that has enough space to hold the relocated U-Boot |
| 50 | * and all other allocations made around it (stack, heap, page tables, etc.) |
| 51 | */ |
| 52 | static u64 ram_top __attribute__((section(".data"))); |
| 53 | /* The base address of the region of RAM that ends at ram_top */ |
| 54 | static u64 region_base __attribute__((section(".data"))); |
| 55 | |
Thierry Reding | ce353ba | 2019-04-15 11:32:29 +0200 | [diff] [blame] | 56 | /* |
| 57 | * Explicitly put this in the .data section because it is written before the |
| 58 | * .bss section is zeroed out but it needs to persist. |
| 59 | */ |
| 60 | unsigned long cboot_boot_x0 __attribute__((section(".data"))); |
| 61 | |
| 62 | void cboot_save_boot_params(unsigned long x0, unsigned long x1, |
| 63 | unsigned long x2, unsigned long x3) |
| 64 | { |
| 65 | cboot_boot_x0 = x0; |
| 66 | } |
| 67 | |
Thierry Reding | a0dbc13 | 2019-04-15 11:32:28 +0200 | [diff] [blame] | 68 | int cboot_dram_init(void) |
| 69 | { |
| 70 | unsigned int na, ns; |
| 71 | const void *cboot_blob = (void *)cboot_boot_x0; |
| 72 | int node, len, i; |
| 73 | const u32 *prop; |
| 74 | |
| 75 | if (!cboot_blob) |
| 76 | return -EINVAL; |
| 77 | |
| 78 | na = fdtdec_get_uint(cboot_blob, 0, "#address-cells", 2); |
| 79 | ns = fdtdec_get_uint(cboot_blob, 0, "#size-cells", 2); |
| 80 | |
| 81 | node = fdt_path_offset(cboot_blob, "/memory"); |
| 82 | if (node < 0) { |
| 83 | pr_err("Can't find /memory node in cboot DTB"); |
| 84 | hang(); |
| 85 | } |
| 86 | prop = fdt_getprop(cboot_blob, node, "reg", &len); |
| 87 | if (!prop) { |
| 88 | pr_err("Can't find /memory/reg property in cboot DTB"); |
| 89 | hang(); |
| 90 | } |
| 91 | |
| 92 | /* Calculate the true # of base/size pairs to read */ |
| 93 | len /= 4; /* Convert bytes to number of cells */ |
| 94 | len /= (na + ns); /* Convert cells to number of banks */ |
| 95 | if (len > CONFIG_NR_DRAM_BANKS) |
| 96 | len = CONFIG_NR_DRAM_BANKS; |
| 97 | |
| 98 | /* Parse the /memory node, and save useful entries */ |
| 99 | gd->ram_size = 0; |
| 100 | ram_bank_count = 0; |
| 101 | for (i = 0; i < len; i++) { |
| 102 | u64 bank_start, bank_end, bank_size, usable_bank_size; |
| 103 | |
| 104 | /* Extract raw memory region data from DTB */ |
| 105 | bank_start = fdt_read_number(prop, na); |
| 106 | prop += na; |
| 107 | bank_size = fdt_read_number(prop, ns); |
| 108 | prop += ns; |
| 109 | gd->ram_size += bank_size; |
| 110 | bank_end = bank_start + bank_size; |
| 111 | debug("Bank %d: %llx..%llx (+%llx)\n", i, |
| 112 | bank_start, bank_end, bank_size); |
| 113 | |
| 114 | /* |
| 115 | * Align the bank to MMU section size. This is not strictly |
| 116 | * necessary, since the translation table construction code |
| 117 | * handles page granularity without issue. However, aligning |
| 118 | * the MMU entries reduces the size and number of levels in the |
| 119 | * page table, so is worth it. |
| 120 | */ |
| 121 | bank_start = ROUND(bank_start, SZ_2M); |
| 122 | bank_end = bank_end & ~(SZ_2M - 1); |
| 123 | bank_size = bank_end - bank_start; |
| 124 | debug(" aligned: %llx..%llx (+%llx)\n", |
| 125 | bank_start, bank_end, bank_size); |
| 126 | if (bank_end <= bank_start) |
| 127 | continue; |
| 128 | |
| 129 | /* Record data used to create MMU translation tables */ |
| 130 | ram_bank_count++; |
| 131 | /* Index below is deliberately 1-based to skip MMIO entry */ |
| 132 | tegra_mem_map[ram_bank_count].virt = bank_start; |
| 133 | tegra_mem_map[ram_bank_count].phys = bank_start; |
| 134 | tegra_mem_map[ram_bank_count].size = bank_size; |
| 135 | tegra_mem_map[ram_bank_count].attrs = |
| 136 | PTE_BLOCK_MEMTYPE(MT_NORMAL) | PTE_BLOCK_INNER_SHARE; |
| 137 | |
| 138 | /* Determine best bank to relocate U-Boot into */ |
| 139 | if (bank_end > SZ_4G) |
| 140 | bank_end = SZ_4G; |
| 141 | debug(" end %llx (usable)\n", bank_end); |
| 142 | usable_bank_size = bank_end - bank_start; |
| 143 | debug(" size %llx (usable)\n", usable_bank_size); |
| 144 | if ((usable_bank_size >= MIN_USABLE_RAM_SIZE) && |
| 145 | (bank_end > ram_top)) { |
| 146 | ram_top = bank_end; |
| 147 | region_base = bank_start; |
| 148 | debug("ram top now %llx\n", ram_top); |
| 149 | } |
| 150 | } |
| 151 | |
| 152 | /* Ensure memory map contains the desired sentinel entry */ |
| 153 | tegra_mem_map[ram_bank_count + 1].virt = 0; |
| 154 | tegra_mem_map[ram_bank_count + 1].phys = 0; |
| 155 | tegra_mem_map[ram_bank_count + 1].size = 0; |
| 156 | tegra_mem_map[ram_bank_count + 1].attrs = 0; |
| 157 | |
| 158 | /* Error out if a relocation target couldn't be found */ |
| 159 | if (!ram_top) { |
| 160 | pr_err("Can't find a usable RAM top"); |
| 161 | hang(); |
| 162 | } |
| 163 | |
| 164 | return 0; |
| 165 | } |
| 166 | |
| 167 | int cboot_dram_init_banksize(void) |
| 168 | { |
| 169 | int i; |
| 170 | |
| 171 | if (ram_bank_count == 0) |
| 172 | return -EINVAL; |
| 173 | |
| 174 | if ((gd->start_addr_sp - region_base) < MIN_USABLE_STACK_SIZE) { |
| 175 | pr_err("Reservations exceed chosen region size"); |
| 176 | hang(); |
| 177 | } |
| 178 | |
| 179 | for (i = 0; i < ram_bank_count; i++) { |
| 180 | gd->bd->bi_dram[i].start = tegra_mem_map[1 + i].virt; |
| 181 | gd->bd->bi_dram[i].size = tegra_mem_map[1 + i].size; |
| 182 | } |
| 183 | |
| 184 | #ifdef CONFIG_PCI |
| 185 | gd->pci_ram_top = ram_top; |
| 186 | #endif |
| 187 | |
| 188 | return 0; |
| 189 | } |
| 190 | |
| 191 | ulong cboot_get_usable_ram_top(ulong total_size) |
| 192 | { |
| 193 | return ram_top; |
| 194 | } |
| 195 | |
| 196 | /* |
| 197 | * The following few functions run late during the boot process and dynamically |
| 198 | * calculate the load address of various binaries. To keep track of multiple |
| 199 | * allocations, some writable list of RAM banks must be used. tegra_mem_map[] |
| 200 | * is used for this purpose to avoid making yet another copy of the list of RAM |
| 201 | * banks. This is safe because tegra_mem_map[] is only used once during very |
| 202 | * early boot to create U-Boot's page tables, long before this code runs. If |
| 203 | * this assumption becomes invalid later, we can just fix the code to copy the |
| 204 | * list of RAM banks into some private data structure before running. |
| 205 | */ |
| 206 | |
| 207 | static char *gen_varname(const char *var, const char *ext) |
| 208 | { |
| 209 | size_t len_var = strlen(var); |
| 210 | size_t len_ext = strlen(ext); |
| 211 | size_t len = len_var + len_ext + 1; |
| 212 | char *varext = malloc(len); |
| 213 | |
| 214 | if (!varext) |
| 215 | return 0; |
| 216 | strcpy(varext, var); |
| 217 | strcpy(varext + len_var, ext); |
| 218 | return varext; |
| 219 | } |
| 220 | |
| 221 | static void mark_ram_allocated(int bank, u64 allocated_start, u64 allocated_end) |
| 222 | { |
| 223 | u64 bank_start = tegra_mem_map[bank].virt; |
| 224 | u64 bank_size = tegra_mem_map[bank].size; |
| 225 | u64 bank_end = bank_start + bank_size; |
| 226 | bool keep_front = allocated_start != bank_start; |
| 227 | bool keep_tail = allocated_end != bank_end; |
| 228 | |
| 229 | if (keep_front && keep_tail) { |
| 230 | /* |
| 231 | * There are CONFIG_NR_DRAM_BANKS DRAM entries in the array, |
| 232 | * starting at index 1 (index 0 is MMIO). So, we are at DRAM |
| 233 | * entry "bank" not "bank - 1" as for a typical 0-base array. |
| 234 | * The number of remaining DRAM entries is therefore |
| 235 | * "CONFIG_NR_DRAM_BANKS - bank". We want to duplicate the |
| 236 | * current entry and shift up the remaining entries, dropping |
| 237 | * the last one. Thus, we must copy one fewer entry than the |
| 238 | * number remaining. |
| 239 | */ |
| 240 | memmove(&tegra_mem_map[bank + 1], &tegra_mem_map[bank], |
| 241 | CONFIG_NR_DRAM_BANKS - bank - 1); |
| 242 | tegra_mem_map[bank].size = allocated_start - bank_start; |
| 243 | bank++; |
| 244 | tegra_mem_map[bank].virt = allocated_end; |
| 245 | tegra_mem_map[bank].phys = allocated_end; |
| 246 | tegra_mem_map[bank].size = bank_end - allocated_end; |
| 247 | } else if (keep_front) { |
| 248 | tegra_mem_map[bank].size = allocated_start - bank_start; |
| 249 | } else if (keep_tail) { |
| 250 | tegra_mem_map[bank].virt = allocated_end; |
| 251 | tegra_mem_map[bank].phys = allocated_end; |
| 252 | tegra_mem_map[bank].size = bank_end - allocated_end; |
| 253 | } else { |
| 254 | /* |
| 255 | * We could move all subsequent banks down in the array but |
| 256 | * that's not necessary for subsequent allocations to work, so |
| 257 | * we skip doing so. |
| 258 | */ |
| 259 | tegra_mem_map[bank].size = 0; |
| 260 | } |
| 261 | } |
| 262 | |
| 263 | static void reserve_ram(u64 start, u64 size) |
| 264 | { |
| 265 | int bank; |
| 266 | u64 end = start + size; |
| 267 | |
| 268 | for (bank = 1; bank <= CONFIG_NR_DRAM_BANKS; bank++) { |
| 269 | u64 bank_start = tegra_mem_map[bank].virt; |
| 270 | u64 bank_size = tegra_mem_map[bank].size; |
| 271 | u64 bank_end = bank_start + bank_size; |
| 272 | |
| 273 | if (end <= bank_start || start > bank_end) |
| 274 | continue; |
| 275 | mark_ram_allocated(bank, start, end); |
| 276 | break; |
| 277 | } |
| 278 | } |
| 279 | |
| 280 | static u64 alloc_ram(u64 size, u64 align, u64 offset) |
| 281 | { |
| 282 | int bank; |
| 283 | |
| 284 | for (bank = 1; bank <= CONFIG_NR_DRAM_BANKS; bank++) { |
| 285 | u64 bank_start = tegra_mem_map[bank].virt; |
| 286 | u64 bank_size = tegra_mem_map[bank].size; |
| 287 | u64 bank_end = bank_start + bank_size; |
| 288 | u64 allocated = ROUND(bank_start, align) + offset; |
| 289 | u64 allocated_end = allocated + size; |
| 290 | |
| 291 | if (allocated_end > bank_end) |
| 292 | continue; |
| 293 | mark_ram_allocated(bank, allocated, allocated_end); |
| 294 | return allocated; |
| 295 | } |
| 296 | return 0; |
| 297 | } |
| 298 | |
| 299 | static void set_calculated_aliases(char *aliases, u64 address) |
| 300 | { |
| 301 | char *tmp, *alias; |
| 302 | int err; |
| 303 | |
| 304 | aliases = strdup(aliases); |
| 305 | if (!aliases) { |
| 306 | pr_err("strdup(aliases) failed"); |
| 307 | return; |
| 308 | } |
| 309 | |
| 310 | tmp = aliases; |
| 311 | while (true) { |
| 312 | alias = strsep(&tmp, " "); |
| 313 | if (!alias) |
| 314 | break; |
| 315 | debug("%s: alias: %s\n", __func__, alias); |
| 316 | err = env_set_hex(alias, address); |
| 317 | if (err) |
| 318 | pr_err("Could not set %s\n", alias); |
| 319 | } |
| 320 | |
| 321 | free(aliases); |
| 322 | } |
| 323 | |
| 324 | static void set_calculated_env_var(const char *var) |
| 325 | { |
| 326 | char *var_size; |
| 327 | char *var_align; |
| 328 | char *var_offset; |
| 329 | char *var_aliases; |
| 330 | u64 size; |
| 331 | u64 align; |
| 332 | u64 offset; |
| 333 | char *aliases; |
| 334 | u64 address; |
| 335 | int err; |
| 336 | |
| 337 | var_size = gen_varname(var, "_size"); |
| 338 | if (!var_size) |
| 339 | return; |
| 340 | var_align = gen_varname(var, "_align"); |
| 341 | if (!var_align) |
| 342 | goto out_free_var_size; |
| 343 | var_offset = gen_varname(var, "_offset"); |
| 344 | if (!var_offset) |
| 345 | goto out_free_var_align; |
| 346 | var_aliases = gen_varname(var, "_aliases"); |
| 347 | if (!var_aliases) |
| 348 | goto out_free_var_offset; |
| 349 | |
| 350 | size = env_get_hex(var_size, 0); |
| 351 | if (!size) { |
| 352 | pr_err("%s not set or zero\n", var_size); |
| 353 | goto out_free_var_aliases; |
| 354 | } |
| 355 | align = env_get_hex(var_align, 1); |
| 356 | /* Handle extant variables, but with a value of 0 */ |
| 357 | if (!align) |
| 358 | align = 1; |
| 359 | offset = env_get_hex(var_offset, 0); |
| 360 | aliases = env_get(var_aliases); |
| 361 | |
| 362 | debug("%s: Calc var %s; size=%llx, align=%llx, offset=%llx\n", |
| 363 | __func__, var, size, align, offset); |
| 364 | if (aliases) |
| 365 | debug("%s: Aliases: %s\n", __func__, aliases); |
| 366 | |
| 367 | address = alloc_ram(size, align, offset); |
| 368 | if (!address) { |
| 369 | pr_err("Could not allocate %s\n", var); |
| 370 | goto out_free_var_aliases; |
| 371 | } |
| 372 | debug("%s: Address %llx\n", __func__, address); |
| 373 | |
| 374 | err = env_set_hex(var, address); |
| 375 | if (err) |
| 376 | pr_err("Could not set %s\n", var); |
| 377 | if (aliases) |
| 378 | set_calculated_aliases(aliases, address); |
| 379 | |
| 380 | out_free_var_aliases: |
| 381 | free(var_aliases); |
| 382 | out_free_var_offset: |
| 383 | free(var_offset); |
| 384 | out_free_var_align: |
| 385 | free(var_align); |
| 386 | out_free_var_size: |
| 387 | free(var_size); |
| 388 | } |
| 389 | |
| 390 | #ifdef DEBUG |
| 391 | static void dump_ram_banks(void) |
| 392 | { |
| 393 | int bank; |
| 394 | |
| 395 | for (bank = 1; bank <= CONFIG_NR_DRAM_BANKS; bank++) { |
| 396 | u64 bank_start = tegra_mem_map[bank].virt; |
| 397 | u64 bank_size = tegra_mem_map[bank].size; |
| 398 | u64 bank_end = bank_start + bank_size; |
| 399 | |
| 400 | if (!bank_size) |
| 401 | continue; |
| 402 | printf("%d: %010llx..%010llx (+%010llx)\n", bank - 1, |
| 403 | bank_start, bank_end, bank_size); |
| 404 | } |
| 405 | } |
| 406 | #endif |
| 407 | |
| 408 | static void set_calculated_env_vars(void) |
| 409 | { |
| 410 | char *vars, *tmp, *var; |
| 411 | |
| 412 | #ifdef DEBUG |
| 413 | printf("RAM banks before any calculated env. var.s:\n"); |
| 414 | dump_ram_banks(); |
| 415 | #endif |
| 416 | |
| 417 | reserve_ram(cboot_boot_x0, fdt_totalsize(cboot_boot_x0)); |
| 418 | |
| 419 | #ifdef DEBUG |
| 420 | printf("RAM after reserving cboot DTB:\n"); |
| 421 | dump_ram_banks(); |
| 422 | #endif |
| 423 | |
| 424 | vars = env_get("calculated_vars"); |
| 425 | if (!vars) { |
| 426 | debug("%s: No env var calculated_vars\n", __func__); |
| 427 | return; |
| 428 | } |
| 429 | |
| 430 | vars = strdup(vars); |
| 431 | if (!vars) { |
| 432 | pr_err("strdup(calculated_vars) failed"); |
| 433 | return; |
| 434 | } |
| 435 | |
| 436 | tmp = vars; |
| 437 | while (true) { |
| 438 | var = strsep(&tmp, " "); |
| 439 | if (!var) |
| 440 | break; |
| 441 | debug("%s: var: %s\n", __func__, var); |
| 442 | set_calculated_env_var(var); |
| 443 | #ifdef DEBUG |
| 444 | printf("RAM banks after allocating %s:\n", var); |
| 445 | dump_ram_banks(); |
| 446 | #endif |
| 447 | } |
| 448 | |
| 449 | free(vars); |
| 450 | } |
| 451 | |
| 452 | static int set_fdt_addr(void) |
| 453 | { |
| 454 | int ret; |
| 455 | |
| 456 | ret = env_set_hex("fdt_addr", cboot_boot_x0); |
| 457 | if (ret) { |
| 458 | printf("Failed to set fdt_addr to point at DTB: %d\n", ret); |
| 459 | return ret; |
| 460 | } |
| 461 | |
| 462 | return 0; |
| 463 | } |
| 464 | |
| 465 | /* |
| 466 | * Attempt to use /chosen/nvidia,ether-mac in the cboot DTB to U-Boot's |
| 467 | * ethaddr environment variable if possible. |
| 468 | */ |
Thierry Reding | 34e12e0 | 2019-04-15 11:32:30 +0200 | [diff] [blame^] | 469 | static int cboot_get_ethaddr_legacy(const void *fdt, uint8_t mac[ETH_ALEN]) |
Thierry Reding | a0dbc13 | 2019-04-15 11:32:28 +0200 | [diff] [blame] | 470 | { |
Thierry Reding | 34e12e0 | 2019-04-15 11:32:30 +0200 | [diff] [blame^] | 471 | const char *const properties[] = { |
| 472 | "nvidia,ethernet-mac", |
| 473 | "nvidia,ether-mac", |
| 474 | }; |
| 475 | const char *prop; |
| 476 | unsigned int i; |
| 477 | int node, len; |
Thierry Reding | a0dbc13 | 2019-04-15 11:32:28 +0200 | [diff] [blame] | 478 | |
Thierry Reding | 34e12e0 | 2019-04-15 11:32:30 +0200 | [diff] [blame^] | 479 | node = fdt_path_offset(fdt, "/chosen"); |
Thierry Reding | a0dbc13 | 2019-04-15 11:32:28 +0200 | [diff] [blame] | 480 | if (node < 0) { |
| 481 | printf("Can't find /chosen node in cboot DTB\n"); |
| 482 | return node; |
| 483 | } |
Thierry Reding | 34e12e0 | 2019-04-15 11:32:30 +0200 | [diff] [blame^] | 484 | |
| 485 | for (i = 0; i < ARRAY_SIZE(properties); i++) { |
| 486 | prop = fdt_getprop(fdt, node, properties[i], &len); |
| 487 | if (prop) |
| 488 | break; |
| 489 | } |
| 490 | |
Thierry Reding | a0dbc13 | 2019-04-15 11:32:28 +0200 | [diff] [blame] | 491 | if (!prop) { |
Thierry Reding | 34e12e0 | 2019-04-15 11:32:30 +0200 | [diff] [blame^] | 492 | printf("Can't find Ethernet MAC address in cboot DTB\n"); |
Thierry Reding | a0dbc13 | 2019-04-15 11:32:28 +0200 | [diff] [blame] | 493 | return -ENOENT; |
| 494 | } |
| 495 | |
Thierry Reding | 34e12e0 | 2019-04-15 11:32:30 +0200 | [diff] [blame^] | 496 | eth_parse_enetaddr(prop, mac); |
| 497 | |
| 498 | if (!is_valid_ethaddr(mac)) { |
| 499 | printf("Invalid MAC address: %s\n", prop); |
| 500 | return -EINVAL; |
Thierry Reding | a0dbc13 | 2019-04-15 11:32:28 +0200 | [diff] [blame] | 501 | } |
| 502 | |
Thierry Reding | 34e12e0 | 2019-04-15 11:32:30 +0200 | [diff] [blame^] | 503 | debug("Legacy MAC address: %pM\n", mac); |
| 504 | |
Thierry Reding | a0dbc13 | 2019-04-15 11:32:28 +0200 | [diff] [blame] | 505 | return 0; |
| 506 | } |
| 507 | |
Thierry Reding | 34e12e0 | 2019-04-15 11:32:30 +0200 | [diff] [blame^] | 508 | int cboot_get_ethaddr(const void *fdt, uint8_t mac[ETH_ALEN]) |
| 509 | { |
| 510 | int node, len, err = 0; |
| 511 | const uchar *prop; |
| 512 | const char *path; |
| 513 | |
| 514 | path = fdt_get_alias(fdt, "ethernet"); |
| 515 | if (!path) { |
| 516 | err = -ENOENT; |
| 517 | goto out; |
| 518 | } |
| 519 | |
| 520 | debug("ethernet alias found: %s\n", path); |
| 521 | |
| 522 | node = fdt_path_offset(fdt, path); |
| 523 | if (node < 0) { |
| 524 | err = -ENOENT; |
| 525 | goto out; |
| 526 | } |
| 527 | |
| 528 | prop = fdt_getprop(fdt, node, "local-mac-address", &len); |
| 529 | if (!prop) { |
| 530 | err = -ENOENT; |
| 531 | goto out; |
| 532 | } |
| 533 | |
| 534 | if (len != ETH_ALEN) { |
| 535 | err = -EINVAL; |
| 536 | goto out; |
| 537 | } |
| 538 | |
| 539 | debug("MAC address: %pM\n", prop); |
| 540 | memcpy(mac, prop, ETH_ALEN); |
| 541 | |
| 542 | out: |
| 543 | if (err < 0) |
| 544 | err = cboot_get_ethaddr_legacy(fdt, mac); |
| 545 | |
| 546 | return err; |
| 547 | } |
| 548 | |
Thierry Reding | a0dbc13 | 2019-04-15 11:32:28 +0200 | [diff] [blame] | 549 | int cboot_late_init(void) |
| 550 | { |
Thierry Reding | 34e12e0 | 2019-04-15 11:32:30 +0200 | [diff] [blame^] | 551 | const void *fdt = (const void *)cboot_boot_x0; |
| 552 | uint8_t mac[ETH_ALEN]; |
| 553 | int err; |
| 554 | |
Thierry Reding | a0dbc13 | 2019-04-15 11:32:28 +0200 | [diff] [blame] | 555 | set_calculated_env_vars(); |
| 556 | /* |
| 557 | * Ignore errors here; the value may not be used depending on |
| 558 | * extlinux.conf or boot script content. |
| 559 | */ |
| 560 | set_fdt_addr(); |
Thierry Reding | 34e12e0 | 2019-04-15 11:32:30 +0200 | [diff] [blame^] | 561 | |
Thierry Reding | a0dbc13 | 2019-04-15 11:32:28 +0200 | [diff] [blame] | 562 | /* Ignore errors here; not all cases care about Ethernet addresses */ |
Thierry Reding | 34e12e0 | 2019-04-15 11:32:30 +0200 | [diff] [blame^] | 563 | err = cboot_get_ethaddr(fdt, mac); |
| 564 | if (!err) { |
| 565 | void *blob = (void *)gd->fdt_blob; |
| 566 | |
| 567 | err = fdtdec_set_ethernet_mac_address(blob, mac, sizeof(mac)); |
| 568 | if (err < 0) |
| 569 | printf("failed to set MAC address %pM: %d\n", mac, err); |
| 570 | } |
Thierry Reding | a0dbc13 | 2019-04-15 11:32:28 +0200 | [diff] [blame] | 571 | |
| 572 | return 0; |
| 573 | } |