]>
Commit | Line | Data |
---|---|---|
50149ea3 AG |
1 | /* |
2 | * EFI application runtime services | |
3 | * | |
4 | * Copyright (c) 2016 Alexander Graf | |
5 | * | |
6 | * SPDX-License-Identifier: GPL-2.0+ | |
7 | */ | |
8 | ||
9 | #include <common.h> | |
10 | #include <command.h> | |
11 | #include <dm.h> | |
12 | #include <efi_loader.h> | |
13 | #include <rtc.h> | |
14 | #include <asm/global_data.h> | |
15 | ||
16 | /* For manual relocation support */ | |
17 | DECLARE_GLOBAL_DATA_PTR; | |
18 | ||
80a4800e AG |
19 | struct efi_runtime_mmio_list { |
20 | struct list_head link; | |
21 | void **ptr; | |
22 | u64 paddr; | |
23 | u64 len; | |
24 | }; | |
25 | ||
26 | /* This list contains all runtime available mmio regions */ | |
27 | LIST_HEAD(efi_runtime_mmio); | |
28 | ||
3c63db9c AG |
29 | static efi_status_t __efi_runtime EFIAPI efi_unimplemented(void); |
30 | static efi_status_t __efi_runtime EFIAPI efi_device_error(void); | |
31 | static efi_status_t __efi_runtime EFIAPI efi_invalid_parameter(void); | |
50149ea3 | 32 | |
36c37a84 AG |
33 | #ifdef CONFIG_SYS_CACHELINE_SIZE |
34 | #define EFI_CACHELINE_SIZE CONFIG_SYS_CACHELINE_SIZE | |
35 | #else | |
36 | /* Just use the greatest cache flush alignment requirement I'm aware of */ | |
37 | #define EFI_CACHELINE_SIZE 128 | |
38 | #endif | |
39 | ||
50149ea3 AG |
40 | #if defined(CONFIG_ARM64) |
41 | #define R_RELATIVE 1027 | |
42 | #define R_MASK 0xffffffffULL | |
43 | #define IS_RELA 1 | |
44 | #elif defined(CONFIG_ARM) | |
45 | #define R_RELATIVE 23 | |
46 | #define R_MASK 0xffULL | |
65e4c0b1 SG |
47 | #elif defined(CONFIG_X86) |
48 | #include <asm/elf.h> | |
49 | #define R_RELATIVE R_386_RELATIVE | |
50 | #define R_MASK 0xffULL | |
50149ea3 AG |
51 | #else |
52 | #error Need to add relocation awareness | |
53 | #endif | |
54 | ||
55 | struct elf_rel { | |
56 | ulong *offset; | |
57 | ulong info; | |
58 | }; | |
59 | ||
60 | struct elf_rela { | |
61 | ulong *offset; | |
62 | ulong info; | |
63 | long addend; | |
64 | }; | |
65 | ||
66 | /* | |
67 | * EFI Runtime code lives in 2 stages. In the first stage, U-Boot and an EFI | |
68 | * payload are running concurrently at the same time. In this mode, we can | |
69 | * handle a good number of runtime callbacks | |
70 | */ | |
71 | ||
80a4800e AG |
72 | static void EFIAPI efi_reset_system_boottime( |
73 | enum efi_reset_type reset_type, | |
74 | efi_status_t reset_status, | |
75 | unsigned long data_size, void *reset_data) | |
50149ea3 AG |
76 | { |
77 | EFI_ENTRY("%d %lx %lx %p", reset_type, reset_status, data_size, | |
78 | reset_data); | |
79 | ||
80 | switch (reset_type) { | |
81 | case EFI_RESET_COLD: | |
82 | case EFI_RESET_WARM: | |
83 | do_reset(NULL, 0, 0, NULL); | |
84 | break; | |
85 | case EFI_RESET_SHUTDOWN: | |
86 | /* We don't have anything to map this to */ | |
87 | break; | |
88 | } | |
89 | ||
80a4800e | 90 | while (1) { } |
50149ea3 AG |
91 | } |
92 | ||
80a4800e AG |
93 | static efi_status_t EFIAPI efi_get_time_boottime( |
94 | struct efi_time *time, | |
95 | struct efi_time_cap *capabilities) | |
50149ea3 AG |
96 | { |
97 | #if defined(CONFIG_CMD_DATE) && defined(CONFIG_DM_RTC) | |
98 | struct rtc_time tm; | |
99 | int r; | |
100 | struct udevice *dev; | |
101 | ||
102 | EFI_ENTRY("%p %p", time, capabilities); | |
103 | ||
104 | r = uclass_get_device(UCLASS_RTC, 0, &dev); | |
105 | if (r) | |
106 | return EFI_EXIT(EFI_DEVICE_ERROR); | |
107 | ||
108 | r = dm_rtc_get(dev, &tm); | |
109 | if (r) | |
110 | return EFI_EXIT(EFI_DEVICE_ERROR); | |
111 | ||
112 | memset(time, 0, sizeof(*time)); | |
113 | time->year = tm.tm_year; | |
114 | time->month = tm.tm_mon; | |
115 | time->day = tm.tm_mday; | |
116 | time->hour = tm.tm_hour; | |
117 | time->minute = tm.tm_min; | |
118 | time->daylight = tm.tm_isdst; | |
119 | ||
120 | return EFI_EXIT(EFI_SUCCESS); | |
121 | #else | |
122 | return EFI_DEVICE_ERROR; | |
123 | #endif | |
124 | } | |
125 | ||
80a4800e AG |
126 | /* Boards may override the helpers below to implement RTS functionality */ |
127 | ||
3c63db9c | 128 | void __weak __efi_runtime EFIAPI efi_reset_system( |
80a4800e AG |
129 | enum efi_reset_type reset_type, |
130 | efi_status_t reset_status, | |
131 | unsigned long data_size, void *reset_data) | |
132 | { | |
133 | /* Nothing we can do */ | |
134 | while (1) { } | |
135 | } | |
136 | ||
137 | void __weak efi_reset_system_init(void) | |
138 | { | |
139 | } | |
140 | ||
3c63db9c | 141 | efi_status_t __weak __efi_runtime EFIAPI efi_get_time( |
80a4800e AG |
142 | struct efi_time *time, |
143 | struct efi_time_cap *capabilities) | |
144 | { | |
145 | /* Nothing we can do */ | |
146 | return EFI_DEVICE_ERROR; | |
147 | } | |
148 | ||
149 | void __weak efi_get_time_init(void) | |
150 | { | |
151 | } | |
152 | ||
50149ea3 AG |
153 | struct efi_runtime_detach_list_struct { |
154 | void *ptr; | |
155 | void *patchto; | |
156 | }; | |
157 | ||
158 | static const struct efi_runtime_detach_list_struct efi_runtime_detach_list[] = { | |
159 | { | |
160 | /* do_reset is gone */ | |
161 | .ptr = &efi_runtime_services.reset_system, | |
80a4800e | 162 | .patchto = efi_reset_system, |
50149ea3 AG |
163 | }, { |
164 | /* invalidate_*cache_all are gone */ | |
165 | .ptr = &efi_runtime_services.set_virtual_address_map, | |
166 | .patchto = &efi_invalid_parameter, | |
167 | }, { | |
168 | /* RTC accessors are gone */ | |
169 | .ptr = &efi_runtime_services.get_time, | |
80a4800e | 170 | .patchto = &efi_get_time, |
ae874405 AG |
171 | }, { |
172 | /* Clean up system table */ | |
173 | .ptr = &systab.con_in, | |
174 | .patchto = NULL, | |
175 | }, { | |
176 | /* Clean up system table */ | |
177 | .ptr = &systab.con_out, | |
178 | .patchto = NULL, | |
179 | }, { | |
180 | /* Clean up system table */ | |
181 | .ptr = &systab.std_err, | |
182 | .patchto = NULL, | |
183 | }, { | |
184 | /* Clean up system table */ | |
185 | .ptr = &systab.boottime, | |
186 | .patchto = NULL, | |
ad644e7c RC |
187 | }, { |
188 | .ptr = &efi_runtime_services.get_variable, | |
189 | .patchto = &efi_device_error, | |
190 | }, { | |
191 | .ptr = &efi_runtime_services.get_next_variable, | |
192 | .patchto = &efi_device_error, | |
193 | }, { | |
194 | .ptr = &efi_runtime_services.set_variable, | |
195 | .patchto = &efi_device_error, | |
196 | } | |
50149ea3 AG |
197 | }; |
198 | ||
199 | static bool efi_runtime_tobedetached(void *p) | |
200 | { | |
201 | int i; | |
202 | ||
203 | for (i = 0; i < ARRAY_SIZE(efi_runtime_detach_list); i++) | |
204 | if (efi_runtime_detach_list[i].ptr == p) | |
205 | return true; | |
206 | ||
207 | return false; | |
208 | } | |
209 | ||
210 | static void efi_runtime_detach(ulong offset) | |
211 | { | |
212 | int i; | |
213 | ulong patchoff = offset - (ulong)gd->relocaddr; | |
214 | ||
215 | for (i = 0; i < ARRAY_SIZE(efi_runtime_detach_list); i++) { | |
216 | ulong patchto = (ulong)efi_runtime_detach_list[i].patchto; | |
217 | ulong *p = efi_runtime_detach_list[i].ptr; | |
218 | ulong newaddr = patchto ? (patchto + patchoff) : 0; | |
219 | ||
edcef3ba | 220 | debug("%s: Setting %p to %lx\n", __func__, p, newaddr); |
50149ea3 AG |
221 | *p = newaddr; |
222 | } | |
223 | } | |
224 | ||
225 | /* Relocate EFI runtime to uboot_reloc_base = offset */ | |
226 | void efi_runtime_relocate(ulong offset, struct efi_mem_desc *map) | |
227 | { | |
228 | #ifdef IS_RELA | |
229 | struct elf_rela *rel = (void*)&__efi_runtime_rel_start; | |
230 | #else | |
231 | struct elf_rel *rel = (void*)&__efi_runtime_rel_start; | |
232 | static ulong lastoff = CONFIG_SYS_TEXT_BASE; | |
233 | #endif | |
234 | ||
edcef3ba | 235 | debug("%s: Relocating to offset=%lx\n", __func__, offset); |
50149ea3 AG |
236 | for (; (ulong)rel < (ulong)&__efi_runtime_rel_stop; rel++) { |
237 | ulong base = CONFIG_SYS_TEXT_BASE; | |
238 | ulong *p; | |
239 | ulong newaddr; | |
240 | ||
241 | p = (void*)((ulong)rel->offset - base) + gd->relocaddr; | |
242 | ||
243 | if ((rel->info & R_MASK) != R_RELATIVE) { | |
244 | continue; | |
245 | } | |
246 | ||
247 | #ifdef IS_RELA | |
248 | newaddr = rel->addend + offset - CONFIG_SYS_TEXT_BASE; | |
249 | #else | |
250 | newaddr = *p - lastoff + offset; | |
251 | #endif | |
252 | ||
253 | /* Check if the relocation is inside bounds */ | |
254 | if (map && ((newaddr < map->virtual_start) || | |
591cf2e1 HS |
255 | newaddr > (map->virtual_start + |
256 | (map->num_pages << EFI_PAGE_SHIFT)))) { | |
50149ea3 AG |
257 | if (!efi_runtime_tobedetached(p)) |
258 | printf("U-Boot EFI: Relocation at %p is out of " | |
259 | "range (%lx)\n", p, newaddr); | |
260 | continue; | |
261 | } | |
262 | ||
edcef3ba | 263 | debug("%s: Setting %p to %lx\n", __func__, p, newaddr); |
50149ea3 | 264 | *p = newaddr; |
36c37a84 AG |
265 | flush_dcache_range((ulong)p & ~(EFI_CACHELINE_SIZE - 1), |
266 | ALIGN((ulong)&p[1], EFI_CACHELINE_SIZE)); | |
50149ea3 AG |
267 | } |
268 | ||
269 | #ifndef IS_RELA | |
270 | lastoff = offset; | |
271 | #endif | |
272 | ||
273 | invalidate_icache_all(); | |
274 | } | |
275 | ||
276 | static efi_status_t EFIAPI efi_set_virtual_address_map( | |
277 | unsigned long memory_map_size, | |
278 | unsigned long descriptor_size, | |
279 | uint32_t descriptor_version, | |
280 | struct efi_mem_desc *virtmap) | |
281 | { | |
591cf2e1 HS |
282 | ulong runtime_start = (ulong)&__efi_runtime_start & |
283 | ~(ulong)EFI_PAGE_MASK; | |
50149ea3 AG |
284 | int n = memory_map_size / descriptor_size; |
285 | int i; | |
286 | ||
287 | EFI_ENTRY("%lx %lx %x %p", memory_map_size, descriptor_size, | |
288 | descriptor_version, virtmap); | |
289 | ||
80a4800e AG |
290 | /* Rebind mmio pointers */ |
291 | for (i = 0; i < n; i++) { | |
292 | struct efi_mem_desc *map = (void*)virtmap + | |
293 | (descriptor_size * i); | |
294 | struct list_head *lhandle; | |
295 | efi_physical_addr_t map_start = map->physical_start; | |
296 | efi_physical_addr_t map_len = map->num_pages << EFI_PAGE_SHIFT; | |
297 | efi_physical_addr_t map_end = map_start + map_len; | |
298 | ||
299 | /* Adjust all mmio pointers in this region */ | |
300 | list_for_each(lhandle, &efi_runtime_mmio) { | |
301 | struct efi_runtime_mmio_list *lmmio; | |
302 | ||
303 | lmmio = list_entry(lhandle, | |
304 | struct efi_runtime_mmio_list, | |
305 | link); | |
306 | if ((map_start <= lmmio->paddr) && | |
307 | (map_end >= lmmio->paddr)) { | |
308 | u64 off = map->virtual_start - map_start; | |
309 | uintptr_t new_addr = lmmio->paddr + off; | |
310 | *lmmio->ptr = (void *)new_addr; | |
311 | } | |
312 | } | |
313 | } | |
314 | ||
315 | /* Move the actual runtime code over */ | |
50149ea3 AG |
316 | for (i = 0; i < n; i++) { |
317 | struct efi_mem_desc *map; | |
318 | ||
319 | map = (void*)virtmap + (descriptor_size * i); | |
320 | if (map->type == EFI_RUNTIME_SERVICES_CODE) { | |
80a4800e AG |
321 | ulong new_offset = map->virtual_start - |
322 | (runtime_start - gd->relocaddr); | |
50149ea3 AG |
323 | |
324 | efi_runtime_relocate(new_offset, map); | |
325 | /* Once we're virtual, we can no longer handle | |
326 | complex callbacks */ | |
327 | efi_runtime_detach(new_offset); | |
328 | return EFI_EXIT(EFI_SUCCESS); | |
329 | } | |
330 | } | |
331 | ||
332 | return EFI_EXIT(EFI_INVALID_PARAMETER); | |
333 | } | |
334 | ||
80a4800e AG |
335 | void efi_add_runtime_mmio(void *mmio_ptr, u64 len) |
336 | { | |
337 | struct efi_runtime_mmio_list *newmmio; | |
338 | ||
aee4f06d | 339 | u64 pages = (len + EFI_PAGE_MASK) >> EFI_PAGE_SHIFT; |
80a4800e AG |
340 | efi_add_memory_map(*(uintptr_t *)mmio_ptr, pages, EFI_MMAP_IO, false); |
341 | ||
342 | newmmio = calloc(1, sizeof(*newmmio)); | |
343 | newmmio->ptr = mmio_ptr; | |
344 | newmmio->paddr = *(uintptr_t *)mmio_ptr; | |
345 | newmmio->len = len; | |
346 | list_add_tail(&newmmio->link, &efi_runtime_mmio); | |
347 | } | |
348 | ||
50149ea3 AG |
349 | /* |
350 | * In the second stage, U-Boot has disappeared. To isolate our runtime code | |
351 | * that at this point still exists from the rest, we put it into a special | |
352 | * section. | |
353 | * | |
354 | * !!WARNING!! | |
355 | * | |
356 | * This means that we can not rely on any code outside of this file in any | |
357 | * function or variable below this line. | |
358 | * | |
359 | * Please keep everything fully self-contained and annotated with | |
3c63db9c | 360 | * __efi_runtime and __efi_runtime_data markers. |
50149ea3 AG |
361 | */ |
362 | ||
363 | /* | |
364 | * Relocate the EFI runtime stub to a different place. We need to call this | |
365 | * the first time we expose the runtime interface to a user and on set virtual | |
366 | * address map calls. | |
367 | */ | |
368 | ||
3c63db9c | 369 | static efi_status_t __efi_runtime EFIAPI efi_unimplemented(void) |
50149ea3 AG |
370 | { |
371 | return EFI_UNSUPPORTED; | |
372 | } | |
373 | ||
3c63db9c | 374 | static efi_status_t __efi_runtime EFIAPI efi_device_error(void) |
50149ea3 AG |
375 | { |
376 | return EFI_DEVICE_ERROR; | |
377 | } | |
378 | ||
3c63db9c | 379 | static efi_status_t __efi_runtime EFIAPI efi_invalid_parameter(void) |
50149ea3 AG |
380 | { |
381 | return EFI_INVALID_PARAMETER; | |
382 | } | |
383 | ||
3c63db9c | 384 | struct efi_runtime_services __efi_runtime_data efi_runtime_services = { |
50149ea3 AG |
385 | .hdr = { |
386 | .signature = EFI_RUNTIME_SERVICES_SIGNATURE, | |
387 | .revision = EFI_RUNTIME_SERVICES_REVISION, | |
388 | .headersize = sizeof(struct efi_table_hdr), | |
389 | }, | |
80a4800e | 390 | .get_time = &efi_get_time_boottime, |
50149ea3 AG |
391 | .set_time = (void *)&efi_device_error, |
392 | .get_wakeup_time = (void *)&efi_unimplemented, | |
393 | .set_wakeup_time = (void *)&efi_unimplemented, | |
394 | .set_virtual_address_map = &efi_set_virtual_address_map, | |
395 | .convert_pointer = (void *)&efi_invalid_parameter, | |
ad644e7c RC |
396 | .get_variable = efi_get_variable, |
397 | .get_next_variable = efi_get_next_variable, | |
398 | .set_variable = efi_set_variable, | |
50149ea3 | 399 | .get_next_high_mono_count = (void *)&efi_device_error, |
80a4800e | 400 | .reset_system = &efi_reset_system_boottime, |
50149ea3 | 401 | }; |