1 /* $NetBSD: fdt_memory.c,v 1.4 2022/01/07 07:25:37 mlelstv Exp $ */ 2 3 /*- 4 * Copyright (c) 2018 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Jared McNeill <jmcneill@invisible.ca>. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include "opt_fdt.h" 33 34 #include <sys/cdefs.h> 35 __KERNEL_RCSID(0, "$NetBSD: fdt_memory.c,v 1.4 2022/01/07 07:25:37 mlelstv Exp $"); 36 37 #include <sys/param.h> 38 #include <sys/queue.h> 39 40 #include <libfdt.h> 41 #include <dev/fdt/fdtvar.h> 42 #include <dev/fdt/fdt_memory.h> 43 44 #ifndef FDT_MEMORY_RANGES 45 #define FDT_MEMORY_RANGES 256 46 #endif 47 48 struct fdt_memory_range { 49 struct fdt_memory mr_mem; 50 bool mr_used; 51 TAILQ_ENTRY(fdt_memory_range) mr_list; 52 }; 53 54 static TAILQ_HEAD(fdt_memory_rangehead, fdt_memory_range) fdt_memory_ranges = 55 TAILQ_HEAD_INITIALIZER(fdt_memory_ranges); 56 57 static struct fdt_memory_range fdt_memory_range_pool[FDT_MEMORY_RANGES]; 58 59 static struct fdt_memory_range * 60 fdt_memory_range_alloc(void) 61 { 62 for (size_t n = 0; n < FDT_MEMORY_RANGES; n++) 63 if (!fdt_memory_range_pool[n].mr_used) { 64 fdt_memory_range_pool[n].mr_used = true; 65 return &fdt_memory_range_pool[n]; 66 } 67 68 printf("%s: no free memory ranges, increase FDT_MEMORY_RANGES!\n", __func__); 69 return NULL; 70 } 71 72 static void 73 fdt_memory_range_free(struct fdt_memory_range *mr) 74 { 75 mr->mr_used = false; 76 } 77 78 /* 79 * Get all of physical memory, including holes. 80 */ 81 void 82 fdt_memory_get(uint64_t *pstart, uint64_t *pend) 83 { 84 const int memory = OF_finddevice("/memory"); 85 uint64_t cur_addr, cur_size; 86 int index; 87 88 for (index = 0; 89 fdtbus_get_reg64(memory, index, &cur_addr, &cur_size) == 0; 90 index++) { 91 fdt_memory_add_range(cur_addr, cur_size); 92 93 if (index == 0) { 94 *pstart = cur_addr; 95 *pend = cur_addr + cur_size; 96 continue; 97 } 98 if (cur_addr < *pstart) 99 *pstart = cur_addr; 100 if (cur_addr + cur_size > *pend) 101 *pend = cur_addr + cur_size; 102 } 103 if (index == 0) 104 panic("Cannot determine memory size"); 105 } 106 107 /* 108 * Exclude memory ranges from memory config from the device tree 109 */ 110 void 111 fdt_memory_remove_reserved(uint64_t min_addr, uint64_t max_addr) 112 { 113 uint64_t lstart = 0, lend = 0; 114 int index, error, phandle, child; 115 116 const int num = fdt_num_mem_rsv(fdtbus_get_data()); 117 for (index = 0; index <= num; index++) { 118 uint64_t addr, size; 119 120 error = fdt_get_mem_rsv(fdtbus_get_data(), index, 121 &addr, &size); 122 if (error != 0) 123 continue; 124 if (lstart <= addr && addr <= lend) { 125 size -= (lend - addr); 126 addr = lend; 127 } 128 if (size == 0) 129 continue; 130 if (addr + size <= min_addr) 131 continue; 132 if (addr >= max_addr) 133 continue; 134 if (addr < min_addr) { 135 size -= (min_addr - addr); 136 addr = min_addr; 137 } 138 if (addr + size > max_addr) 139 size = max_addr - addr; 140 fdt_memory_remove_range(addr, size); 141 lstart = addr; 142 lend = addr + size; 143 } 144 145 /* 146 * "no-map" ranges defined in the /reserved-memory node 147 * must also be excluded. 148 */ 149 phandle = OF_finddevice("/reserved-memory"); 150 if (phandle != -1) { 151 for (child = OF_child(phandle); child; child = OF_peer(child)) { 152 bus_addr_t addr; 153 bus_size_t size; 154 155 if (!of_hasprop(child, "no-map")) 156 continue; 157 158 if (fdtbus_get_reg(child, 0, &addr, &size) != 0) 159 continue; 160 if (size == 0) 161 continue; 162 fdt_memory_remove_range(addr, size); 163 } 164 } 165 } 166 167 void 168 fdt_memory_add_range(uint64_t start, uint64_t size) 169 { 170 struct fdt_memory_range *mr, *prev, *cur, *tmp; 171 bool inserted = false; 172 173 mr = fdt_memory_range_alloc(); 174 if (mr == NULL) 175 return; 176 177 mr->mr_mem.start = start; 178 mr->mr_mem.end = start + size; 179 180 /* 181 * Add the new range to the list of sorted ranges. 182 */ 183 TAILQ_FOREACH(cur, &fdt_memory_ranges, mr_list) 184 if (mr->mr_mem.start <= cur->mr_mem.start) { 185 TAILQ_INSERT_BEFORE(cur, mr, mr_list); 186 inserted = true; 187 break; 188 } 189 if (!inserted) 190 TAILQ_INSERT_TAIL(&fdt_memory_ranges, mr, mr_list); 191 192 /* 193 * Remove overlaps. 194 */ 195 TAILQ_FOREACH_SAFE(mr, &fdt_memory_ranges, mr_list, tmp) { 196 prev = TAILQ_PREV(mr, fdt_memory_rangehead, mr_list); 197 if (prev && prev->mr_mem.end > mr->mr_mem.start) { 198 mr->mr_mem.start = prev->mr_mem.end; 199 if (mr->mr_mem.start >= mr->mr_mem.end) { 200 TAILQ_REMOVE(&fdt_memory_ranges, mr, mr_list); 201 fdt_memory_range_free(mr); 202 } 203 } 204 } 205 206 /* 207 * Combine adjacent ranges. 208 */ 209 TAILQ_FOREACH_SAFE(mr, &fdt_memory_ranges, mr_list, tmp) { 210 prev = TAILQ_PREV(mr, fdt_memory_rangehead, mr_list); 211 if (prev && prev->mr_mem.end == mr->mr_mem.start) { 212 prev->mr_mem.end = mr->mr_mem.end; 213 TAILQ_REMOVE(&fdt_memory_ranges, mr, mr_list); 214 fdt_memory_range_free(mr); 215 } 216 } 217 } 218 219 void 220 fdt_memory_remove_range(uint64_t start, uint64_t size) 221 { 222 struct fdt_memory_range *mr, *next, *tmp; 223 const uint64_t end = start + size; 224 225 TAILQ_FOREACH_SAFE(mr, &fdt_memory_ranges, mr_list, tmp) { 226 if (start <= mr->mr_mem.start && end >= mr->mr_mem.end) { 227 /* 228 * Removed range completely covers this range, 229 * just remove it. 230 */ 231 TAILQ_REMOVE(&fdt_memory_ranges, mr, mr_list); 232 fdt_memory_range_free(mr); 233 } else if (start > mr->mr_mem.start && end < mr->mr_mem.end) { 234 /* 235 * Removed range is completely contained by this range, 236 * split it. 237 */ 238 next = fdt_memory_range_alloc(); 239 if (next == NULL) 240 panic("fdt_memory_remove_range"); 241 next->mr_mem.start = end; 242 next->mr_mem.end = mr->mr_mem.end; 243 mr->mr_mem.end = start; 244 TAILQ_INSERT_AFTER(&fdt_memory_ranges, mr, next, mr_list); 245 } else if (start <= mr->mr_mem.start && end > mr->mr_mem.start && end < mr->mr_mem.end) { 246 /* 247 * Partial overlap at the beginning of the range. 248 */ 249 mr->mr_mem.start = end; 250 } else if (start > mr->mr_mem.start && start < mr->mr_mem.end && end >= mr->mr_mem.end) { 251 /* 252 * Partial overlap at the end of the range. 253 */ 254 mr->mr_mem.end = start; 255 } 256 KASSERT(mr->mr_mem.start < mr->mr_mem.end); 257 } 258 } 259 260 void 261 fdt_memory_foreach(void (*fn)(const struct fdt_memory *, void *), void *arg) 262 { 263 struct fdt_memory_range *mr; 264 265 TAILQ_FOREACH(mr, &fdt_memory_ranges, mr_list) 266 fn(&mr->mr_mem, arg); 267 } 268