fdt_memory.c revision 1.9
1 /* $NetBSD: fdt_memory.c,v 1.9 2024/01/12 18:06:18 skrll 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 (at) 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.9 2024/01/12 18:06:18 skrll 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 struct fdt_memory_range { 45 struct fdt_memory mr_mem; 46 bool mr_used; 47 TAILQ_ENTRY(fdt_memory_range) mr_list; 48 }; 49 50 static TAILQ_HEAD(fdt_memory_rangehead, fdt_memory_range) fdt_memory_ranges = 51 TAILQ_HEAD_INITIALIZER(fdt_memory_ranges); 52 53 static struct fdt_memory_range fdt_memory_range_pool[FDT_MEMORY_RANGES]; 54 55 static struct fdt_memory_range * 56 fdt_memory_range_alloc(void) 57 { 58 for (size_t n = 0; n < FDT_MEMORY_RANGES; n++) 59 if (!fdt_memory_range_pool[n].mr_used) { 60 fdt_memory_range_pool[n].mr_used = true; 61 return &fdt_memory_range_pool[n]; 62 } 63 64 printf("%s: no free memory ranges, increase FDT_MEMORY_RANGES!\n", __func__); 65 return NULL; 66 } 67 68 static void 69 fdt_memory_range_free(struct fdt_memory_range *mr) 70 { 71 mr->mr_used = false; 72 } 73 74 /* 75 * Get all of physical memory, including holes. 76 */ 77 void 78 fdt_memory_get(uint64_t *pstart, uint64_t *pend) 79 { 80 const int memory = OF_finddevice("/memory"); 81 uint64_t cur_addr, cur_size; 82 int index, nadd; 83 84 for (index = 0, nadd = 0; 85 fdtbus_get_reg64(memory, index, &cur_addr, &cur_size) == 0; 86 index++) { 87 if (cur_size == 0) 88 continue; 89 fdt_memory_add_range(cur_addr, cur_size); 90 91 if (nadd++ == 0) { 92 *pstart = cur_addr; 93 *pend = cur_addr + cur_size; 94 continue; 95 } 96 if (cur_addr < *pstart) 97 *pstart = cur_addr; 98 if (cur_addr + cur_size > *pend) 99 *pend = cur_addr + cur_size; 100 } 101 if (nadd == 0) 102 panic("Cannot determine memory size"); 103 } 104 105 /* 106 * Exclude memory ranges from memory config from the device tree 107 */ 108 void 109 fdt_memory_remove_reserved(uint64_t min_addr, uint64_t max_addr) 110 { 111 uint64_t lstart = 0, lend = 0; 112 int index, error, phandle, child; 113 const void *fdt_data = fdtbus_get_data(); 114 const int num = fdt_num_mem_rsv(fdt_data); 115 116 for (index = 0; index <= num; index++) { 117 uint64_t addr, size; 118 119 error = fdt_get_mem_rsv(fdt_data, index, &addr, &size); 120 if (error != 0) 121 continue; 122 123 if (lstart <= addr && addr <= lend) { 124 size -= (lend - addr); 125 addr = lend; 126 } 127 if (size == 0) 128 continue; 129 if (addr + size <= min_addr) 130 continue; 131 if (addr >= max_addr) 132 continue; 133 if (addr < min_addr) { 134 size -= (min_addr - addr); 135 addr = min_addr; 136 } 137 if (addr + size > max_addr) 138 size = max_addr - addr; 139 fdt_memory_remove_range(addr, size); 140 lstart = addr; 141 lend = addr + size; 142 } 143 144 /* 145 * "no-map" ranges defined in the /reserved-memory node 146 * must also be excluded. 147 */ 148 phandle = OF_finddevice("/reserved-memory"); 149 if (phandle != -1) { 150 for (child = OF_child(phandle); child; child = OF_peer(child)) { 151 bus_addr_t addr; 152 bus_size_t size; 153 154 if (fdtbus_get_reg(child, 0, &addr, &size) != 0) 155 continue; 156 if (size == 0) 157 continue; 158 fdt_memory_remove_range(addr, size); 159 } 160 } 161 } 162 163 void 164 fdt_memory_add_range(uint64_t start, uint64_t size) 165 { 166 struct fdt_memory_range *mr, *prev, *cur, *tmp; 167 bool inserted = false; 168 169 mr = fdt_memory_range_alloc(); 170 if (mr == NULL) 171 return; 172 173 mr->mr_mem.start = start; 174 mr->mr_mem.end = start + size; 175 176 /* 177 * Add the new range to the list of sorted ranges. 178 */ 179 TAILQ_FOREACH(cur, &fdt_memory_ranges, mr_list) 180 if (mr->mr_mem.start <= cur->mr_mem.start) { 181 TAILQ_INSERT_BEFORE(cur, mr, mr_list); 182 inserted = true; 183 break; 184 } 185 if (!inserted) 186 TAILQ_INSERT_TAIL(&fdt_memory_ranges, mr, mr_list); 187 188 /* 189 * Remove overlaps. 190 */ 191 TAILQ_FOREACH_SAFE(mr, &fdt_memory_ranges, mr_list, tmp) { 192 prev = TAILQ_PREV(mr, fdt_memory_rangehead, mr_list); 193 if (prev && prev->mr_mem.end > mr->mr_mem.start) { 194 mr->mr_mem.start = prev->mr_mem.end; 195 if (mr->mr_mem.start >= mr->mr_mem.end) { 196 TAILQ_REMOVE(&fdt_memory_ranges, mr, mr_list); 197 fdt_memory_range_free(mr); 198 } 199 } 200 } 201 202 /* 203 * Combine adjacent ranges. 204 */ 205 TAILQ_FOREACH_SAFE(mr, &fdt_memory_ranges, mr_list, tmp) { 206 prev = TAILQ_PREV(mr, fdt_memory_rangehead, mr_list); 207 if (prev && prev->mr_mem.end == mr->mr_mem.start) { 208 prev->mr_mem.end = mr->mr_mem.end; 209 TAILQ_REMOVE(&fdt_memory_ranges, mr, mr_list); 210 fdt_memory_range_free(mr); 211 } 212 } 213 } 214 215 void 216 fdt_memory_remove_range(uint64_t start, uint64_t size) 217 { 218 struct fdt_memory_range *mr, *next, *tmp; 219 const uint64_t end = start + size; 220 221 TAILQ_FOREACH_SAFE(mr, &fdt_memory_ranges, mr_list, tmp) { 222 if (start <= mr->mr_mem.start && end >= mr->mr_mem.end) { 223 /* 224 * Removed range completely covers this range, 225 * just remove it. 226 */ 227 TAILQ_REMOVE(&fdt_memory_ranges, mr, mr_list); 228 fdt_memory_range_free(mr); 229 } else if (start > mr->mr_mem.start && end < mr->mr_mem.end) { 230 /* 231 * Removed range is completely contained by this range, 232 * split it. 233 */ 234 next = fdt_memory_range_alloc(); 235 if (next == NULL) 236 panic("fdt_memory_remove_range"); 237 next->mr_mem.start = end; 238 next->mr_mem.end = mr->mr_mem.end; 239 mr->mr_mem.end = start; 240 TAILQ_INSERT_AFTER(&fdt_memory_ranges, mr, next, mr_list); 241 } else if (start <= mr->mr_mem.start && end > mr->mr_mem.start && end < mr->mr_mem.end) { 242 /* 243 * Partial overlap at the beginning of the range. 244 */ 245 mr->mr_mem.start = end; 246 } else if (start > mr->mr_mem.start && start < mr->mr_mem.end && end >= mr->mr_mem.end) { 247 /* 248 * Partial overlap at the end of the range. 249 */ 250 mr->mr_mem.end = start; 251 } 252 KASSERT(mr->mr_mem.start < mr->mr_mem.end); 253 } 254 } 255 256 void 257 fdt_memory_foreach(void (*fn)(const struct fdt_memory *, void *), void *arg) 258 { 259 struct fdt_memory_range *mr; 260 261 TAILQ_FOREACH(mr, &fdt_memory_ranges, mr_list) 262 fn(&mr->mr_mem, arg); 263 } 264
Indexes created Tue Sep 23 07:09:52 GMT 2025