blob: 51080cbeed2f35d03fb1deb983a0d0a26021a92b [file] [log] [blame]
Alexander Grafbee91162016-03-04 01:09:59 +01001/*
2 * EFI application boot time services
3 *
4 * Copyright (c) 2016 Alexander Graf
5 *
6 * SPDX-License-Identifier: GPL-2.0+
7 */
8
Alexander Grafbee91162016-03-04 01:09:59 +01009#include <common.h>
10#include <efi_loader.h>
11#include <malloc.h>
12#include <asm/global_data.h>
13#include <libfdt_env.h>
14#include <u-boot/crc.h>
15#include <bootm.h>
16#include <inttypes.h>
17#include <watchdog.h>
18
19DECLARE_GLOBAL_DATA_PTR;
20
21/* This list contains all the EFI objects our payload has access to */
22LIST_HEAD(efi_obj_list);
23
24/*
25 * If we're running on nasty systems (32bit ARM booting into non-EFI Linux)
26 * we need to do trickery with caches. Since we don't want to break the EFI
27 * aware boot path, only apply hacks when loading exiting directly (breaking
28 * direct Linux EFI booting along the way - oh well).
29 */
30static bool efi_is_direct_boot = true;
31
32/*
33 * EFI can pass arbitrary additional "tables" containing vendor specific
34 * information to the payload. One such table is the FDT table which contains
35 * a pointer to a flattened device tree blob.
36 *
37 * In most cases we want to pass an FDT to the payload, so reserve one slot of
38 * config table space for it. The pointer gets populated by do_bootefi_exec().
39 */
Alexander Graf3c63db92016-10-14 13:45:30 +020040static struct efi_configuration_table __efi_runtime_data efi_conf_table[2];
Alexander Grafbee91162016-03-04 01:09:59 +010041
Simon Glass65e4c0b2016-09-25 15:27:35 -060042#ifdef CONFIG_ARM
Alexander Grafbee91162016-03-04 01:09:59 +010043/*
44 * The "gd" pointer lives in a register on ARM and AArch64 that we declare
45 * fixed when compiling U-Boot. However, the payload does not know about that
46 * restriction so we need to manually swap its and our view of that register on
47 * EFI callback entry/exit.
48 */
49static volatile void *efi_gd, *app_gd;
Simon Glass65e4c0b2016-09-25 15:27:35 -060050#endif
Alexander Grafbee91162016-03-04 01:09:59 +010051
52/* Called from do_bootefi_exec() */
53void efi_save_gd(void)
54{
Simon Glass65e4c0b2016-09-25 15:27:35 -060055#ifdef CONFIG_ARM
Alexander Grafbee91162016-03-04 01:09:59 +010056 efi_gd = gd;
Simon Glass65e4c0b2016-09-25 15:27:35 -060057#endif
Alexander Grafbee91162016-03-04 01:09:59 +010058}
59
60/* Called on every callback entry */
61void efi_restore_gd(void)
62{
Simon Glass65e4c0b2016-09-25 15:27:35 -060063#ifdef CONFIG_ARM
Alexander Grafbee91162016-03-04 01:09:59 +010064 /* Only restore if we're already in EFI context */
65 if (!efi_gd)
66 return;
67
68 if (gd != efi_gd)
69 app_gd = gd;
70 gd = efi_gd;
Simon Glass65e4c0b2016-09-25 15:27:35 -060071#endif
Alexander Grafbee91162016-03-04 01:09:59 +010072}
73
74/* Called on every callback exit */
75efi_status_t efi_exit_func(efi_status_t ret)
76{
Simon Glass65e4c0b2016-09-25 15:27:35 -060077#ifdef CONFIG_ARM
Alexander Grafbee91162016-03-04 01:09:59 +010078 gd = app_gd;
Simon Glass65e4c0b2016-09-25 15:27:35 -060079#endif
80
Alexander Grafbee91162016-03-04 01:09:59 +010081 return ret;
82}
83
84static efi_status_t efi_unsupported(const char *funcname)
85{
Alexander Grafedcef3b2016-06-02 11:38:27 +020086 debug("EFI: App called into unimplemented function %s\n", funcname);
Alexander Grafbee91162016-03-04 01:09:59 +010087 return EFI_EXIT(EFI_UNSUPPORTED);
88}
89
90static int guidcmp(const efi_guid_t *g1, const efi_guid_t *g2)
91{
92 return memcmp(g1, g2, sizeof(efi_guid_t));
93}
94
95static unsigned long EFIAPI efi_raise_tpl(unsigned long new_tpl)
96{
97 EFI_ENTRY("0x%lx", new_tpl);
98 return EFI_EXIT(0);
99}
100
101static void EFIAPI efi_restore_tpl(unsigned long old_tpl)
102{
103 EFI_ENTRY("0x%lx", old_tpl);
104 EFI_EXIT(efi_unsupported(__func__));
105}
106
107efi_status_t EFIAPI efi_allocate_pages_ext(int type, int memory_type,
108 unsigned long pages,
109 uint64_t *memory)
110{
111 efi_status_t r;
112
113 EFI_ENTRY("%d, %d, 0x%lx, %p", type, memory_type, pages, memory);
114 r = efi_allocate_pages(type, memory_type, pages, memory);
115 return EFI_EXIT(r);
116}
117
118efi_status_t EFIAPI efi_free_pages_ext(uint64_t memory, unsigned long pages)
119{
120 efi_status_t r;
121
122 EFI_ENTRY("%"PRIx64", 0x%lx", memory, pages);
123 r = efi_free_pages(memory, pages);
124 return EFI_EXIT(r);
125}
126
127efi_status_t EFIAPI efi_get_memory_map_ext(unsigned long *memory_map_size,
128 struct efi_mem_desc *memory_map,
129 unsigned long *map_key,
130 unsigned long *descriptor_size,
131 uint32_t *descriptor_version)
132{
133 efi_status_t r;
134
135 EFI_ENTRY("%p, %p, %p, %p, %p", memory_map_size, memory_map,
136 map_key, descriptor_size, descriptor_version);
137 r = efi_get_memory_map(memory_map_size, memory_map, map_key,
138 descriptor_size, descriptor_version);
139 return EFI_EXIT(r);
140}
141
Stefan Brünsead12742016-10-09 22:17:18 +0200142static efi_status_t EFIAPI efi_allocate_pool_ext(int pool_type,
143 unsigned long size,
144 void **buffer)
Alexander Grafbee91162016-03-04 01:09:59 +0100145{
Alexander Graf1cd29f02016-03-24 01:37:37 +0100146 efi_status_t r;
147
148 EFI_ENTRY("%d, %ld, %p", pool_type, size, buffer);
Stefan Brünsead12742016-10-09 22:17:18 +0200149 r = efi_allocate_pool(pool_type, size, buffer);
Alexander Graf1cd29f02016-03-24 01:37:37 +0100150 return EFI_EXIT(r);
Alexander Grafbee91162016-03-04 01:09:59 +0100151}
152
Stefan Brüns42417bc2016-10-09 22:17:26 +0200153static efi_status_t EFIAPI efi_free_pool_ext(void *buffer)
Alexander Grafbee91162016-03-04 01:09:59 +0100154{
Alexander Graf1cd29f02016-03-24 01:37:37 +0100155 efi_status_t r;
156
157 EFI_ENTRY("%p", buffer);
Stefan Brüns42417bc2016-10-09 22:17:26 +0200158 r = efi_free_pool(buffer);
Alexander Graf1cd29f02016-03-24 01:37:37 +0100159 return EFI_EXIT(r);
Alexander Grafbee91162016-03-04 01:09:59 +0100160}
161
162/*
163 * Our event capabilities are very limited. Only support a single
164 * event to exist, so we don't need to maintain lists.
165 */
166static struct {
167 enum efi_event_type type;
168 u32 trigger_type;
169 u32 trigger_time;
170 u64 trigger_next;
171 unsigned long notify_tpl;
Simon Glasse2754582016-09-25 15:27:32 -0600172 void (EFIAPI *notify_function) (void *event, void *context);
Alexander Grafbee91162016-03-04 01:09:59 +0100173 void *notify_context;
174} efi_event = {
175 /* Disable timers on bootup */
176 .trigger_next = -1ULL,
177};
178
179static efi_status_t EFIAPI efi_create_event(
180 enum efi_event_type type, ulong notify_tpl,
Simon Glasse2754582016-09-25 15:27:32 -0600181 void (EFIAPI *notify_function) (void *event,
182 void *context),
Alexander Grafbee91162016-03-04 01:09:59 +0100183 void *notify_context, void **event)
184{
185 EFI_ENTRY("%d, 0x%lx, %p, %p", type, notify_tpl, notify_function,
186 notify_context);
187 if (efi_event.notify_function) {
188 /* We only support one event at a time */
189 return EFI_EXIT(EFI_OUT_OF_RESOURCES);
190 }
191
192 efi_event.type = type;
193 efi_event.notify_tpl = notify_tpl;
194 efi_event.notify_function = notify_function;
195 efi_event.notify_context = notify_context;
196 *event = &efi_event;
197
198 return EFI_EXIT(EFI_SUCCESS);
199}
200
201/*
202 * Our timers have to work without interrupts, so we check whenever keyboard
203 * input or disk accesses happen if enough time elapsed for it to fire.
204 */
205void efi_timer_check(void)
206{
207 u64 now = timer_get_us();
208
209 if (now >= efi_event.trigger_next) {
210 /* Triggering! */
211 if (efi_event.trigger_type == EFI_TIMER_PERIODIC)
212 efi_event.trigger_next += efi_event.trigger_time / 10;
213 efi_event.notify_function(&efi_event, efi_event.notify_context);
214 }
215
216 WATCHDOG_RESET();
217}
218
219static efi_status_t EFIAPI efi_set_timer(void *event, int type,
220 uint64_t trigger_time)
221{
222 /* We don't have 64bit division available everywhere, so limit timer
223 * distances to 32bit bits. */
224 u32 trigger32 = trigger_time;
225
226 EFI_ENTRY("%p, %d, %"PRIx64, event, type, trigger_time);
227
228 if (trigger32 < trigger_time) {
229 printf("WARNING: Truncating timer from %"PRIx64" to %x\n",
230 trigger_time, trigger32);
231 }
232
233 if (event != &efi_event) {
234 /* We only support one event at a time */
235 return EFI_EXIT(EFI_INVALID_PARAMETER);
236 }
237
238 switch (type) {
239 case EFI_TIMER_STOP:
240 efi_event.trigger_next = -1ULL;
241 break;
242 case EFI_TIMER_PERIODIC:
243 case EFI_TIMER_RELATIVE:
244 efi_event.trigger_next = timer_get_us() + (trigger32 / 10);
245 break;
246 default:
247 return EFI_EXIT(EFI_INVALID_PARAMETER);
248 }
249 efi_event.trigger_type = type;
250 efi_event.trigger_time = trigger_time;
251
252 return EFI_EXIT(EFI_SUCCESS);
253}
254
255static efi_status_t EFIAPI efi_wait_for_event(unsigned long num_events,
256 void *event, unsigned long *index)
257{
258 u64 now;
259
260 EFI_ENTRY("%ld, %p, %p", num_events, event, index);
261
262 now = timer_get_us();
263 while (now < efi_event.trigger_next) { }
264 efi_timer_check();
265
266 return EFI_EXIT(EFI_SUCCESS);
267}
268
269static efi_status_t EFIAPI efi_signal_event(void *event)
270{
271 EFI_ENTRY("%p", event);
272 return EFI_EXIT(EFI_SUCCESS);
273}
274
275static efi_status_t EFIAPI efi_close_event(void *event)
276{
277 EFI_ENTRY("%p", event);
278 efi_event.trigger_next = -1ULL;
279 return EFI_EXIT(EFI_SUCCESS);
280}
281
282static efi_status_t EFIAPI efi_check_event(void *event)
283{
284 EFI_ENTRY("%p", event);
285 return EFI_EXIT(EFI_NOT_READY);
286}
287
288static efi_status_t EFIAPI efi_install_protocol_interface(void **handle,
289 efi_guid_t *protocol, int protocol_interface_type,
290 void *protocol_interface)
291{
292 EFI_ENTRY("%p, %p, %d, %p", handle, protocol, protocol_interface_type,
293 protocol_interface);
294 return EFI_EXIT(EFI_OUT_OF_RESOURCES);
295}
296static efi_status_t EFIAPI efi_reinstall_protocol_interface(void *handle,
297 efi_guid_t *protocol, void *old_interface,
298 void *new_interface)
299{
300 EFI_ENTRY("%p, %p, %p, %p", handle, protocol, old_interface,
301 new_interface);
302 return EFI_EXIT(EFI_ACCESS_DENIED);
303}
304
305static efi_status_t EFIAPI efi_uninstall_protocol_interface(void *handle,
306 efi_guid_t *protocol, void *protocol_interface)
307{
308 EFI_ENTRY("%p, %p, %p", handle, protocol, protocol_interface);
309 return EFI_EXIT(EFI_NOT_FOUND);
310}
311
312static efi_status_t EFIAPI efi_register_protocol_notify(efi_guid_t *protocol,
313 void *event,
314 void **registration)
315{
316 EFI_ENTRY("%p, %p, %p", protocol, event, registration);
317 return EFI_EXIT(EFI_OUT_OF_RESOURCES);
318}
319
320static int efi_search(enum efi_locate_search_type search_type,
321 efi_guid_t *protocol, void *search_key,
322 struct efi_object *efiobj)
323{
324 int i;
325
326 switch (search_type) {
327 case all_handles:
328 return 0;
329 case by_register_notify:
330 return -1;
331 case by_protocol:
332 for (i = 0; i < ARRAY_SIZE(efiobj->protocols); i++) {
333 const efi_guid_t *guid = efiobj->protocols[i].guid;
334 if (guid && !guidcmp(guid, protocol))
335 return 0;
336 }
337 return -1;
338 }
339
340 return -1;
341}
342
343static efi_status_t EFIAPI efi_locate_handle(
344 enum efi_locate_search_type search_type,
345 efi_guid_t *protocol, void *search_key,
346 unsigned long *buffer_size, efi_handle_t *buffer)
347{
348 struct list_head *lhandle;
349 unsigned long size = 0;
350
351 EFI_ENTRY("%d, %p, %p, %p, %p", search_type, protocol, search_key,
352 buffer_size, buffer);
353
354 /* Count how much space we need */
355 list_for_each(lhandle, &efi_obj_list) {
356 struct efi_object *efiobj;
357 efiobj = list_entry(lhandle, struct efi_object, link);
358 if (!efi_search(search_type, protocol, search_key, efiobj)) {
359 size += sizeof(void*);
360 }
361 }
362
363 if (*buffer_size < size) {
364 *buffer_size = size;
365 return EFI_EXIT(EFI_BUFFER_TOO_SMALL);
366 }
367
368 /* Then fill the array */
369 list_for_each(lhandle, &efi_obj_list) {
370 struct efi_object *efiobj;
371 efiobj = list_entry(lhandle, struct efi_object, link);
372 if (!efi_search(search_type, protocol, search_key, efiobj)) {
373 *(buffer++) = efiobj->handle;
374 }
375 }
376
377 *buffer_size = size;
378 return EFI_EXIT(EFI_SUCCESS);
379}
380
381static efi_status_t EFIAPI efi_locate_device_path(efi_guid_t *protocol,
382 struct efi_device_path **device_path,
383 efi_handle_t *device)
384{
385 EFI_ENTRY("%p, %p, %p", protocol, device_path, device);
386 return EFI_EXIT(EFI_NOT_FOUND);
387}
388
Alexander Graf488bf122016-08-19 01:23:24 +0200389efi_status_t efi_install_configuration_table(const efi_guid_t *guid, void *table)
Alexander Grafbee91162016-03-04 01:09:59 +0100390{
391 int i;
392
Alexander Grafbee91162016-03-04 01:09:59 +0100393 /* Check for guid override */
394 for (i = 0; i < systab.nr_tables; i++) {
395 if (!guidcmp(guid, &efi_conf_table[i].guid)) {
396 efi_conf_table[i].table = table;
Alexander Graf488bf122016-08-19 01:23:24 +0200397 return EFI_SUCCESS;
Alexander Grafbee91162016-03-04 01:09:59 +0100398 }
399 }
400
401 /* No override, check for overflow */
402 if (i >= ARRAY_SIZE(efi_conf_table))
Alexander Graf488bf122016-08-19 01:23:24 +0200403 return EFI_OUT_OF_RESOURCES;
Alexander Grafbee91162016-03-04 01:09:59 +0100404
405 /* Add a new entry */
406 memcpy(&efi_conf_table[i].guid, guid, sizeof(*guid));
407 efi_conf_table[i].table = table;
Alexander Grafaba5e912016-08-19 01:23:30 +0200408 systab.nr_tables = i + 1;
Alexander Grafbee91162016-03-04 01:09:59 +0100409
Alexander Graf488bf122016-08-19 01:23:24 +0200410 return EFI_SUCCESS;
411}
412
413static efi_status_t EFIAPI efi_install_configuration_table_ext(efi_guid_t *guid,
414 void *table)
415{
416 EFI_ENTRY("%p, %p", guid, table);
417 return EFI_EXIT(efi_install_configuration_table(guid, table));
Alexander Grafbee91162016-03-04 01:09:59 +0100418}
419
420static efi_status_t EFIAPI efi_load_image(bool boot_policy,
421 efi_handle_t parent_image,
422 struct efi_device_path *file_path,
423 void *source_buffer,
424 unsigned long source_size,
425 efi_handle_t *image_handle)
426{
427 static struct efi_object loaded_image_info_obj = {
428 .protocols = {
429 {
430 .guid = &efi_guid_loaded_image,
431 .open = &efi_return_handle,
432 },
433 },
434 };
435 struct efi_loaded_image *info;
436 struct efi_object *obj;
437
438 EFI_ENTRY("%d, %p, %p, %p, %ld, %p", boot_policy, parent_image,
439 file_path, source_buffer, source_size, image_handle);
440 info = malloc(sizeof(*info));
441 obj = malloc(sizeof(loaded_image_info_obj));
442 memset(info, 0, sizeof(*info));
443 memcpy(obj, &loaded_image_info_obj, sizeof(loaded_image_info_obj));
444 obj->handle = info;
445 info->file_path = file_path;
446 info->reserved = efi_load_pe(source_buffer, info);
447 if (!info->reserved) {
448 free(info);
449 free(obj);
450 return EFI_EXIT(EFI_UNSUPPORTED);
451 }
452
453 *image_handle = info;
454 list_add_tail(&obj->link, &efi_obj_list);
455
456 return EFI_EXIT(EFI_SUCCESS);
457}
458
459static efi_status_t EFIAPI efi_start_image(efi_handle_t image_handle,
460 unsigned long *exit_data_size,
461 s16 **exit_data)
462{
463 ulong (*entry)(void *image_handle, struct efi_system_table *st);
464 struct efi_loaded_image *info = image_handle;
465
466 EFI_ENTRY("%p, %p, %p", image_handle, exit_data_size, exit_data);
467 entry = info->reserved;
468
469 efi_is_direct_boot = false;
470
471 /* call the image! */
Alexander Grafa86aeaf2016-05-20 23:28:23 +0200472 if (setjmp(&info->exit_jmp)) {
473 /* We returned from the child image */
474 return EFI_EXIT(info->exit_status);
475 }
476
Alexander Grafbee91162016-03-04 01:09:59 +0100477 entry(image_handle, &systab);
478
479 /* Should usually never get here */
480 return EFI_EXIT(EFI_SUCCESS);
481}
482
Alexander Grafa86aeaf2016-05-20 23:28:23 +0200483static efi_status_t EFIAPI efi_exit(efi_handle_t image_handle,
484 efi_status_t exit_status, unsigned long exit_data_size,
485 int16_t *exit_data)
Alexander Grafbee91162016-03-04 01:09:59 +0100486{
Alexander Grafa86aeaf2016-05-20 23:28:23 +0200487 struct efi_loaded_image *loaded_image_info = (void*)image_handle;
488
Alexander Grafbee91162016-03-04 01:09:59 +0100489 EFI_ENTRY("%p, %ld, %ld, %p", image_handle, exit_status,
490 exit_data_size, exit_data);
Alexander Grafa86aeaf2016-05-20 23:28:23 +0200491
492 loaded_image_info->exit_status = exit_status;
Alexander Graf692fcdd2016-09-27 09:30:32 +0200493 longjmp(&loaded_image_info->exit_jmp, 1);
Alexander Grafa86aeaf2016-05-20 23:28:23 +0200494
495 panic("EFI application exited");
Alexander Grafbee91162016-03-04 01:09:59 +0100496}
497
498static struct efi_object *efi_search_obj(void *handle)
499{
500 struct list_head *lhandle;
501
502 list_for_each(lhandle, &efi_obj_list) {
503 struct efi_object *efiobj;
504 efiobj = list_entry(lhandle, struct efi_object, link);
505 if (efiobj->handle == handle)
506 return efiobj;
507 }
508
509 return NULL;
510}
511
512static efi_status_t EFIAPI efi_unload_image(void *image_handle)
513{
514 struct efi_object *efiobj;
515
516 EFI_ENTRY("%p", image_handle);
517 efiobj = efi_search_obj(image_handle);
518 if (efiobj)
519 list_del(&efiobj->link);
520
521 return EFI_EXIT(EFI_SUCCESS);
522}
523
524static void efi_exit_caches(void)
525{
526#if defined(CONFIG_ARM) && !defined(CONFIG_ARM64)
527 /*
528 * Grub on 32bit ARM needs to have caches disabled before jumping into
529 * a zImage, but does not know of all cache layers. Give it a hand.
530 */
531 if (efi_is_direct_boot)
532 cleanup_before_linux();
533#endif
534}
535
536static efi_status_t EFIAPI efi_exit_boot_services(void *image_handle,
537 unsigned long map_key)
538{
539 EFI_ENTRY("%p, %ld", image_handle, map_key);
540
Alexander Grafb7b84102016-11-17 01:02:57 +0100541 board_quiesce_devices();
542
Alexander Grafbee91162016-03-04 01:09:59 +0100543 /* Fix up caches for EFI payloads if necessary */
544 efi_exit_caches();
545
546 /* This stops all lingering devices */
547 bootm_disable_interrupts();
548
549 /* Give the payload some time to boot */
550 WATCHDOG_RESET();
551
552 return EFI_EXIT(EFI_SUCCESS);
553}
554
555static efi_status_t EFIAPI efi_get_next_monotonic_count(uint64_t *count)
556{
557 static uint64_t mono = 0;
558 EFI_ENTRY("%p", count);
559 *count = mono++;
560 return EFI_EXIT(EFI_SUCCESS);
561}
562
563static efi_status_t EFIAPI efi_stall(unsigned long microseconds)
564{
565 EFI_ENTRY("%ld", microseconds);
566 udelay(microseconds);
567 return EFI_EXIT(EFI_SUCCESS);
568}
569
570static efi_status_t EFIAPI efi_set_watchdog_timer(unsigned long timeout,
571 uint64_t watchdog_code,
572 unsigned long data_size,
573 uint16_t *watchdog_data)
574{
575 EFI_ENTRY("%ld, 0x%"PRIx64", %ld, %p", timeout, watchdog_code,
576 data_size, watchdog_data);
577 return EFI_EXIT(efi_unsupported(__func__));
578}
579
580static efi_status_t EFIAPI efi_connect_controller(
581 efi_handle_t controller_handle,
582 efi_handle_t *driver_image_handle,
583 struct efi_device_path *remain_device_path,
584 bool recursive)
585{
586 EFI_ENTRY("%p, %p, %p, %d", controller_handle, driver_image_handle,
587 remain_device_path, recursive);
588 return EFI_EXIT(EFI_NOT_FOUND);
589}
590
591static efi_status_t EFIAPI efi_disconnect_controller(void *controller_handle,
592 void *driver_image_handle,
593 void *child_handle)
594{
595 EFI_ENTRY("%p, %p, %p", controller_handle, driver_image_handle,
596 child_handle);
597 return EFI_EXIT(EFI_INVALID_PARAMETER);
598}
599
600static efi_status_t EFIAPI efi_close_protocol(void *handle,
601 efi_guid_t *protocol,
602 void *agent_handle,
603 void *controller_handle)
604{
605 EFI_ENTRY("%p, %p, %p, %p", handle, protocol, agent_handle,
606 controller_handle);
607 return EFI_EXIT(EFI_NOT_FOUND);
608}
609
610static efi_status_t EFIAPI efi_open_protocol_information(efi_handle_t handle,
611 efi_guid_t *protocol,
612 struct efi_open_protocol_info_entry **entry_buffer,
613 unsigned long *entry_count)
614{
615 EFI_ENTRY("%p, %p, %p, %p", handle, protocol, entry_buffer,
616 entry_count);
617 return EFI_EXIT(EFI_NOT_FOUND);
618}
619
620static efi_status_t EFIAPI efi_protocols_per_handle(void *handle,
621 efi_guid_t ***protocol_buffer,
622 unsigned long *protocol_buffer_count)
623{
624 EFI_ENTRY("%p, %p, %p", handle, protocol_buffer,
625 protocol_buffer_count);
626 return EFI_EXIT(EFI_OUT_OF_RESOURCES);
627}
628
629static efi_status_t EFIAPI efi_locate_handle_buffer(
630 enum efi_locate_search_type search_type,
631 efi_guid_t *protocol, void *search_key,
632 unsigned long *no_handles, efi_handle_t **buffer)
633{
634 EFI_ENTRY("%d, %p, %p, %p, %p", search_type, protocol, search_key,
635 no_handles, buffer);
636 return EFI_EXIT(EFI_NOT_FOUND);
637}
638
639static struct efi_class_map efi_class_maps[] = {
640 {
641 .guid = &efi_guid_console_control,
642 .interface = &efi_console_control
643 },
644};
645
646static efi_status_t EFIAPI efi_locate_protocol(efi_guid_t *protocol,
647 void *registration,
648 void **protocol_interface)
649{
650 int i;
651
652 EFI_ENTRY("%p, %p, %p", protocol, registration, protocol_interface);
653 for (i = 0; i < ARRAY_SIZE(efi_class_maps); i++) {
654 struct efi_class_map *curmap = &efi_class_maps[i];
655 if (!guidcmp(protocol, curmap->guid)) {
656 *protocol_interface = (void*)curmap->interface;
657 return EFI_EXIT(EFI_SUCCESS);
658 }
659 }
660
661 return EFI_EXIT(EFI_NOT_FOUND);
662}
663
664static efi_status_t EFIAPI efi_install_multiple_protocol_interfaces(
665 void **handle, ...)
666{
667 EFI_ENTRY("%p", handle);
668 return EFI_EXIT(EFI_OUT_OF_RESOURCES);
669}
670
671static efi_status_t EFIAPI efi_uninstall_multiple_protocol_interfaces(
672 void *handle, ...)
673{
674 EFI_ENTRY("%p", handle);
675 return EFI_EXIT(EFI_INVALID_PARAMETER);
676}
677
678static efi_status_t EFIAPI efi_calculate_crc32(void *data,
679 unsigned long data_size,
680 uint32_t *crc32_p)
681{
682 EFI_ENTRY("%p, %ld", data, data_size);
683 *crc32_p = crc32(0, data, data_size);
684 return EFI_EXIT(EFI_SUCCESS);
685}
686
687static void EFIAPI efi_copy_mem(void *destination, void *source,
688 unsigned long length)
689{
690 EFI_ENTRY("%p, %p, %ld", destination, source, length);
691 memcpy(destination, source, length);
692}
693
694static void EFIAPI efi_set_mem(void *buffer, unsigned long size, uint8_t value)
695{
696 EFI_ENTRY("%p, %ld, 0x%x", buffer, size, value);
697 memset(buffer, value, size);
698}
699
700static efi_status_t EFIAPI efi_open_protocol(
701 void *handle, efi_guid_t *protocol,
702 void **protocol_interface, void *agent_handle,
703 void *controller_handle, uint32_t attributes)
704{
705 struct list_head *lhandle;
706 int i;
707 efi_status_t r = EFI_UNSUPPORTED;
708
709 EFI_ENTRY("%p, %p, %p, %p, %p, 0x%x", handle, protocol,
710 protocol_interface, agent_handle, controller_handle,
711 attributes);
712 list_for_each(lhandle, &efi_obj_list) {
713 struct efi_object *efiobj;
714 efiobj = list_entry(lhandle, struct efi_object, link);
715
716 if (efiobj->handle != handle)
717 continue;
718
719 for (i = 0; i < ARRAY_SIZE(efiobj->protocols); i++) {
720 struct efi_handler *handler = &efiobj->protocols[i];
721 const efi_guid_t *hprotocol = handler->guid;
722 if (!hprotocol)
723 break;
724 if (!guidcmp(hprotocol, protocol)) {
725 r = handler->open(handle, protocol,
726 protocol_interface, agent_handle,
727 controller_handle, attributes);
728 goto out;
729 }
730 }
731 }
732
733out:
734 return EFI_EXIT(r);
735}
736
737static efi_status_t EFIAPI efi_handle_protocol(void *handle,
738 efi_guid_t *protocol,
739 void **protocol_interface)
740{
Alexander Grafbee91162016-03-04 01:09:59 +0100741 return efi_open_protocol(handle, protocol, protocol_interface,
742 NULL, NULL, 0);
743}
744
745static const struct efi_boot_services efi_boot_services = {
746 .hdr = {
747 .headersize = sizeof(struct efi_table_hdr),
748 },
749 .raise_tpl = efi_raise_tpl,
750 .restore_tpl = efi_restore_tpl,
751 .allocate_pages = efi_allocate_pages_ext,
752 .free_pages = efi_free_pages_ext,
753 .get_memory_map = efi_get_memory_map_ext,
Stefan Brünsead12742016-10-09 22:17:18 +0200754 .allocate_pool = efi_allocate_pool_ext,
Stefan Brüns42417bc2016-10-09 22:17:26 +0200755 .free_pool = efi_free_pool_ext,
Alexander Grafbee91162016-03-04 01:09:59 +0100756 .create_event = efi_create_event,
757 .set_timer = efi_set_timer,
758 .wait_for_event = efi_wait_for_event,
759 .signal_event = efi_signal_event,
760 .close_event = efi_close_event,
761 .check_event = efi_check_event,
762 .install_protocol_interface = efi_install_protocol_interface,
763 .reinstall_protocol_interface = efi_reinstall_protocol_interface,
764 .uninstall_protocol_interface = efi_uninstall_protocol_interface,
765 .handle_protocol = efi_handle_protocol,
766 .reserved = NULL,
767 .register_protocol_notify = efi_register_protocol_notify,
768 .locate_handle = efi_locate_handle,
769 .locate_device_path = efi_locate_device_path,
Alexander Graf488bf122016-08-19 01:23:24 +0200770 .install_configuration_table = efi_install_configuration_table_ext,
Alexander Grafbee91162016-03-04 01:09:59 +0100771 .load_image = efi_load_image,
772 .start_image = efi_start_image,
Alexander Grafa86aeaf2016-05-20 23:28:23 +0200773 .exit = efi_exit,
Alexander Grafbee91162016-03-04 01:09:59 +0100774 .unload_image = efi_unload_image,
775 .exit_boot_services = efi_exit_boot_services,
776 .get_next_monotonic_count = efi_get_next_monotonic_count,
777 .stall = efi_stall,
778 .set_watchdog_timer = efi_set_watchdog_timer,
779 .connect_controller = efi_connect_controller,
780 .disconnect_controller = efi_disconnect_controller,
781 .open_protocol = efi_open_protocol,
782 .close_protocol = efi_close_protocol,
783 .open_protocol_information = efi_open_protocol_information,
784 .protocols_per_handle = efi_protocols_per_handle,
785 .locate_handle_buffer = efi_locate_handle_buffer,
786 .locate_protocol = efi_locate_protocol,
787 .install_multiple_protocol_interfaces = efi_install_multiple_protocol_interfaces,
788 .uninstall_multiple_protocol_interfaces = efi_uninstall_multiple_protocol_interfaces,
789 .calculate_crc32 = efi_calculate_crc32,
790 .copy_mem = efi_copy_mem,
791 .set_mem = efi_set_mem,
792};
793
794
Alexander Graf3c63db92016-10-14 13:45:30 +0200795static uint16_t __efi_runtime_data firmware_vendor[] =
Alexander Grafbee91162016-03-04 01:09:59 +0100796 { 'D','a','s',' ','U','-','b','o','o','t',0 };
797
Alexander Graf3c63db92016-10-14 13:45:30 +0200798struct efi_system_table __efi_runtime_data systab = {
Alexander Grafbee91162016-03-04 01:09:59 +0100799 .hdr = {
800 .signature = EFI_SYSTEM_TABLE_SIGNATURE,
801 .revision = 0x20005, /* 2.5 */
802 .headersize = sizeof(struct efi_table_hdr),
803 },
804 .fw_vendor = (long)firmware_vendor,
805 .con_in = (void*)&efi_con_in,
806 .con_out = (void*)&efi_con_out,
807 .std_err = (void*)&efi_con_out,
808 .runtime = (void*)&efi_runtime_services,
809 .boottime = (void*)&efi_boot_services,
810 .nr_tables = 0,
811 .tables = (void*)efi_conf_table,
812};