1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright (c) 2016-2018, NVIDIA CORPORATION.
8 #include <fdt_support.h>
13 #include <linux/ctype.h>
14 #include <linux/sizes.h>
16 #include <asm/arch/tegra.h>
17 #include <asm/arch-tegra/cboot.h>
18 #include <asm/armv8/mmu.h>
21 * Size of a region that's large enough to hold the relocated U-Boot and all
22 * other allocations made around it (stack, heap, page tables, etc.)
23 * In practice, running "bdinfo" at the shell prompt, the stack reaches about
24 * 5MB from the address selected for ram_top as of the time of writing,
25 * so a 16MB region should be plenty.
27 #define MIN_USABLE_RAM_SIZE SZ_16M
29 * The amount of space we expect to require for stack usage. Used to validate
30 * that all reservations fit into the region selected for the relocation target
32 #define MIN_USABLE_STACK_SIZE SZ_1M
34 DECLARE_GLOBAL_DATA_PTR;
36 extern struct mm_region tegra_mem_map[];
39 * These variables are written to before relocation, and hence cannot be
40 * in.bss, since .bss overlaps the DTB that's appended to the U-Boot binary.
41 * The section attribute forces this into .data and avoids this issue. This
42 * also has the nice side-effect of the content being valid after relocation.
45 /* The number of valid entries in ram_banks[] */
46 static int ram_bank_count __attribute__((section(".data")));
49 * The usable top-of-RAM for U-Boot. This is both:
50 * a) Below 4GB to avoid issues with peripherals that use 32-bit addressing.
51 * b) At the end of a region that has enough space to hold the relocated U-Boot
52 * and all other allocations made around it (stack, heap, page tables, etc.)
54 static u64 ram_top __attribute__((section(".data")));
55 /* The base address of the region of RAM that ends at ram_top */
56 static u64 region_base __attribute__((section(".data")));
59 * Explicitly put this in the .data section because it is written before the
60 * .bss section is zeroed out but it needs to persist.
62 unsigned long cboot_boot_x0 __attribute__((section(".data")));
64 void cboot_save_boot_params(unsigned long x0, unsigned long x1,
65 unsigned long x2, unsigned long x3)
70 int cboot_dram_init(void)
73 const void *cboot_blob = (void *)cboot_boot_x0;
80 na = fdtdec_get_uint(cboot_blob, 0, "#address-cells", 2);
81 ns = fdtdec_get_uint(cboot_blob, 0, "#size-cells", 2);
83 node = fdt_path_offset(cboot_blob, "/memory");
85 pr_err("Can't find /memory node in cboot DTB");
88 prop = fdt_getprop(cboot_blob, node, "reg", &len);
90 pr_err("Can't find /memory/reg property in cboot DTB");
94 /* Calculate the true # of base/size pairs to read */
95 len /= 4; /* Convert bytes to number of cells */
96 len /= (na + ns); /* Convert cells to number of banks */
97 if (len > CONFIG_NR_DRAM_BANKS)
98 len = CONFIG_NR_DRAM_BANKS;
100 /* Parse the /memory node, and save useful entries */
103 for (i = 0; i < len; i++) {
104 u64 bank_start, bank_end, bank_size, usable_bank_size;
106 /* Extract raw memory region data from DTB */
107 bank_start = fdt_read_number(prop, na);
109 bank_size = fdt_read_number(prop, ns);
111 gd->ram_size += bank_size;
112 bank_end = bank_start + bank_size;
113 debug("Bank %d: %llx..%llx (+%llx)\n", i,
114 bank_start, bank_end, bank_size);
117 * Align the bank to MMU section size. This is not strictly
118 * necessary, since the translation table construction code
119 * handles page granularity without issue. However, aligning
120 * the MMU entries reduces the size and number of levels in the
121 * page table, so is worth it.
123 bank_start = ROUND(bank_start, SZ_2M);
124 bank_end = bank_end & ~(SZ_2M - 1);
125 bank_size = bank_end - bank_start;
126 debug(" aligned: %llx..%llx (+%llx)\n",
127 bank_start, bank_end, bank_size);
128 if (bank_end <= bank_start)
131 /* Record data used to create MMU translation tables */
133 /* Index below is deliberately 1-based to skip MMIO entry */
134 tegra_mem_map[ram_bank_count].virt = bank_start;
135 tegra_mem_map[ram_bank_count].phys = bank_start;
136 tegra_mem_map[ram_bank_count].size = bank_size;
137 tegra_mem_map[ram_bank_count].attrs =
138 PTE_BLOCK_MEMTYPE(MT_NORMAL) | PTE_BLOCK_INNER_SHARE;
140 /* Determine best bank to relocate U-Boot into */
141 if (bank_end > SZ_4G)
143 debug(" end %llx (usable)\n", bank_end);
144 usable_bank_size = bank_end - bank_start;
145 debug(" size %llx (usable)\n", usable_bank_size);
146 if ((usable_bank_size >= MIN_USABLE_RAM_SIZE) &&
147 (bank_end > ram_top)) {
149 region_base = bank_start;
150 debug("ram top now %llx\n", ram_top);
154 /* Ensure memory map contains the desired sentinel entry */
155 tegra_mem_map[ram_bank_count + 1].virt = 0;
156 tegra_mem_map[ram_bank_count + 1].phys = 0;
157 tegra_mem_map[ram_bank_count + 1].size = 0;
158 tegra_mem_map[ram_bank_count + 1].attrs = 0;
160 /* Error out if a relocation target couldn't be found */
162 pr_err("Can't find a usable RAM top");
169 int cboot_dram_init_banksize(void)
173 if (ram_bank_count == 0)
176 if ((gd->start_addr_sp - region_base) < MIN_USABLE_STACK_SIZE) {
177 pr_err("Reservations exceed chosen region size");
181 for (i = 0; i < ram_bank_count; i++) {
182 gd->bd->bi_dram[i].start = tegra_mem_map[1 + i].virt;
183 gd->bd->bi_dram[i].size = tegra_mem_map[1 + i].size;
187 gd->pci_ram_top = ram_top;
193 ulong cboot_get_usable_ram_top(ulong total_size)
199 * The following few functions run late during the boot process and dynamically
200 * calculate the load address of various binaries. To keep track of multiple
201 * allocations, some writable list of RAM banks must be used. tegra_mem_map[]
202 * is used for this purpose to avoid making yet another copy of the list of RAM
203 * banks. This is safe because tegra_mem_map[] is only used once during very
204 * early boot to create U-Boot's page tables, long before this code runs. If
205 * this assumption becomes invalid later, we can just fix the code to copy the
206 * list of RAM banks into some private data structure before running.
209 static char *gen_varname(const char *var, const char *ext)
211 size_t len_var = strlen(var);
212 size_t len_ext = strlen(ext);
213 size_t len = len_var + len_ext + 1;
214 char *varext = malloc(len);
219 strcpy(varext + len_var, ext);
223 static void mark_ram_allocated(int bank, u64 allocated_start, u64 allocated_end)
225 u64 bank_start = tegra_mem_map[bank].virt;
226 u64 bank_size = tegra_mem_map[bank].size;
227 u64 bank_end = bank_start + bank_size;
228 bool keep_front = allocated_start != bank_start;
229 bool keep_tail = allocated_end != bank_end;
231 if (keep_front && keep_tail) {
233 * There are CONFIG_NR_DRAM_BANKS DRAM entries in the array,
234 * starting at index 1 (index 0 is MMIO). So, we are at DRAM
235 * entry "bank" not "bank - 1" as for a typical 0-base array.
236 * The number of remaining DRAM entries is therefore
237 * "CONFIG_NR_DRAM_BANKS - bank". We want to duplicate the
238 * current entry and shift up the remaining entries, dropping
239 * the last one. Thus, we must copy one fewer entry than the
242 memmove(&tegra_mem_map[bank + 1], &tegra_mem_map[bank],
243 CONFIG_NR_DRAM_BANKS - bank - 1);
244 tegra_mem_map[bank].size = allocated_start - bank_start;
246 tegra_mem_map[bank].virt = allocated_end;
247 tegra_mem_map[bank].phys = allocated_end;
248 tegra_mem_map[bank].size = bank_end - allocated_end;
249 } else if (keep_front) {
250 tegra_mem_map[bank].size = allocated_start - bank_start;
251 } else if (keep_tail) {
252 tegra_mem_map[bank].virt = allocated_end;
253 tegra_mem_map[bank].phys = allocated_end;
254 tegra_mem_map[bank].size = bank_end - allocated_end;
257 * We could move all subsequent banks down in the array but
258 * that's not necessary for subsequent allocations to work, so
261 tegra_mem_map[bank].size = 0;
265 static void reserve_ram(u64 start, u64 size)
268 u64 end = start + size;
270 for (bank = 1; bank <= CONFIG_NR_DRAM_BANKS; bank++) {
271 u64 bank_start = tegra_mem_map[bank].virt;
272 u64 bank_size = tegra_mem_map[bank].size;
273 u64 bank_end = bank_start + bank_size;
275 if (end <= bank_start || start > bank_end)
277 mark_ram_allocated(bank, start, end);
282 static u64 alloc_ram(u64 size, u64 align, u64 offset)
286 for (bank = 1; bank <= CONFIG_NR_DRAM_BANKS; bank++) {
287 u64 bank_start = tegra_mem_map[bank].virt;
288 u64 bank_size = tegra_mem_map[bank].size;
289 u64 bank_end = bank_start + bank_size;
290 u64 allocated = ROUND(bank_start, align) + offset;
291 u64 allocated_end = allocated + size;
293 if (allocated_end > bank_end)
295 mark_ram_allocated(bank, allocated, allocated_end);
301 static void set_calculated_aliases(char *aliases, u64 address)
306 aliases = strdup(aliases);
308 pr_err("strdup(aliases) failed");
314 alias = strsep(&tmp, " ");
317 debug("%s: alias: %s\n", __func__, alias);
318 err = env_set_hex(alias, address);
320 pr_err("Could not set %s\n", alias);
326 static void set_calculated_env_var(const char *var)
339 var_size = gen_varname(var, "_size");
342 var_align = gen_varname(var, "_align");
344 goto out_free_var_size;
345 var_offset = gen_varname(var, "_offset");
347 goto out_free_var_align;
348 var_aliases = gen_varname(var, "_aliases");
350 goto out_free_var_offset;
352 size = env_get_hex(var_size, 0);
354 pr_err("%s not set or zero\n", var_size);
355 goto out_free_var_aliases;
357 align = env_get_hex(var_align, 1);
358 /* Handle extant variables, but with a value of 0 */
361 offset = env_get_hex(var_offset, 0);
362 aliases = env_get(var_aliases);
364 debug("%s: Calc var %s; size=%llx, align=%llx, offset=%llx\n",
365 __func__, var, size, align, offset);
367 debug("%s: Aliases: %s\n", __func__, aliases);
369 address = alloc_ram(size, align, offset);
371 pr_err("Could not allocate %s\n", var);
372 goto out_free_var_aliases;
374 debug("%s: Address %llx\n", __func__, address);
376 err = env_set_hex(var, address);
378 pr_err("Could not set %s\n", var);
380 set_calculated_aliases(aliases, address);
382 out_free_var_aliases:
393 static void dump_ram_banks(void)
397 for (bank = 1; bank <= CONFIG_NR_DRAM_BANKS; bank++) {
398 u64 bank_start = tegra_mem_map[bank].virt;
399 u64 bank_size = tegra_mem_map[bank].size;
400 u64 bank_end = bank_start + bank_size;
404 printf("%d: %010llx..%010llx (+%010llx)\n", bank - 1,
405 bank_start, bank_end, bank_size);
410 static void set_calculated_env_vars(void)
412 char *vars, *tmp, *var;
415 printf("RAM banks before any calculated env. var.s:\n");
419 reserve_ram(cboot_boot_x0, fdt_totalsize(cboot_boot_x0));
422 printf("RAM after reserving cboot DTB:\n");
426 vars = env_get("calculated_vars");
428 debug("%s: No env var calculated_vars\n", __func__);
434 pr_err("strdup(calculated_vars) failed");
440 var = strsep(&tmp, " ");
443 debug("%s: var: %s\n", __func__, var);
444 set_calculated_env_var(var);
446 printf("RAM banks after allocating %s:\n", var);
454 static int set_fdt_addr(void)
458 ret = env_set_hex("fdt_addr", cboot_boot_x0);
460 printf("Failed to set fdt_addr to point at DTB: %d\n", ret);
468 * Attempt to use /chosen/nvidia,ether-mac in the cboot DTB to U-Boot's
469 * ethaddr environment variable if possible.
471 static int cboot_get_ethaddr_legacy(const void *fdt, uint8_t mac[ETH_ALEN])
473 const char *const properties[] = {
474 "nvidia,ethernet-mac",
481 node = fdt_path_offset(fdt, "/chosen");
483 printf("Can't find /chosen node in cboot DTB\n");
487 for (i = 0; i < ARRAY_SIZE(properties); i++) {
488 prop = fdt_getprop(fdt, node, properties[i], &len);
494 printf("Can't find Ethernet MAC address in cboot DTB\n");
498 eth_parse_enetaddr(prop, mac);
500 if (!is_valid_ethaddr(mac)) {
501 printf("Invalid MAC address: %s\n", prop);
505 debug("Legacy MAC address: %pM\n", mac);
510 int cboot_get_ethaddr(const void *fdt, uint8_t mac[ETH_ALEN])
512 int node, len, err = 0;
516 path = fdt_get_alias(fdt, "ethernet");
522 debug("ethernet alias found: %s\n", path);
524 node = fdt_path_offset(fdt, path);
530 prop = fdt_getprop(fdt, node, "local-mac-address", &len);
536 if (len != ETH_ALEN) {
541 debug("MAC address: %pM\n", prop);
542 memcpy(mac, prop, ETH_ALEN);
546 err = cboot_get_ethaddr_legacy(fdt, mac);
551 static char *strip(const char *ptr)
555 while (*ptr && isblank(*ptr))
567 while (isblank(*end))
570 return strndup(ptr, end - ptr + 1);
573 static char *cboot_get_bootargs(const void *fdt)
578 offset = fdt_path_offset(fdt, "/chosen");
582 args = fdt_getprop(fdt, offset, "bootargs", &len);
589 int cboot_late_init(void)
591 const void *fdt = (const void *)cboot_boot_x0;
592 uint8_t mac[ETH_ALEN];
596 set_calculated_env_vars();
598 * Ignore errors here; the value may not be used depending on
599 * extlinux.conf or boot script content.
603 /* Ignore errors here; not all cases care about Ethernet addresses */
604 err = cboot_get_ethaddr(fdt, mac);
606 void *blob = (void *)gd->fdt_blob;
608 err = fdtdec_set_ethernet_mac_address(blob, mac, sizeof(mac));
610 printf("failed to set MAC address %pM: %d\n", mac, err);
613 bootargs = cboot_get_bootargs(fdt);
615 env_set("cbootargs", bootargs);