Tom Rini | 10e4779 | 2018-05-06 17:58:06 -0400 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0+ |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 2 | /* |
| 3 | * Procedures for maintaining information about logical memory blocks. |
| 4 | * |
| 5 | * Peter Bergner, IBM Corp. June 2001. |
| 6 | * Copyright (C) 2001 Peter Bergner. |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 7 | */ |
| 8 | |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 9 | #include <alist.h> |
Heinrich Schuchardt | c9bb2eb | 2023-01-04 01:36:14 +0100 | [diff] [blame] | 10 | #include <efi_loader.h> |
Sughosh Ganu | a3af5ba | 2024-10-15 21:07:07 +0530 | [diff] [blame] | 11 | #include <event.h> |
Simon Glass | 2dc9c34 | 2020-05-10 11:40:01 -0600 | [diff] [blame] | 12 | #include <image.h> |
Heinrich Schuchardt | c9bb2eb | 2023-01-04 01:36:14 +0100 | [diff] [blame] | 13 | #include <mapmem.h> |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 14 | #include <lmb.h> |
Simon Glass | 0f2af88 | 2020-05-10 11:40:05 -0600 | [diff] [blame] | 15 | #include <log.h> |
Simon Glass | 9bc1564 | 2020-02-03 07:36:16 -0700 | [diff] [blame] | 16 | #include <malloc.h> |
Sughosh Ganu | 6518b41 | 2024-08-26 17:29:24 +0530 | [diff] [blame] | 17 | #include <spl.h> |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 18 | |
Marek Vasut | a2eec02 | 2021-09-10 22:47:09 +0200 | [diff] [blame] | 19 | #include <asm/global_data.h> |
Marek Vasut | 0fcae7f | 2021-11-13 18:34:37 +0100 | [diff] [blame] | 20 | #include <asm/sections.h> |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 21 | #include <linux/kernel.h> |
Sughosh Ganu | e5348c7 | 2024-08-26 17:29:30 +0530 | [diff] [blame] | 22 | #include <linux/sizes.h> |
Marek Vasut | a2eec02 | 2021-09-10 22:47:09 +0200 | [diff] [blame] | 23 | |
| 24 | DECLARE_GLOBAL_DATA_PTR; |
| 25 | |
Sughosh Ganu | a3af5ba | 2024-10-15 21:07:07 +0530 | [diff] [blame] | 26 | #define MAP_OP_RESERVE (u8)0x1 |
| 27 | #define MAP_OP_FREE (u8)0x2 |
| 28 | #define MAP_OP_ADD (u8)0x3 |
| 29 | |
Janne Grunau | 5631f44 | 2024-11-11 07:56:32 +0100 | [diff] [blame] | 30 | /* |
| 31 | * The following low level LMB functions must not access the global LMB memory |
| 32 | * map since they are also used to manage IOVA memory maps in iommu drivers like |
| 33 | * apple_dart. |
| 34 | */ |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 35 | |
Simon Goldschmidt | f41f7d6 | 2019-01-21 20:29:56 +0100 | [diff] [blame] | 36 | static long lmb_addrs_overlap(phys_addr_t base1, phys_size_t size1, |
| 37 | phys_addr_t base2, phys_size_t size2) |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 38 | { |
Simon Goldschmidt | 6402d9b | 2019-01-14 22:38:15 +0100 | [diff] [blame] | 39 | const phys_addr_t base1_end = base1 + size1 - 1; |
| 40 | const phys_addr_t base2_end = base2 + size2 - 1; |
| 41 | |
| 42 | return ((base1 <= base2_end) && (base2 <= base1_end)); |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 43 | } |
| 44 | |
Becky Bruce | d26d67c | 2008-06-09 20:37:18 -0500 | [diff] [blame] | 45 | static long lmb_addrs_adjacent(phys_addr_t base1, phys_size_t size1, |
Simon Goldschmidt | f41f7d6 | 2019-01-21 20:29:56 +0100 | [diff] [blame] | 46 | phys_addr_t base2, phys_size_t size2) |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 47 | { |
| 48 | if (base2 == base1 + size1) |
| 49 | return 1; |
| 50 | else if (base1 == base2 + size2) |
| 51 | return -1; |
| 52 | |
| 53 | return 0; |
| 54 | } |
| 55 | |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 56 | static long lmb_regions_overlap(struct alist *lmb_rgn_lst, unsigned long r1, |
Udit Kumar | 4e8e663 | 2023-09-26 16:54:42 +0530 | [diff] [blame] | 57 | unsigned long r2) |
| 58 | { |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 59 | struct lmb_region *rgn = lmb_rgn_lst->data; |
| 60 | |
| 61 | phys_addr_t base1 = rgn[r1].base; |
| 62 | phys_size_t size1 = rgn[r1].size; |
| 63 | phys_addr_t base2 = rgn[r2].base; |
| 64 | phys_size_t size2 = rgn[r2].size; |
Udit Kumar | 4e8e663 | 2023-09-26 16:54:42 +0530 | [diff] [blame] | 65 | |
| 66 | return lmb_addrs_overlap(base1, size1, base2, size2); |
| 67 | } |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 68 | |
| 69 | static long lmb_regions_adjacent(struct alist *lmb_rgn_lst, unsigned long r1, |
Simon Goldschmidt | f41f7d6 | 2019-01-21 20:29:56 +0100 | [diff] [blame] | 70 | unsigned long r2) |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 71 | { |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 72 | struct lmb_region *rgn = lmb_rgn_lst->data; |
| 73 | |
| 74 | phys_addr_t base1 = rgn[r1].base; |
| 75 | phys_size_t size1 = rgn[r1].size; |
| 76 | phys_addr_t base2 = rgn[r2].base; |
| 77 | phys_size_t size2 = rgn[r2].size; |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 78 | return lmb_addrs_adjacent(base1, size1, base2, size2); |
| 79 | } |
| 80 | |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 81 | static void lmb_remove_region(struct alist *lmb_rgn_lst, unsigned long r) |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 82 | { |
| 83 | unsigned long i; |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 84 | struct lmb_region *rgn = lmb_rgn_lst->data; |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 85 | |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 86 | for (i = r; i < lmb_rgn_lst->count - 1; i++) { |
| 87 | rgn[i].base = rgn[i + 1].base; |
| 88 | rgn[i].size = rgn[i + 1].size; |
| 89 | rgn[i].flags = rgn[i + 1].flags; |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 90 | } |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 91 | lmb_rgn_lst->count--; |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 92 | } |
| 93 | |
| 94 | /* Assumption: base addr of region 1 < base addr of region 2 */ |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 95 | static void lmb_coalesce_regions(struct alist *lmb_rgn_lst, unsigned long r1, |
Simon Goldschmidt | f41f7d6 | 2019-01-21 20:29:56 +0100 | [diff] [blame] | 96 | unsigned long r2) |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 97 | { |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 98 | struct lmb_region *rgn = lmb_rgn_lst->data; |
| 99 | |
| 100 | rgn[r1].size += rgn[r2].size; |
| 101 | lmb_remove_region(lmb_rgn_lst, r2); |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 102 | } |
| 103 | |
Udit Kumar | 4e8e663 | 2023-09-26 16:54:42 +0530 | [diff] [blame] | 104 | /*Assumption : base addr of region 1 < base addr of region 2*/ |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 105 | static void lmb_fix_over_lap_regions(struct alist *lmb_rgn_lst, |
| 106 | unsigned long r1, unsigned long r2) |
Udit Kumar | 4e8e663 | 2023-09-26 16:54:42 +0530 | [diff] [blame] | 107 | { |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 108 | struct lmb_region *rgn = lmb_rgn_lst->data; |
| 109 | |
| 110 | phys_addr_t base1 = rgn[r1].base; |
| 111 | phys_size_t size1 = rgn[r1].size; |
| 112 | phys_addr_t base2 = rgn[r2].base; |
| 113 | phys_size_t size2 = rgn[r2].size; |
Udit Kumar | 4e8e663 | 2023-09-26 16:54:42 +0530 | [diff] [blame] | 114 | |
| 115 | if (base1 + size1 > base2 + size2) { |
| 116 | printf("This will not be a case any time\n"); |
| 117 | return; |
| 118 | } |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 119 | rgn[r1].size = base2 + size2 - base1; |
| 120 | lmb_remove_region(lmb_rgn_lst, r2); |
Udit Kumar | 4e8e663 | 2023-09-26 16:54:42 +0530 | [diff] [blame] | 121 | } |
| 122 | |
Sughosh Ganu | 50e2727 | 2024-08-26 17:29:19 +0530 | [diff] [blame] | 123 | static long lmb_resize_regions(struct alist *lmb_rgn_lst, |
| 124 | unsigned long idx_start, |
| 125 | phys_addr_t base, phys_size_t size) |
| 126 | { |
| 127 | phys_size_t rgnsize; |
| 128 | unsigned long rgn_cnt, idx, idx_end; |
| 129 | phys_addr_t rgnbase, rgnend; |
| 130 | phys_addr_t mergebase, mergeend; |
| 131 | struct lmb_region *rgn = lmb_rgn_lst->data; |
| 132 | |
| 133 | rgn_cnt = 0; |
| 134 | idx = idx_start; |
| 135 | idx_end = idx_start; |
| 136 | |
| 137 | /* |
| 138 | * First thing to do is to identify how many regions |
| 139 | * the requested region overlaps. |
| 140 | * If the flags match, combine all these overlapping |
| 141 | * regions into a single region, and remove the merged |
| 142 | * regions. |
| 143 | */ |
| 144 | while (idx <= lmb_rgn_lst->count - 1) { |
| 145 | rgnbase = rgn[idx].base; |
| 146 | rgnsize = rgn[idx].size; |
| 147 | |
| 148 | if (lmb_addrs_overlap(base, size, rgnbase, |
| 149 | rgnsize)) { |
| 150 | if (rgn[idx].flags != LMB_NONE) |
| 151 | return -1; |
| 152 | rgn_cnt++; |
| 153 | idx_end = idx; |
| 154 | } |
| 155 | idx++; |
| 156 | } |
| 157 | |
| 158 | /* The merged region's base and size */ |
| 159 | rgnbase = rgn[idx_start].base; |
| 160 | mergebase = min(base, rgnbase); |
| 161 | rgnend = rgn[idx_end].base + rgn[idx_end].size; |
| 162 | mergeend = max(rgnend, (base + size)); |
| 163 | |
| 164 | rgn[idx_start].base = mergebase; |
| 165 | rgn[idx_start].size = mergeend - mergebase; |
| 166 | |
| 167 | /* Now remove the merged regions */ |
| 168 | while (--rgn_cnt) |
| 169 | lmb_remove_region(lmb_rgn_lst, idx_start + 1); |
| 170 | |
| 171 | return 0; |
| 172 | } |
| 173 | |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 174 | /** |
| 175 | * lmb_add_region_flags() - Add an lmb region to the given list |
| 176 | * @lmb_rgn_lst: LMB list to which region is to be added(free/used) |
| 177 | * @base: Start address of the region |
| 178 | * @size: Size of the region to be added |
| 179 | * @flags: Attributes of the LMB region |
| 180 | * |
| 181 | * Add a region of memory to the list. If the region does not exist, add |
| 182 | * it to the list. Depending on the attributes of the region to be added, |
| 183 | * the function might resize an already existing region or coalesce two |
| 184 | * adjacent regions. |
| 185 | * |
Sam Protsenko | b4f8110 | 2024-12-10 20:17:01 -0600 | [diff] [blame] | 186 | * Return: |
| 187 | * * %0 - Added successfully, or it's already added (only if LMB_NONE) |
| 188 | * * %-EEXIST - The region is already added, and flags != LMB_NONE |
| 189 | * * %-1 - Failure |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 190 | */ |
| 191 | static long lmb_add_region_flags(struct alist *lmb_rgn_lst, phys_addr_t base, |
Patrick Delaunay | e11c908 | 2021-05-07 14:50:29 +0200 | [diff] [blame] | 192 | phys_size_t size, enum lmb_flags flags) |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 193 | { |
| 194 | unsigned long coalesced = 0; |
Sughosh Ganu | 50e2727 | 2024-08-26 17:29:19 +0530 | [diff] [blame] | 195 | long ret, i; |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 196 | struct lmb_region *rgn = lmb_rgn_lst->data; |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 197 | |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 198 | if (alist_err(lmb_rgn_lst)) |
| 199 | return -1; |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 200 | |
| 201 | /* First try and coalesce this LMB with another. */ |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 202 | for (i = 0; i < lmb_rgn_lst->count; i++) { |
| 203 | phys_addr_t rgnbase = rgn[i].base; |
| 204 | phys_size_t rgnsize = rgn[i].size; |
| 205 | phys_size_t rgnflags = rgn[i].flags; |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 206 | |
Sughosh Ganu | 50e2727 | 2024-08-26 17:29:19 +0530 | [diff] [blame] | 207 | ret = lmb_addrs_adjacent(base, size, rgnbase, rgnsize); |
| 208 | if (ret > 0) { |
Patrick Delaunay | e11c908 | 2021-05-07 14:50:29 +0200 | [diff] [blame] | 209 | if (flags != rgnflags) |
| 210 | break; |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 211 | rgn[i].base -= size; |
| 212 | rgn[i].size += size; |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 213 | coalesced++; |
| 214 | break; |
Sughosh Ganu | 50e2727 | 2024-08-26 17:29:19 +0530 | [diff] [blame] | 215 | } else if (ret < 0) { |
Patrick Delaunay | e11c908 | 2021-05-07 14:50:29 +0200 | [diff] [blame] | 216 | if (flags != rgnflags) |
| 217 | break; |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 218 | rgn[i].size += size; |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 219 | coalesced++; |
| 220 | break; |
Simon Goldschmidt | cb57d13 | 2019-01-14 22:38:16 +0100 | [diff] [blame] | 221 | } else if (lmb_addrs_overlap(base, size, rgnbase, rgnsize)) { |
Sam Protsenko | b4f8110 | 2024-12-10 20:17:01 -0600 | [diff] [blame] | 222 | if (flags != LMB_NONE) |
| 223 | return -EEXIST; |
Sughosh Ganu | 50e2727 | 2024-08-26 17:29:19 +0530 | [diff] [blame] | 224 | |
Sam Protsenko | b4f8110 | 2024-12-10 20:17:01 -0600 | [diff] [blame] | 225 | ret = lmb_resize_regions(lmb_rgn_lst, i, base, size); |
| 226 | if (ret < 0) |
Sughosh Ganu | 50e2727 | 2024-08-26 17:29:19 +0530 | [diff] [blame] | 227 | return -1; |
Sam Protsenko | b4f8110 | 2024-12-10 20:17:01 -0600 | [diff] [blame] | 228 | |
| 229 | coalesced++; |
| 230 | break; |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 231 | } |
| 232 | } |
| 233 | |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 234 | if (lmb_rgn_lst->count && i < lmb_rgn_lst->count - 1) { |
| 235 | rgn = lmb_rgn_lst->data; |
| 236 | if (rgn[i].flags == rgn[i + 1].flags) { |
| 237 | if (lmb_regions_adjacent(lmb_rgn_lst, i, i + 1)) { |
| 238 | lmb_coalesce_regions(lmb_rgn_lst, i, i + 1); |
| 239 | coalesced++; |
| 240 | } else if (lmb_regions_overlap(lmb_rgn_lst, i, i + 1)) { |
| 241 | /* fix overlapping area */ |
| 242 | lmb_fix_over_lap_regions(lmb_rgn_lst, i, i + 1); |
| 243 | coalesced++; |
| 244 | } |
Patrick Delaunay | e11c908 | 2021-05-07 14:50:29 +0200 | [diff] [blame] | 245 | } |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 246 | } |
| 247 | |
| 248 | if (coalesced) |
Ilias Apalodimas | 9849125 | 2024-10-23 18:22:00 +0300 | [diff] [blame] | 249 | return 0; |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 250 | |
| 251 | if (alist_full(lmb_rgn_lst) && |
| 252 | !alist_expand_by(lmb_rgn_lst, lmb_rgn_lst->alloc)) |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 253 | return -1; |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 254 | rgn = lmb_rgn_lst->data; |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 255 | |
| 256 | /* Couldn't coalesce the LMB, so add it to the sorted table. */ |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 257 | for (i = lmb_rgn_lst->count; i >= 0; i--) { |
| 258 | if (i && base < rgn[i - 1].base) { |
| 259 | rgn[i] = rgn[i - 1]; |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 260 | } else { |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 261 | rgn[i].base = base; |
| 262 | rgn[i].size = size; |
| 263 | rgn[i].flags = flags; |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 264 | break; |
| 265 | } |
| 266 | } |
| 267 | |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 268 | lmb_rgn_lst->count++; |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 269 | |
| 270 | return 0; |
| 271 | } |
| 272 | |
Janne Grunau | d9c7040 | 2024-11-11 07:56:31 +0100 | [diff] [blame] | 273 | static long _lmb_free(struct alist *lmb_rgn_lst, phys_addr_t base, |
| 274 | phys_size_t size) |
Andy Fleming | 1ae346c | 2008-06-16 13:58:54 -0500 | [diff] [blame] | 275 | { |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 276 | struct lmb_region *rgn; |
Andy Fleming | 09d2a71 | 2008-07-07 14:24:39 -0500 | [diff] [blame] | 277 | phys_addr_t rgnbegin, rgnend; |
Simon Goldschmidt | 6402d9b | 2019-01-14 22:38:15 +0100 | [diff] [blame] | 278 | phys_addr_t end = base + size - 1; |
Andy Fleming | 1ae346c | 2008-06-16 13:58:54 -0500 | [diff] [blame] | 279 | int i; |
| 280 | |
| 281 | rgnbegin = rgnend = 0; /* supress gcc warnings */ |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 282 | rgn = lmb_rgn_lst->data; |
Andy Fleming | 1ae346c | 2008-06-16 13:58:54 -0500 | [diff] [blame] | 283 | /* Find the region where (base, size) belongs to */ |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 284 | for (i = 0; i < lmb_rgn_lst->count; i++) { |
| 285 | rgnbegin = rgn[i].base; |
| 286 | rgnend = rgnbegin + rgn[i].size - 1; |
Andy Fleming | 1ae346c | 2008-06-16 13:58:54 -0500 | [diff] [blame] | 287 | |
| 288 | if ((rgnbegin <= base) && (end <= rgnend)) |
| 289 | break; |
| 290 | } |
| 291 | |
| 292 | /* Didn't find the region */ |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 293 | if (i == lmb_rgn_lst->count) |
Andy Fleming | 1ae346c | 2008-06-16 13:58:54 -0500 | [diff] [blame] | 294 | return -1; |
| 295 | |
| 296 | /* Check to see if we are removing entire region */ |
| 297 | if ((rgnbegin == base) && (rgnend == end)) { |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 298 | lmb_remove_region(lmb_rgn_lst, i); |
Andy Fleming | 1ae346c | 2008-06-16 13:58:54 -0500 | [diff] [blame] | 299 | return 0; |
| 300 | } |
| 301 | |
| 302 | /* Check to see if region is matching at the front */ |
| 303 | if (rgnbegin == base) { |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 304 | rgn[i].base = end + 1; |
| 305 | rgn[i].size -= size; |
Andy Fleming | 1ae346c | 2008-06-16 13:58:54 -0500 | [diff] [blame] | 306 | return 0; |
| 307 | } |
| 308 | |
| 309 | /* Check to see if the region is matching at the end */ |
| 310 | if (rgnend == end) { |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 311 | rgn[i].size -= size; |
Andy Fleming | 1ae346c | 2008-06-16 13:58:54 -0500 | [diff] [blame] | 312 | return 0; |
| 313 | } |
| 314 | |
| 315 | /* |
| 316 | * We need to split the entry - adjust the current one to the |
| 317 | * beginging of the hole and add the region after hole. |
| 318 | */ |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 319 | rgn[i].size = base - rgn[i].base; |
| 320 | return lmb_add_region_flags(lmb_rgn_lst, end + 1, rgnend - end, |
| 321 | rgn[i].flags); |
Andy Fleming | 1ae346c | 2008-06-16 13:58:54 -0500 | [diff] [blame] | 322 | } |
| 323 | |
Janne Grunau | 5631f44 | 2024-11-11 07:56:32 +0100 | [diff] [blame] | 324 | static long lmb_overlaps_region(struct alist *lmb_rgn_lst, phys_addr_t base, |
| 325 | phys_size_t size) |
| 326 | { |
| 327 | unsigned long i; |
| 328 | struct lmb_region *rgn = lmb_rgn_lst->data; |
| 329 | |
| 330 | for (i = 0; i < lmb_rgn_lst->count; i++) { |
| 331 | phys_addr_t rgnbase = rgn[i].base; |
| 332 | phys_size_t rgnsize = rgn[i].size; |
| 333 | if (lmb_addrs_overlap(base, size, rgnbase, rgnsize)) |
| 334 | break; |
| 335 | } |
| 336 | |
| 337 | return (i < lmb_rgn_lst->count) ? i : -1; |
| 338 | } |
| 339 | |
| 340 | static phys_addr_t lmb_align_down(phys_addr_t addr, phys_size_t size) |
| 341 | { |
| 342 | return addr & ~(size - 1); |
| 343 | } |
| 344 | |
| 345 | /* |
Janne Grunau | e818d3c | 2024-11-11 07:56:33 +0100 | [diff] [blame] | 346 | * IOVA LMB memory maps using lmb pointers instead of the global LMB memory map. |
| 347 | */ |
| 348 | |
| 349 | int io_lmb_setup(struct lmb *io_lmb) |
| 350 | { |
| 351 | int ret; |
| 352 | |
| 353 | ret = alist_init(&io_lmb->free_mem, sizeof(struct lmb_region), |
| 354 | (uint)LMB_ALIST_INITIAL_SIZE); |
| 355 | if (!ret) { |
| 356 | log_debug("Unable to initialise the list for LMB free IOVA\n"); |
| 357 | return -ENOMEM; |
| 358 | } |
| 359 | |
| 360 | ret = alist_init(&io_lmb->used_mem, sizeof(struct lmb_region), |
| 361 | (uint)LMB_ALIST_INITIAL_SIZE); |
| 362 | if (!ret) { |
| 363 | log_debug("Unable to initialise the list for LMB used IOVA\n"); |
| 364 | return -ENOMEM; |
| 365 | } |
| 366 | |
| 367 | io_lmb->test = false; |
| 368 | |
| 369 | return 0; |
| 370 | } |
| 371 | |
| 372 | void io_lmb_teardown(struct lmb *io_lmb) |
| 373 | { |
| 374 | alist_uninit(&io_lmb->free_mem); |
| 375 | alist_uninit(&io_lmb->used_mem); |
| 376 | } |
| 377 | |
| 378 | long io_lmb_add(struct lmb *io_lmb, phys_addr_t base, phys_size_t size) |
| 379 | { |
| 380 | return lmb_add_region_flags(&io_lmb->free_mem, base, size, LMB_NONE); |
| 381 | } |
| 382 | |
| 383 | /* derived and simplified from _lmb_alloc_base() */ |
| 384 | phys_addr_t io_lmb_alloc(struct lmb *io_lmb, phys_size_t size, ulong align) |
| 385 | { |
| 386 | long i, rgn; |
| 387 | phys_addr_t base = 0; |
| 388 | phys_addr_t res_base; |
| 389 | struct lmb_region *lmb_used = io_lmb->used_mem.data; |
| 390 | struct lmb_region *lmb_memory = io_lmb->free_mem.data; |
| 391 | |
| 392 | for (i = io_lmb->free_mem.count - 1; i >= 0; i--) { |
| 393 | phys_addr_t lmbbase = lmb_memory[i].base; |
| 394 | phys_size_t lmbsize = lmb_memory[i].size; |
| 395 | |
| 396 | if (lmbsize < size) |
| 397 | continue; |
| 398 | base = lmb_align_down(lmbbase + lmbsize - size, align); |
| 399 | |
| 400 | while (base && lmbbase <= base) { |
| 401 | rgn = lmb_overlaps_region(&io_lmb->used_mem, base, size); |
| 402 | if (rgn < 0) { |
| 403 | /* This area isn't reserved, take it */ |
| 404 | if (lmb_add_region_flags(&io_lmb->used_mem, base, |
| 405 | size, LMB_NONE) < 0) |
| 406 | return 0; |
| 407 | |
| 408 | return base; |
| 409 | } |
| 410 | |
| 411 | res_base = lmb_used[rgn].base; |
| 412 | if (res_base < size) |
| 413 | break; |
| 414 | base = lmb_align_down(res_base - size, align); |
| 415 | } |
| 416 | } |
| 417 | return 0; |
| 418 | } |
| 419 | |
| 420 | long io_lmb_free(struct lmb *io_lmb, phys_addr_t base, phys_size_t size) |
| 421 | { |
| 422 | return _lmb_free(&io_lmb->used_mem, base, size); |
| 423 | } |
| 424 | |
| 425 | /* |
Janne Grunau | 5631f44 | 2024-11-11 07:56:32 +0100 | [diff] [blame] | 426 | * Low level LMB functions are used to manage IOVA memory maps for the Apple |
| 427 | * dart iommu. They must not access the global LMB memory map. |
| 428 | * So keep the global LMB variable declaration unreachable from them. |
| 429 | */ |
| 430 | |
| 431 | static struct lmb lmb; |
| 432 | |
| 433 | static bool lmb_should_notify(enum lmb_flags flags) |
| 434 | { |
| 435 | return !lmb.test && !(flags & LMB_NONOTIFY) && |
| 436 | CONFIG_IS_ENABLED(EFI_LOADER); |
| 437 | } |
| 438 | |
| 439 | static int lmb_map_update_notify(phys_addr_t addr, phys_size_t size, u8 op, |
| 440 | enum lmb_flags flags) |
| 441 | { |
| 442 | u64 efi_addr; |
| 443 | u64 pages; |
| 444 | efi_status_t status; |
| 445 | |
| 446 | if (op != MAP_OP_RESERVE && op != MAP_OP_FREE && op != MAP_OP_ADD) { |
| 447 | log_err("Invalid map update op received (%d)\n", op); |
| 448 | return -1; |
| 449 | } |
| 450 | |
| 451 | if (!lmb_should_notify(flags)) |
| 452 | return 0; |
| 453 | |
| 454 | efi_addr = (uintptr_t)map_sysmem(addr, 0); |
| 455 | pages = efi_size_in_pages(size + (efi_addr & EFI_PAGE_MASK)); |
| 456 | efi_addr &= ~EFI_PAGE_MASK; |
| 457 | |
| 458 | status = efi_add_memory_map_pg(efi_addr, pages, |
| 459 | op == MAP_OP_RESERVE ? |
| 460 | EFI_BOOT_SERVICES_DATA : |
| 461 | EFI_CONVENTIONAL_MEMORY, |
| 462 | false); |
| 463 | if (status != EFI_SUCCESS) { |
| 464 | log_err("%s: LMB Map notify failure %lu\n", __func__, |
| 465 | status & ~EFI_ERROR_MASK); |
| 466 | return -1; |
| 467 | } |
| 468 | unmap_sysmem((void *)(uintptr_t)efi_addr); |
| 469 | |
| 470 | return 0; |
| 471 | } |
| 472 | |
| 473 | static void lmb_print_region_flags(enum lmb_flags flags) |
| 474 | { |
Janne Grunau | 5631f44 | 2024-11-11 07:56:32 +0100 | [diff] [blame] | 475 | const char *flag_str[] = { "none", "no-map", "no-overwrite", "no-notify" }; |
Heinrich Schuchardt | 5573820 | 2024-11-02 07:32:26 +0100 | [diff] [blame] | 476 | unsigned int pflags = flags & |
| 477 | (LMB_NOMAP | LMB_NOOVERWRITE | LMB_NONOTIFY); |
| 478 | |
| 479 | if (flags != pflags) { |
| 480 | printf("invalid %#x\n", flags); |
| 481 | return; |
| 482 | } |
Janne Grunau | 5631f44 | 2024-11-11 07:56:32 +0100 | [diff] [blame] | 483 | |
| 484 | do { |
Heinrich Schuchardt | 5573820 | 2024-11-02 07:32:26 +0100 | [diff] [blame] | 485 | int bitpos = pflags ? fls(pflags) - 1 : 0; |
| 486 | |
Janne Grunau | 5631f44 | 2024-11-11 07:56:32 +0100 | [diff] [blame] | 487 | printf("%s", flag_str[bitpos]); |
Heinrich Schuchardt | 5573820 | 2024-11-02 07:32:26 +0100 | [diff] [blame] | 488 | pflags &= ~(1u << bitpos); |
| 489 | puts(pflags ? ", " : "\n"); |
| 490 | } while (pflags); |
Janne Grunau | 5631f44 | 2024-11-11 07:56:32 +0100 | [diff] [blame] | 491 | } |
| 492 | |
| 493 | static void lmb_dump_region(struct alist *lmb_rgn_lst, char *name) |
| 494 | { |
| 495 | struct lmb_region *rgn = lmb_rgn_lst->data; |
| 496 | unsigned long long base, size, end; |
| 497 | enum lmb_flags flags; |
| 498 | int i; |
| 499 | |
Heinrich Schuchardt | 2abe305 | 2024-11-07 11:14:42 +0100 | [diff] [blame] | 500 | printf(" %s.count = %#x\n", name, lmb_rgn_lst->count); |
Janne Grunau | 5631f44 | 2024-11-11 07:56:32 +0100 | [diff] [blame] | 501 | |
| 502 | for (i = 0; i < lmb_rgn_lst->count; i++) { |
| 503 | base = rgn[i].base; |
| 504 | size = rgn[i].size; |
| 505 | end = base + size - 1; |
| 506 | flags = rgn[i].flags; |
| 507 | |
Heinrich Schuchardt | 2abe305 | 2024-11-07 11:14:42 +0100 | [diff] [blame] | 508 | printf(" %s[%d]\t[%#llx-%#llx], %#llx bytes, flags: ", |
Janne Grunau | 5631f44 | 2024-11-11 07:56:32 +0100 | [diff] [blame] | 509 | name, i, base, end, size); |
| 510 | lmb_print_region_flags(flags); |
| 511 | } |
| 512 | } |
| 513 | |
| 514 | void lmb_dump_all_force(void) |
| 515 | { |
| 516 | printf("lmb_dump_all:\n"); |
| 517 | lmb_dump_region(&lmb.free_mem, "memory"); |
| 518 | lmb_dump_region(&lmb.used_mem, "reserved"); |
| 519 | } |
| 520 | |
| 521 | void lmb_dump_all(void) |
| 522 | { |
| 523 | #ifdef DEBUG |
| 524 | lmb_dump_all_force(); |
| 525 | #endif |
| 526 | } |
| 527 | |
| 528 | static void lmb_reserve_uboot_region(void) |
| 529 | { |
| 530 | int bank; |
| 531 | ulong end, bank_end; |
| 532 | phys_addr_t rsv_start; |
| 533 | |
| 534 | rsv_start = gd->start_addr_sp - CONFIG_STACK_SIZE; |
| 535 | end = gd->ram_top; |
| 536 | |
| 537 | /* |
| 538 | * Reserve memory from aligned address below the bottom of U-Boot stack |
| 539 | * until end of RAM area to prevent LMB from overwriting that memory. |
| 540 | */ |
| 541 | debug("## Current stack ends at 0x%08lx ", (ulong)rsv_start); |
| 542 | |
| 543 | for (bank = 0; bank < CONFIG_NR_DRAM_BANKS; bank++) { |
| 544 | if (!gd->bd->bi_dram[bank].size || |
| 545 | rsv_start < gd->bd->bi_dram[bank].start) |
| 546 | continue; |
| 547 | /* Watch out for RAM at end of address space! */ |
| 548 | bank_end = gd->bd->bi_dram[bank].start + |
| 549 | gd->bd->bi_dram[bank].size - 1; |
| 550 | if (rsv_start > bank_end) |
| 551 | continue; |
| 552 | if (bank_end > end) |
| 553 | bank_end = end - 1; |
| 554 | |
| 555 | lmb_reserve_flags(rsv_start, bank_end - rsv_start + 1, |
| 556 | LMB_NOOVERWRITE); |
| 557 | |
| 558 | if (gd->flags & GD_FLG_SKIP_RELOC) |
| 559 | lmb_reserve_flags((phys_addr_t)(uintptr_t)_start, |
| 560 | gd->mon_len, LMB_NOOVERWRITE); |
| 561 | |
| 562 | break; |
| 563 | } |
| 564 | } |
| 565 | |
| 566 | static void lmb_reserve_common(void *fdt_blob) |
| 567 | { |
| 568 | lmb_reserve_uboot_region(); |
| 569 | |
| 570 | if (CONFIG_IS_ENABLED(OF_LIBFDT) && fdt_blob) |
| 571 | boot_fdt_add_mem_rsv_regions(fdt_blob); |
| 572 | } |
| 573 | |
| 574 | static __maybe_unused void lmb_reserve_common_spl(void) |
| 575 | { |
| 576 | phys_addr_t rsv_start; |
| 577 | phys_size_t rsv_size; |
| 578 | |
| 579 | /* |
| 580 | * Assume a SPL stack of 16KB. This must be |
| 581 | * more than enough for the SPL stage. |
| 582 | */ |
| 583 | if (IS_ENABLED(CONFIG_SPL_STACK_R_ADDR)) { |
| 584 | rsv_start = gd->start_addr_sp - 16384; |
| 585 | rsv_size = 16384; |
| 586 | lmb_reserve_flags(rsv_start, rsv_size, LMB_NOOVERWRITE); |
| 587 | } |
| 588 | |
| 589 | if (IS_ENABLED(CONFIG_SPL_SEPARATE_BSS)) { |
| 590 | /* Reserve the bss region */ |
| 591 | rsv_start = (phys_addr_t)(uintptr_t)__bss_start; |
| 592 | rsv_size = (phys_addr_t)(uintptr_t)__bss_end - |
| 593 | (phys_addr_t)(uintptr_t)__bss_start; |
| 594 | lmb_reserve_flags(rsv_start, rsv_size, LMB_NOOVERWRITE); |
| 595 | } |
| 596 | } |
| 597 | |
| 598 | /** |
| 599 | * lmb_add_memory() - Add memory range for LMB allocations |
| 600 | * |
| 601 | * Add the entire available memory range to the pool of memory that |
| 602 | * can be used by the LMB module for allocations. |
| 603 | * |
| 604 | * Return: None |
| 605 | */ |
| 606 | void lmb_add_memory(void) |
| 607 | { |
| 608 | int i; |
Sughosh Ganu | ed220b8 | 2024-12-02 12:36:24 +0530 | [diff] [blame] | 609 | phys_addr_t bank_end; |
Janne Grunau | 5631f44 | 2024-11-11 07:56:32 +0100 | [diff] [blame] | 610 | phys_size_t size; |
| 611 | u64 ram_top = gd->ram_top; |
| 612 | struct bd_info *bd = gd->bd; |
| 613 | |
| 614 | if (CONFIG_IS_ENABLED(LMB_ARCH_MEM_MAP)) |
| 615 | return lmb_arch_add_memory(); |
| 616 | |
| 617 | /* Assume a 4GB ram_top if not defined */ |
| 618 | if (!ram_top) |
| 619 | ram_top = 0x100000000ULL; |
| 620 | |
| 621 | for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) { |
| 622 | size = bd->bi_dram[i].size; |
Sughosh Ganu | ed220b8 | 2024-12-02 12:36:24 +0530 | [diff] [blame] | 623 | bank_end = bd->bi_dram[i].start + size; |
| 624 | |
Janne Grunau | 5631f44 | 2024-11-11 07:56:32 +0100 | [diff] [blame] | 625 | if (size) { |
| 626 | lmb_add(bd->bi_dram[i].start, size); |
| 627 | |
| 628 | /* |
| 629 | * Reserve memory above ram_top as |
| 630 | * no-overwrite so that it cannot be |
| 631 | * allocated |
| 632 | */ |
| 633 | if (bd->bi_dram[i].start >= ram_top) |
| 634 | lmb_reserve_flags(bd->bi_dram[i].start, size, |
| 635 | LMB_NOOVERWRITE); |
Sughosh Ganu | ed220b8 | 2024-12-02 12:36:24 +0530 | [diff] [blame] | 636 | else if (bank_end > ram_top) |
| 637 | lmb_reserve_flags(ram_top, bank_end - ram_top, |
| 638 | LMB_NOOVERWRITE); |
Janne Grunau | 5631f44 | 2024-11-11 07:56:32 +0100 | [diff] [blame] | 639 | } |
| 640 | } |
| 641 | } |
| 642 | |
| 643 | static long lmb_add_region(struct alist *lmb_rgn_lst, phys_addr_t base, |
| 644 | phys_size_t size) |
| 645 | { |
| 646 | return lmb_add_region_flags(lmb_rgn_lst, base, size, LMB_NONE); |
| 647 | } |
| 648 | |
| 649 | /* This routine may be called with relocation disabled. */ |
| 650 | long lmb_add(phys_addr_t base, phys_size_t size) |
| 651 | { |
| 652 | long ret; |
| 653 | struct alist *lmb_rgn_lst = &lmb.free_mem; |
| 654 | |
| 655 | ret = lmb_add_region(lmb_rgn_lst, base, size); |
| 656 | if (ret) |
| 657 | return ret; |
| 658 | |
| 659 | return lmb_map_update_notify(base, size, MAP_OP_ADD, LMB_NONE); |
| 660 | } |
| 661 | |
Sughosh Ganu | 7f15d32 | 2024-10-15 21:07:03 +0530 | [diff] [blame] | 662 | /** |
| 663 | * lmb_free_flags() - Free up a region of memory |
| 664 | * @base: Base Address of region to be freed |
| 665 | * @size: Size of the region to be freed |
| 666 | * @flags: Memory region attributes |
| 667 | * |
| 668 | * Free up a region of memory. |
| 669 | * |
Sam Protsenko | b4f8110 | 2024-12-10 20:17:01 -0600 | [diff] [blame] | 670 | * Return: 0 if successful, negative error code on failure |
Sughosh Ganu | 7f15d32 | 2024-10-15 21:07:03 +0530 | [diff] [blame] | 671 | */ |
| 672 | long lmb_free_flags(phys_addr_t base, phys_size_t size, |
Sughosh Ganu | a3af5ba | 2024-10-15 21:07:07 +0530 | [diff] [blame] | 673 | uint flags) |
Sughosh Ganu | 7f15d32 | 2024-10-15 21:07:03 +0530 | [diff] [blame] | 674 | { |
Sughosh Ganu | a3af5ba | 2024-10-15 21:07:07 +0530 | [diff] [blame] | 675 | long ret; |
| 676 | |
Janne Grunau | d9c7040 | 2024-11-11 07:56:31 +0100 | [diff] [blame] | 677 | ret = _lmb_free(&lmb.used_mem, base, size); |
Sughosh Ganu | a3af5ba | 2024-10-15 21:07:07 +0530 | [diff] [blame] | 678 | if (ret < 0) |
| 679 | return ret; |
| 680 | |
Ilias Apalodimas | 2930f89 | 2024-10-23 18:22:01 +0300 | [diff] [blame] | 681 | return lmb_map_update_notify(base, size, MAP_OP_FREE, flags); |
Sughosh Ganu | 7f15d32 | 2024-10-15 21:07:03 +0530 | [diff] [blame] | 682 | } |
| 683 | |
Sughosh Ganu | a3af5ba | 2024-10-15 21:07:07 +0530 | [diff] [blame] | 684 | long lmb_free(phys_addr_t base, phys_size_t size) |
| 685 | { |
| 686 | return lmb_free_flags(base, size, LMB_NONE); |
| 687 | } |
| 688 | |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 689 | long lmb_reserve_flags(phys_addr_t base, phys_size_t size, enum lmb_flags flags) |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 690 | { |
Sughosh Ganu | a3af5ba | 2024-10-15 21:07:07 +0530 | [diff] [blame] | 691 | long ret = 0; |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 692 | struct alist *lmb_rgn_lst = &lmb.used_mem; |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 693 | |
Sughosh Ganu | a3af5ba | 2024-10-15 21:07:07 +0530 | [diff] [blame] | 694 | ret = lmb_add_region_flags(lmb_rgn_lst, base, size, flags); |
Ilias Apalodimas | 9849125 | 2024-10-23 18:22:00 +0300 | [diff] [blame] | 695 | if (ret) |
| 696 | return ret; |
Sughosh Ganu | a3af5ba | 2024-10-15 21:07:07 +0530 | [diff] [blame] | 697 | |
Ilias Apalodimas | 2930f89 | 2024-10-23 18:22:01 +0300 | [diff] [blame] | 698 | return lmb_map_update_notify(base, size, MAP_OP_RESERVE, flags); |
Patrick Delaunay | e11c908 | 2021-05-07 14:50:29 +0200 | [diff] [blame] | 699 | } |
| 700 | |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 701 | long lmb_reserve(phys_addr_t base, phys_size_t size) |
Patrick Delaunay | e11c908 | 2021-05-07 14:50:29 +0200 | [diff] [blame] | 702 | { |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 703 | return lmb_reserve_flags(base, size, LMB_NONE); |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 704 | } |
| 705 | |
Sughosh Ganu | 99b5966 | 2024-10-15 21:07:17 +0530 | [diff] [blame] | 706 | static phys_addr_t _lmb_alloc_base(phys_size_t size, ulong align, |
Sughosh Ganu | 50e2727 | 2024-08-26 17:29:19 +0530 | [diff] [blame] | 707 | phys_addr_t max_addr, enum lmb_flags flags) |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 708 | { |
Sughosh Ganu | a3af5ba | 2024-10-15 21:07:07 +0530 | [diff] [blame] | 709 | int ret; |
Simon Goldschmidt | f41f7d6 | 2019-01-21 20:29:56 +0100 | [diff] [blame] | 710 | long i, rgn; |
Becky Bruce | d26d67c | 2008-06-09 20:37:18 -0500 | [diff] [blame] | 711 | phys_addr_t base = 0; |
Andy Fleming | 78bd5a7 | 2008-06-16 13:58:55 -0500 | [diff] [blame] | 712 | phys_addr_t res_base; |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 713 | struct lmb_region *lmb_used = lmb.used_mem.data; |
| 714 | struct lmb_region *lmb_memory = lmb.free_mem.data; |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 715 | |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 716 | for (i = lmb.free_mem.count - 1; i >= 0; i--) { |
| 717 | phys_addr_t lmbbase = lmb_memory[i].base; |
| 718 | phys_size_t lmbsize = lmb_memory[i].size; |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 719 | |
Andy Fleming | 78bd5a7 | 2008-06-16 13:58:55 -0500 | [diff] [blame] | 720 | if (lmbsize < size) |
| 721 | continue; |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 722 | if (max_addr == LMB_ALLOC_ANYWHERE) |
| 723 | base = lmb_align_down(lmbbase + lmbsize - size, align); |
| 724 | else if (lmbbase < max_addr) { |
Stephen Warren | b6a010b | 2014-07-31 13:40:07 -0600 | [diff] [blame] | 725 | base = lmbbase + lmbsize; |
| 726 | if (base < lmbbase) |
| 727 | base = -1; |
| 728 | base = min(base, max_addr); |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 729 | base = lmb_align_down(base - size, align); |
| 730 | } else |
| 731 | continue; |
| 732 | |
Andy Fleming | 78bd5a7 | 2008-06-16 13:58:55 -0500 | [diff] [blame] | 733 | while (base && lmbbase <= base) { |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 734 | rgn = lmb_overlaps_region(&lmb.used_mem, base, size); |
Simon Goldschmidt | f41f7d6 | 2019-01-21 20:29:56 +0100 | [diff] [blame] | 735 | if (rgn < 0) { |
Andy Fleming | 78bd5a7 | 2008-06-16 13:58:55 -0500 | [diff] [blame] | 736 | /* This area isn't reserved, take it */ |
Sughosh Ganu | 50e2727 | 2024-08-26 17:29:19 +0530 | [diff] [blame] | 737 | if (lmb_add_region_flags(&lmb.used_mem, base, |
Ilias Apalodimas | 9849125 | 2024-10-23 18:22:00 +0300 | [diff] [blame] | 738 | size, flags)) |
Andy Fleming | 78bd5a7 | 2008-06-16 13:58:55 -0500 | [diff] [blame] | 739 | return 0; |
Sughosh Ganu | a3af5ba | 2024-10-15 21:07:07 +0530 | [diff] [blame] | 740 | |
Ilias Apalodimas | 2930f89 | 2024-10-23 18:22:01 +0300 | [diff] [blame] | 741 | ret = lmb_map_update_notify(base, size, |
| 742 | MAP_OP_RESERVE, |
| 743 | flags); |
| 744 | if (ret) |
| 745 | return ret; |
Sughosh Ganu | a3af5ba | 2024-10-15 21:07:07 +0530 | [diff] [blame] | 746 | |
Andy Fleming | 78bd5a7 | 2008-06-16 13:58:55 -0500 | [diff] [blame] | 747 | return base; |
| 748 | } |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 749 | |
| 750 | res_base = lmb_used[rgn].base; |
Andy Fleming | 78bd5a7 | 2008-06-16 13:58:55 -0500 | [diff] [blame] | 751 | if (res_base < size) |
| 752 | break; |
| 753 | base = lmb_align_down(res_base - size, align); |
| 754 | } |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 755 | } |
Andy Fleming | 78bd5a7 | 2008-06-16 13:58:55 -0500 | [diff] [blame] | 756 | return 0; |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 757 | } |
| 758 | |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 759 | phys_addr_t lmb_alloc(phys_size_t size, ulong align) |
Sughosh Ganu | 78435de | 2024-08-26 17:29:16 +0530 | [diff] [blame] | 760 | { |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 761 | return lmb_alloc_base(size, align, LMB_ALLOC_ANYWHERE); |
Sughosh Ganu | 78435de | 2024-08-26 17:29:16 +0530 | [diff] [blame] | 762 | } |
| 763 | |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 764 | phys_addr_t lmb_alloc_base(phys_size_t size, ulong align, phys_addr_t max_addr) |
Sughosh Ganu | 78435de | 2024-08-26 17:29:16 +0530 | [diff] [blame] | 765 | { |
| 766 | phys_addr_t alloc; |
| 767 | |
Sughosh Ganu | 99b5966 | 2024-10-15 21:07:17 +0530 | [diff] [blame] | 768 | alloc = _lmb_alloc_base(size, align, max_addr, LMB_NONE); |
Sughosh Ganu | 78435de | 2024-08-26 17:29:16 +0530 | [diff] [blame] | 769 | |
| 770 | if (alloc == 0) |
| 771 | printf("ERROR: Failed to allocate 0x%lx bytes below 0x%lx.\n", |
| 772 | (ulong)size, (ulong)max_addr); |
| 773 | |
| 774 | return alloc; |
| 775 | } |
| 776 | |
Sughosh Ganu | 7f15d32 | 2024-10-15 21:07:03 +0530 | [diff] [blame] | 777 | /** |
| 778 | * lmb_alloc_base_flags() - Allocate specified memory region with specified attributes |
| 779 | * @size: Size of the region requested |
| 780 | * @align: Alignment of the memory region requested |
| 781 | * @max_addr: Maximum address of the requested region |
| 782 | * @flags: Memory region attributes to be set |
| 783 | * |
| 784 | * Allocate a region of memory with the attributes specified through the |
| 785 | * parameter. The max_addr parameter is used to specify the maximum address |
| 786 | * below which the requested region should be allocated. |
| 787 | * |
| 788 | * Return: base address on success, 0 on error |
| 789 | */ |
| 790 | phys_addr_t lmb_alloc_base_flags(phys_size_t size, ulong align, |
| 791 | phys_addr_t max_addr, uint flags) |
| 792 | { |
| 793 | phys_addr_t alloc; |
| 794 | |
Sughosh Ganu | 99b5966 | 2024-10-15 21:07:17 +0530 | [diff] [blame] | 795 | alloc = _lmb_alloc_base(size, align, max_addr, flags); |
Sughosh Ganu | 7f15d32 | 2024-10-15 21:07:03 +0530 | [diff] [blame] | 796 | |
| 797 | if (alloc == 0) |
| 798 | printf("ERROR: Failed to allocate 0x%lx bytes below 0x%lx.\n", |
| 799 | (ulong)size, (ulong)max_addr); |
| 800 | |
| 801 | return alloc; |
| 802 | } |
| 803 | |
Sughosh Ganu | 99b5966 | 2024-10-15 21:07:17 +0530 | [diff] [blame] | 804 | static phys_addr_t _lmb_alloc_addr(phys_addr_t base, phys_size_t size, |
Sughosh Ganu | 50e2727 | 2024-08-26 17:29:19 +0530 | [diff] [blame] | 805 | enum lmb_flags flags) |
Simon Goldschmidt | 7a6ee46 | 2019-01-14 22:38:18 +0100 | [diff] [blame] | 806 | { |
Simon Goldschmidt | f41f7d6 | 2019-01-21 20:29:56 +0100 | [diff] [blame] | 807 | long rgn; |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 808 | struct lmb_region *lmb_memory = lmb.free_mem.data; |
Simon Goldschmidt | 7a6ee46 | 2019-01-14 22:38:18 +0100 | [diff] [blame] | 809 | |
| 810 | /* Check if the requested address is in one of the memory regions */ |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 811 | rgn = lmb_overlaps_region(&lmb.free_mem, base, size); |
Simon Goldschmidt | f41f7d6 | 2019-01-21 20:29:56 +0100 | [diff] [blame] | 812 | if (rgn >= 0) { |
Simon Goldschmidt | 7a6ee46 | 2019-01-14 22:38:18 +0100 | [diff] [blame] | 813 | /* |
| 814 | * Check if the requested end address is in the same memory |
| 815 | * region we found. |
| 816 | */ |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 817 | if (lmb_addrs_overlap(lmb_memory[rgn].base, |
| 818 | lmb_memory[rgn].size, |
Simon Goldschmidt | f41f7d6 | 2019-01-21 20:29:56 +0100 | [diff] [blame] | 819 | base + size - 1, 1)) { |
Simon Goldschmidt | 7a6ee46 | 2019-01-14 22:38:18 +0100 | [diff] [blame] | 820 | /* ok, reserve the memory */ |
Sam Protsenko | b4f8110 | 2024-12-10 20:17:01 -0600 | [diff] [blame] | 821 | if (!lmb_reserve_flags(base, size, flags)) |
Simon Goldschmidt | 7a6ee46 | 2019-01-14 22:38:18 +0100 | [diff] [blame] | 822 | return base; |
| 823 | } |
| 824 | } |
Sughosh Ganu | 50e2727 | 2024-08-26 17:29:19 +0530 | [diff] [blame] | 825 | |
Simon Goldschmidt | 7a6ee46 | 2019-01-14 22:38:18 +0100 | [diff] [blame] | 826 | return 0; |
| 827 | } |
| 828 | |
Sughosh Ganu | 50e2727 | 2024-08-26 17:29:19 +0530 | [diff] [blame] | 829 | /* |
| 830 | * Try to allocate a specific address range: must be in defined memory but not |
| 831 | * reserved |
| 832 | */ |
| 833 | phys_addr_t lmb_alloc_addr(phys_addr_t base, phys_size_t size) |
| 834 | { |
Sughosh Ganu | 99b5966 | 2024-10-15 21:07:17 +0530 | [diff] [blame] | 835 | return _lmb_alloc_addr(base, size, LMB_NONE); |
Sughosh Ganu | 50e2727 | 2024-08-26 17:29:19 +0530 | [diff] [blame] | 836 | } |
| 837 | |
Sughosh Ganu | 7f15d32 | 2024-10-15 21:07:03 +0530 | [diff] [blame] | 838 | /** |
| 839 | * lmb_alloc_addr_flags() - Allocate specified memory address with specified attributes |
| 840 | * @base: Base Address requested |
| 841 | * @size: Size of the region requested |
| 842 | * @flags: Memory region attributes to be set |
| 843 | * |
| 844 | * Allocate a region of memory with the attributes specified through the |
| 845 | * parameter. The base parameter is used to specify the base address |
| 846 | * of the requested region. |
| 847 | * |
| 848 | * Return: base address on success, 0 on error |
| 849 | */ |
| 850 | phys_addr_t lmb_alloc_addr_flags(phys_addr_t base, phys_size_t size, |
| 851 | uint flags) |
| 852 | { |
Sughosh Ganu | 99b5966 | 2024-10-15 21:07:17 +0530 | [diff] [blame] | 853 | return _lmb_alloc_addr(base, size, flags); |
Sughosh Ganu | 7f15d32 | 2024-10-15 21:07:03 +0530 | [diff] [blame] | 854 | } |
| 855 | |
Simon Goldschmidt | 7a6ee46 | 2019-01-14 22:38:18 +0100 | [diff] [blame] | 856 | /* Return number of bytes from a given address that are free */ |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 857 | phys_size_t lmb_get_free_size(phys_addr_t addr) |
Simon Goldschmidt | 7a6ee46 | 2019-01-14 22:38:18 +0100 | [diff] [blame] | 858 | { |
| 859 | int i; |
Simon Goldschmidt | f41f7d6 | 2019-01-21 20:29:56 +0100 | [diff] [blame] | 860 | long rgn; |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 861 | struct lmb_region *lmb_used = lmb.used_mem.data; |
| 862 | struct lmb_region *lmb_memory = lmb.free_mem.data; |
Simon Goldschmidt | 7a6ee46 | 2019-01-14 22:38:18 +0100 | [diff] [blame] | 863 | |
| 864 | /* check if the requested address is in the memory regions */ |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 865 | rgn = lmb_overlaps_region(&lmb.free_mem, addr, 1); |
Simon Goldschmidt | f41f7d6 | 2019-01-21 20:29:56 +0100 | [diff] [blame] | 866 | if (rgn >= 0) { |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 867 | for (i = 0; i < lmb.used_mem.count; i++) { |
| 868 | if (addr < lmb_used[i].base) { |
Simon Goldschmidt | 7a6ee46 | 2019-01-14 22:38:18 +0100 | [diff] [blame] | 869 | /* first reserved range > requested address */ |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 870 | return lmb_used[i].base - addr; |
Simon Goldschmidt | 7a6ee46 | 2019-01-14 22:38:18 +0100 | [diff] [blame] | 871 | } |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 872 | if (lmb_used[i].base + |
| 873 | lmb_used[i].size > addr) { |
Simon Goldschmidt | 7a6ee46 | 2019-01-14 22:38:18 +0100 | [diff] [blame] | 874 | /* requested addr is in this reserved range */ |
| 875 | return 0; |
| 876 | } |
| 877 | } |
| 878 | /* if we come here: no reserved ranges above requested addr */ |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 879 | return lmb_memory[lmb.free_mem.count - 1].base + |
| 880 | lmb_memory[lmb.free_mem.count - 1].size - addr; |
Simon Goldschmidt | 7a6ee46 | 2019-01-14 22:38:18 +0100 | [diff] [blame] | 881 | } |
| 882 | return 0; |
| 883 | } |
| 884 | |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 885 | int lmb_is_reserved_flags(phys_addr_t addr, int flags) |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 886 | { |
| 887 | int i; |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 888 | struct lmb_region *lmb_used = lmb.used_mem.data; |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 889 | |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 890 | for (i = 0; i < lmb.used_mem.count; i++) { |
| 891 | phys_addr_t upper = lmb_used[i].base + |
| 892 | lmb_used[i].size - 1; |
| 893 | if (addr >= lmb_used[i].base && addr <= upper) |
| 894 | return (lmb_used[i].flags & flags) == flags; |
Kumar Gala | 6d7bfa8 | 2008-02-27 21:51:47 -0600 | [diff] [blame] | 895 | } |
| 896 | return 0; |
| 897 | } |
Mike Frysinger | a0dadf8 | 2009-11-03 11:35:59 -0500 | [diff] [blame] | 898 | |
Sughosh Ganu | a3af5ba | 2024-10-15 21:07:07 +0530 | [diff] [blame] | 899 | static int lmb_setup(bool test) |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 900 | { |
| 901 | bool ret; |
| 902 | |
| 903 | ret = alist_init(&lmb.free_mem, sizeof(struct lmb_region), |
| 904 | (uint)LMB_ALIST_INITIAL_SIZE); |
| 905 | if (!ret) { |
| 906 | log_debug("Unable to initialise the list for LMB free memory\n"); |
| 907 | return -ENOMEM; |
| 908 | } |
| 909 | |
| 910 | ret = alist_init(&lmb.used_mem, sizeof(struct lmb_region), |
| 911 | (uint)LMB_ALIST_INITIAL_SIZE); |
| 912 | if (!ret) { |
| 913 | log_debug("Unable to initialise the list for LMB used memory\n"); |
| 914 | return -ENOMEM; |
| 915 | } |
| 916 | |
Sughosh Ganu | a3af5ba | 2024-10-15 21:07:07 +0530 | [diff] [blame] | 917 | lmb.test = test; |
| 918 | |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 919 | return 0; |
| 920 | } |
| 921 | |
| 922 | /** |
| 923 | * lmb_init() - Initialise the LMB module |
| 924 | * |
| 925 | * Initialise the LMB lists needed for keeping the memory map. There |
| 926 | * are two lists, in form of alloced list data structure. One for the |
| 927 | * available memory, and one for the used memory. Initialise the two |
| 928 | * lists as part of board init. Add memory to the available memory |
| 929 | * list and reserve common areas by adding them to the used memory |
| 930 | * list. |
| 931 | * |
| 932 | * Return: 0 on success, -ve on error |
| 933 | */ |
| 934 | int lmb_init(void) |
| 935 | { |
| 936 | int ret; |
| 937 | |
Sughosh Ganu | a3af5ba | 2024-10-15 21:07:07 +0530 | [diff] [blame] | 938 | ret = lmb_setup(false); |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 939 | if (ret) { |
| 940 | log_info("Unable to init LMB\n"); |
| 941 | return ret; |
| 942 | } |
| 943 | |
Sughosh Ganu | 65597fa | 2024-08-26 17:29:23 +0530 | [diff] [blame] | 944 | lmb_add_memory(); |
| 945 | |
Sughosh Ganu | 6518b41 | 2024-08-26 17:29:24 +0530 | [diff] [blame] | 946 | /* Reserve the U-Boot image region once U-Boot has relocated */ |
Simon Glass | d4dce4a | 2024-09-29 19:49:36 -0600 | [diff] [blame] | 947 | if (xpl_phase() == PHASE_SPL) |
Sughosh Ganu | 6518b41 | 2024-08-26 17:29:24 +0530 | [diff] [blame] | 948 | lmb_reserve_common_spl(); |
Simon Glass | d4dce4a | 2024-09-29 19:49:36 -0600 | [diff] [blame] | 949 | else if (xpl_phase() == PHASE_BOARD_R) |
Sughosh Ganu | 6518b41 | 2024-08-26 17:29:24 +0530 | [diff] [blame] | 950 | lmb_reserve_common((void *)gd->fdt_blob); |
| 951 | |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 952 | return 0; |
| 953 | } |
| 954 | |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 955 | struct lmb *lmb_get(void) |
| 956 | { |
| 957 | return &lmb; |
| 958 | } |
| 959 | |
Simon Glass | 176eba5 | 2024-10-21 10:19:31 +0200 | [diff] [blame] | 960 | #if CONFIG_IS_ENABLED(UNIT_TEST) |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 961 | int lmb_push(struct lmb *store) |
| 962 | { |
| 963 | int ret; |
| 964 | |
| 965 | *store = lmb; |
Sughosh Ganu | a3af5ba | 2024-10-15 21:07:07 +0530 | [diff] [blame] | 966 | ret = lmb_setup(true); |
Sughosh Ganu | 291bf9c | 2024-08-26 17:29:18 +0530 | [diff] [blame] | 967 | if (ret) |
| 968 | return ret; |
| 969 | |
| 970 | return 0; |
| 971 | } |
| 972 | |
| 973 | void lmb_pop(struct lmb *store) |
| 974 | { |
| 975 | alist_uninit(&lmb.free_mem); |
| 976 | alist_uninit(&lmb.used_mem); |
| 977 | lmb = *store; |
| 978 | } |
| 979 | #endif /* UNIT_TEST */ |