1 // SPDX-License-Identifier: GPL-2.0-only 2 3 #include <linux/kernel.h> 4 #include <linux/libfdt.h> 5 #include <linux/sizes.h> 6 7 static const void *get_prop(const void *fdt, const char *node_path, 8 const char *property, int minlen) 9 { 10 const void *prop; 11 int offset, len; 12 13 offset = fdt_path_offset(fdt, node_path); 14 if (offset < 0) 15 return NULL; 16 17 prop = fdt_getprop(fdt, offset, property, &len); 18 if (!prop || len < minlen) 19 return NULL; 20 21 return prop; 22 } 23 24 static uint32_t get_cells(const void *fdt, const char *name) 25 { 26 const fdt32_t *prop = get_prop(fdt, "/", name, sizeof(fdt32_t)); 27 28 if (!prop) { 29 /* default */ 30 return 1; 31 } 32 33 return fdt32_ld(prop); 34 } 35 36 static uint64_t get_val(const fdt32_t *cells, uint32_t ncells) 37 { 38 uint64_t r; 39 40 r = fdt32_ld(cells); 41 if (ncells > 1) 42 r = (r << 32) | fdt32_ld(cells + 1); 43 44 return r; 45 } 46 47 /* 48 * Check the start of physical memory 49 * 50 * Traditionally, the start address of physical memory is obtained by masking 51 * the program counter. However, this does require that this address is a 52 * multiple of 128 MiB, precluding booting Linux on platforms where this 53 * requirement is not fulfilled. 54 * Hence validate the calculated address against the memory information in the 55 * DTB, and, if out-of-range, replace it by the real start address. 56 * To preserve backwards compatibility (systems reserving a block of memory 57 * at the start of physical memory, kdump, ...), the traditional method is 58 * used if it yields a valid address, unless the "linux,usable-memory-range" 59 * property is present. 60 * 61 * Return value: start address of physical memory to use 62 */ 63 uint32_t fdt_check_mem_start(uint32_t mem_start, const void *fdt) 64 { 65 uint32_t addr_cells, size_cells, usable_base, base; 66 uint32_t fdt_mem_start = 0xffffffff; 67 const fdt32_t *usable, *reg, *endp; 68 uint64_t size, usable_end, end; 69 const char *type; 70 int offset, len; 71 72 if (!fdt) 73 return mem_start; 74 75 if (fdt_magic(fdt) != FDT_MAGIC) 76 return mem_start; 77 78 /* There may be multiple cells on LPAE platforms */ 79 addr_cells = get_cells(fdt, "#address-cells"); 80 size_cells = get_cells(fdt, "#size-cells"); 81 if (addr_cells > 2 || size_cells > 2) 82 return mem_start; 83 84 /* 85 * Usable memory in case of a crash dump kernel 86 * This property describes a limitation: memory within this range is 87 * only valid when also described through another mechanism 88 */ 89 usable = get_prop(fdt, "/chosen", "linux,usable-memory-range", 90 (addr_cells + size_cells) * sizeof(fdt32_t)); 91 if (usable) { 92 size = get_val(usable + addr_cells, size_cells); 93 if (!size) 94 return mem_start; 95 96 if (addr_cells > 1 && fdt32_ld(usable)) { 97 /* Outside 32-bit address space */ 98 return mem_start; 99 } 100 101 usable_base = fdt32_ld(usable + addr_cells - 1); 102 usable_end = usable_base + size; 103 } 104 105 /* Walk all memory nodes and regions */ 106 for (offset = fdt_next_node(fdt, -1, NULL); offset >= 0; 107 offset = fdt_next_node(fdt, offset, NULL)) { 108 type = fdt_getprop(fdt, offset, "device_type", NULL); 109 if (!type || strcmp(type, "memory")) 110 continue; 111 112 reg = fdt_getprop(fdt, offset, "linux,usable-memory", &len); 113 if (!reg) 114 reg = fdt_getprop(fdt, offset, "reg", &len); 115 if (!reg) 116 continue; 117 118 for (endp = reg + (len / sizeof(fdt32_t)); 119 endp - reg >= addr_cells + size_cells; 120 reg += addr_cells + size_cells) { 121 size = get_val(reg + addr_cells, size_cells); 122 if (!size) 123 continue; 124 125 if (addr_cells > 1 && fdt32_ld(reg)) { 126 /* Outside 32-bit address space, skipping */ 127 continue; 128 } 129 130 base = fdt32_ld(reg + addr_cells - 1); 131 end = base + size; 132 if (usable) { 133 /* 134 * Clip to usable range, which takes precedence 135 * over mem_start 136 */ 137 if (base < usable_base) 138 base = usable_base; 139 140 if (end > usable_end) 141 end = usable_end; 142 143 if (end <= base) 144 continue; 145 } else if (mem_start >= base && mem_start < end) { 146 /* Calculated address is valid, use it */ 147 return mem_start; 148 } 149 150 if (base < fdt_mem_start) 151 fdt_mem_start = base; 152 } 153 } 154 155 if (fdt_mem_start == 0xffffffff) { 156 /* No usable memory found, falling back to default */ 157 return mem_start; 158 } 159 160 /* 161 * The calculated address is not usable, or was overridden by the 162 * "linux,usable-memory-range" property. 163 * Use the lowest usable physical memory address from the DTB instead, 164 * and make sure this is a multiple of 2 MiB for phys/virt patching. 165 */ 166 return round_up(fdt_mem_start, SZ_2M); 167 } 168