1 // SPDX-License-Identifier: GPL-2.0+
3 * EFI application boot time services
5 * Copyright (c) 2016 Alexander Graf
10 #include <efi_loader.h>
11 #include <environment.h>
13 #include <linux/libfdt_env.h>
14 #include <u-boot/crc.h>
19 DECLARE_GLOBAL_DATA_PTR
;
21 /* Task priority level */
22 static efi_uintn_t efi_tpl
= TPL_APPLICATION
;
24 /* This list contains all the EFI objects our payload has access to */
25 LIST_HEAD(efi_obj_list
);
27 /* List of all events */
28 LIST_HEAD(efi_events
);
30 /* List of all events registered by RegisterProtocolNotify() */
31 LIST_HEAD(efi_register_notify_events
);
33 /* Handle of the currently executing image */
34 static efi_handle_t current_image
;
37 * If we're running on nasty systems (32bit ARM booting into non-EFI Linux)
38 * we need to do trickery with caches. Since we don't want to break the EFI
39 * aware boot path, only apply hacks when loading exiting directly (breaking
40 * direct Linux EFI booting along the way - oh well).
42 static bool efi_is_direct_boot
= true;
46 * The "gd" pointer lives in a register on ARM and AArch64 that we declare
47 * fixed when compiling U-Boot. However, the payload does not know about that
48 * restriction so we need to manually swap its and our view of that register on
49 * EFI callback entry/exit.
51 static volatile void *efi_gd
, *app_gd
;
54 /* 1 if inside U-Boot code, 0 if inside EFI payload code */
55 static int entry_count
= 1;
56 static int nesting_level
;
57 /* GUID of the device tree table */
58 const efi_guid_t efi_guid_fdt
= EFI_FDT_GUID
;
59 /* GUID of the EFI_DRIVER_BINDING_PROTOCOL */
60 const efi_guid_t efi_guid_driver_binding_protocol
=
61 EFI_DRIVER_BINDING_PROTOCOL_GUID
;
63 /* event group ExitBootServices() invoked */
64 const efi_guid_t efi_guid_event_group_exit_boot_services
=
65 EFI_EVENT_GROUP_EXIT_BOOT_SERVICES
;
66 /* event group SetVirtualAddressMap() invoked */
67 const efi_guid_t efi_guid_event_group_virtual_address_change
=
68 EFI_EVENT_GROUP_VIRTUAL_ADDRESS_CHANGE
;
69 /* event group memory map changed */
70 const efi_guid_t efi_guid_event_group_memory_map_change
=
71 EFI_EVENT_GROUP_MEMORY_MAP_CHANGE
;
72 /* event group boot manager about to boot */
73 const efi_guid_t efi_guid_event_group_ready_to_boot
=
74 EFI_EVENT_GROUP_READY_TO_BOOT
;
75 /* event group ResetSystem() invoked (before ExitBootServices) */
76 const efi_guid_t efi_guid_event_group_reset_system
=
77 EFI_EVENT_GROUP_RESET_SYSTEM
;
79 static efi_status_t EFIAPI
efi_disconnect_controller(
80 efi_handle_t controller_handle
,
81 efi_handle_t driver_image_handle
,
82 efi_handle_t child_handle
);
84 /* Called on every callback entry */
85 int __efi_entry_check(void)
87 int ret
= entry_count
++ == 0;
96 /* Called on every callback exit */
97 int __efi_exit_check(void)
99 int ret
= --entry_count
== 0;
106 /* Called from do_bootefi_exec() */
107 void efi_save_gd(void)
115 * Special case handler for error/abort that just forces things back to u-boot
116 * world so we can dump out an abort message, without any care about returning
117 * back to UEFI world.
119 void efi_restore_gd(void)
122 /* Only restore if we're already in EFI context */
130 * indent_string() - returns a string for indenting with two spaces per level
131 * @level: indent level
133 * A maximum of ten indent levels is supported. Higher indent levels will be
136 * Return: A string for indenting with two spaces per level is
139 static const char *indent_string(int level
)
141 const char *indent
= " ";
142 const int max
= strlen(indent
);
144 level
= min(max
, level
* 2);
145 return &indent
[max
- level
];
148 const char *__efi_nesting(void)
150 return indent_string(nesting_level
);
153 const char *__efi_nesting_inc(void)
155 return indent_string(nesting_level
++);
158 const char *__efi_nesting_dec(void)
160 return indent_string(--nesting_level
);
164 * efi_queue_event() - queue an EFI event
165 * @event: event to signal
166 * @check_tpl: check the TPL level
168 * This function queues the notification function of the event for future
171 * The notification function is called if the task priority level of the event
172 * is higher than the current task priority level.
174 * For the SignalEvent service see efi_signal_event_ext.
177 static void efi_queue_event(struct efi_event
*event
, bool check_tpl
)
179 if (event
->notify_function
) {
180 event
->is_queued
= true;
182 if (check_tpl
&& efi_tpl
>= event
->notify_tpl
)
184 EFI_CALL_VOID(event
->notify_function(event
,
185 event
->notify_context
));
187 event
->is_queued
= false;
191 * is_valid_tpl() - check if the task priority level is valid
193 * @tpl: TPL level to check
194 * Return: status code
196 efi_status_t
is_valid_tpl(efi_uintn_t tpl
)
199 case TPL_APPLICATION
:
205 return EFI_INVALID_PARAMETER
;
210 * efi_signal_event() - signal an EFI event
211 * @event: event to signal
212 * @check_tpl: check the TPL level
214 * This function signals an event. If the event belongs to an event group all
215 * events of the group are signaled. If they are of type EVT_NOTIFY_SIGNAL
216 * their notification function is queued.
218 * For the SignalEvent service see efi_signal_event_ext.
220 void efi_signal_event(struct efi_event
*event
, bool check_tpl
)
223 struct efi_event
*evt
;
226 * The signaled state has to set before executing any
227 * notification function
229 list_for_each_entry(evt
, &efi_events
, link
) {
230 if (!evt
->group
|| guidcmp(evt
->group
, event
->group
))
232 if (evt
->is_signaled
)
234 evt
->is_signaled
= true;
235 if (evt
->type
& EVT_NOTIFY_SIGNAL
&&
236 evt
->notify_function
)
237 evt
->is_queued
= true;
239 list_for_each_entry(evt
, &efi_events
, link
) {
240 if (!evt
->group
|| guidcmp(evt
->group
, event
->group
))
243 efi_queue_event(evt
, check_tpl
);
246 event
->is_signaled
= true;
247 if (event
->type
& EVT_NOTIFY_SIGNAL
)
248 efi_queue_event(event
, check_tpl
);
253 * efi_raise_tpl() - raise the task priority level
254 * @new_tpl: new value of the task priority level
256 * This function implements the RaiseTpl service.
258 * See the Unified Extensible Firmware Interface (UEFI) specification for
261 * Return: old value of the task priority level
263 static unsigned long EFIAPI
efi_raise_tpl(efi_uintn_t new_tpl
)
265 efi_uintn_t old_tpl
= efi_tpl
;
267 EFI_ENTRY("0x%zx", new_tpl
);
269 if (new_tpl
< efi_tpl
)
270 EFI_PRINT("WARNING: new_tpl < current_tpl in %s\n", __func__
);
272 if (efi_tpl
> TPL_HIGH_LEVEL
)
273 efi_tpl
= TPL_HIGH_LEVEL
;
275 EFI_EXIT(EFI_SUCCESS
);
280 * efi_restore_tpl() - lower the task priority level
281 * @old_tpl: value of the task priority level to be restored
283 * This function implements the RestoreTpl service.
285 * See the Unified Extensible Firmware Interface (UEFI) specification for
288 static void EFIAPI
efi_restore_tpl(efi_uintn_t old_tpl
)
290 EFI_ENTRY("0x%zx", old_tpl
);
292 if (old_tpl
> efi_tpl
)
293 EFI_PRINT("WARNING: old_tpl > current_tpl in %s\n", __func__
);
295 if (efi_tpl
> TPL_HIGH_LEVEL
)
296 efi_tpl
= TPL_HIGH_LEVEL
;
299 * Lowering the TPL may have made queued events eligible for execution.
303 EFI_EXIT(EFI_SUCCESS
);
307 * efi_allocate_pages_ext() - allocate memory pages
308 * @type: type of allocation to be performed
309 * @memory_type: usage type of the allocated memory
310 * @pages: number of pages to be allocated
311 * @memory: allocated memory
313 * This function implements the AllocatePages service.
315 * See the Unified Extensible Firmware Interface (UEFI) specification for
318 * Return: status code
320 static efi_status_t EFIAPI
efi_allocate_pages_ext(int type
, int memory_type
,
326 EFI_ENTRY("%d, %d, 0x%zx, %p", type
, memory_type
, pages
, memory
);
327 r
= efi_allocate_pages(type
, memory_type
, pages
, memory
);
332 * efi_free_pages_ext() - Free memory pages.
333 * @memory: start of the memory area to be freed
334 * @pages: number of pages to be freed
336 * This function implements the FreePages service.
338 * See the Unified Extensible Firmware Interface (UEFI) specification for
341 * Return: status code
343 static efi_status_t EFIAPI
efi_free_pages_ext(uint64_t memory
,
348 EFI_ENTRY("%llx, 0x%zx", memory
, pages
);
349 r
= efi_free_pages(memory
, pages
);
354 * efi_get_memory_map_ext() - get map describing memory usage
355 * @memory_map_size: on entry the size, in bytes, of the memory map buffer,
356 * on exit the size of the copied memory map
357 * @memory_map: buffer to which the memory map is written
358 * @map_key: key for the memory map
359 * @descriptor_size: size of an individual memory descriptor
360 * @descriptor_version: version number of the memory descriptor structure
362 * This function implements the GetMemoryMap service.
364 * See the Unified Extensible Firmware Interface (UEFI) specification for
367 * Return: status code
369 static efi_status_t EFIAPI
efi_get_memory_map_ext(
370 efi_uintn_t
*memory_map_size
,
371 struct efi_mem_desc
*memory_map
,
372 efi_uintn_t
*map_key
,
373 efi_uintn_t
*descriptor_size
,
374 uint32_t *descriptor_version
)
378 EFI_ENTRY("%p, %p, %p, %p, %p", memory_map_size
, memory_map
,
379 map_key
, descriptor_size
, descriptor_version
);
380 r
= efi_get_memory_map(memory_map_size
, memory_map
, map_key
,
381 descriptor_size
, descriptor_version
);
386 * efi_allocate_pool_ext() - allocate memory from pool
387 * @pool_type: type of the pool from which memory is to be allocated
388 * @size: number of bytes to be allocated
389 * @buffer: allocated memory
391 * This function implements the AllocatePool service.
393 * See the Unified Extensible Firmware Interface (UEFI) specification for
396 * Return: status code
398 static efi_status_t EFIAPI
efi_allocate_pool_ext(int pool_type
,
404 EFI_ENTRY("%d, %zd, %p", pool_type
, size
, buffer
);
405 r
= efi_allocate_pool(pool_type
, size
, buffer
);
410 * efi_free_pool_ext() - free memory from pool
411 * @buffer: start of memory to be freed
413 * This function implements the FreePool service.
415 * See the Unified Extensible Firmware Interface (UEFI) specification for
418 * Return: status code
420 static efi_status_t EFIAPI
efi_free_pool_ext(void *buffer
)
424 EFI_ENTRY("%p", buffer
);
425 r
= efi_free_pool(buffer
);
430 * efi_add_handle() - add a new handle to the object list
432 * @handle: handle to be added
434 * The protocols list is initialized. The handle is added to the list of known
437 void efi_add_handle(efi_handle_t handle
)
441 INIT_LIST_HEAD(&handle
->protocols
);
442 list_add_tail(&handle
->link
, &efi_obj_list
);
446 * efi_create_handle() - create handle
447 * @handle: new handle
449 * Return: status code
451 efi_status_t
efi_create_handle(efi_handle_t
*handle
)
453 struct efi_object
*obj
;
455 obj
= calloc(1, sizeof(struct efi_object
));
457 return EFI_OUT_OF_RESOURCES
;
466 * efi_search_protocol() - find a protocol on a handle.
468 * @protocol_guid: GUID of the protocol
469 * @handler: reference to the protocol
471 * Return: status code
473 efi_status_t
efi_search_protocol(const efi_handle_t handle
,
474 const efi_guid_t
*protocol_guid
,
475 struct efi_handler
**handler
)
477 struct efi_object
*efiobj
;
478 struct list_head
*lhandle
;
480 if (!handle
|| !protocol_guid
)
481 return EFI_INVALID_PARAMETER
;
482 efiobj
= efi_search_obj(handle
);
484 return EFI_INVALID_PARAMETER
;
485 list_for_each(lhandle
, &efiobj
->protocols
) {
486 struct efi_handler
*protocol
;
488 protocol
= list_entry(lhandle
, struct efi_handler
, link
);
489 if (!guidcmp(protocol
->guid
, protocol_guid
)) {
495 return EFI_NOT_FOUND
;
499 * efi_remove_protocol() - delete protocol from a handle
500 * @handle: handle from which the protocol shall be deleted
501 * @protocol: GUID of the protocol to be deleted
502 * @protocol_interface: interface of the protocol implementation
504 * Return: status code
506 efi_status_t
efi_remove_protocol(const efi_handle_t handle
,
507 const efi_guid_t
*protocol
,
508 void *protocol_interface
)
510 struct efi_handler
*handler
;
513 ret
= efi_search_protocol(handle
, protocol
, &handler
);
514 if (ret
!= EFI_SUCCESS
)
516 if (guidcmp(handler
->guid
, protocol
))
517 return EFI_INVALID_PARAMETER
;
518 if (handler
->protocol_interface
!= protocol_interface
)
519 return EFI_INVALID_PARAMETER
;
520 list_del(&handler
->link
);
526 * efi_remove_all_protocols() - delete all protocols from a handle
527 * @handle: handle from which the protocols shall be deleted
529 * Return: status code
531 efi_status_t
efi_remove_all_protocols(const efi_handle_t handle
)
533 struct efi_object
*efiobj
;
534 struct efi_handler
*protocol
;
535 struct efi_handler
*pos
;
537 efiobj
= efi_search_obj(handle
);
539 return EFI_INVALID_PARAMETER
;
540 list_for_each_entry_safe(protocol
, pos
, &efiobj
->protocols
, link
) {
543 ret
= efi_remove_protocol(handle
, protocol
->guid
,
544 protocol
->protocol_interface
);
545 if (ret
!= EFI_SUCCESS
)
552 * efi_delete_handle() - delete handle
554 * @obj: handle to delete
556 void efi_delete_handle(efi_handle_t handle
)
560 efi_remove_all_protocols(handle
);
561 list_del(&handle
->link
);
566 * efi_is_event() - check if a pointer is a valid event
567 * @event: pointer to check
569 * Return: status code
571 static efi_status_t
efi_is_event(const struct efi_event
*event
)
573 const struct efi_event
*evt
;
576 return EFI_INVALID_PARAMETER
;
577 list_for_each_entry(evt
, &efi_events
, link
) {
581 return EFI_INVALID_PARAMETER
;
585 * efi_create_event() - create an event
586 * @type: type of the event to create
587 * @notify_tpl: task priority level of the event
588 * @notify_function: notification function of the event
589 * @notify_context: pointer passed to the notification function
590 * @group: event group
591 * @event: created event
593 * This function is used inside U-Boot code to create an event.
595 * For the API function implementing the CreateEvent service see
596 * efi_create_event_ext.
598 * Return: status code
600 efi_status_t
efi_create_event(uint32_t type
, efi_uintn_t notify_tpl
,
601 void (EFIAPI
*notify_function
) (
602 struct efi_event
*event
,
604 void *notify_context
, efi_guid_t
*group
,
605 struct efi_event
**event
)
607 struct efi_event
*evt
;
610 return EFI_INVALID_PARAMETER
;
615 case EVT_NOTIFY_SIGNAL
:
616 case EVT_TIMER
| EVT_NOTIFY_SIGNAL
:
617 case EVT_NOTIFY_WAIT
:
618 case EVT_TIMER
| EVT_NOTIFY_WAIT
:
619 case EVT_SIGNAL_EXIT_BOOT_SERVICES
:
620 case EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE
:
623 return EFI_INVALID_PARAMETER
;
626 if ((type
& (EVT_NOTIFY_WAIT
| EVT_NOTIFY_SIGNAL
)) &&
627 (!notify_function
|| is_valid_tpl(notify_tpl
) != EFI_SUCCESS
))
628 return EFI_INVALID_PARAMETER
;
630 evt
= calloc(1, sizeof(struct efi_event
));
632 return EFI_OUT_OF_RESOURCES
;
634 evt
->notify_tpl
= notify_tpl
;
635 evt
->notify_function
= notify_function
;
636 evt
->notify_context
= notify_context
;
638 /* Disable timers on boot up */
639 evt
->trigger_next
= -1ULL;
640 evt
->is_queued
= false;
641 evt
->is_signaled
= false;
642 list_add_tail(&evt
->link
, &efi_events
);
648 * efi_create_event_ex() - create an event in a group
649 * @type: type of the event to create
650 * @notify_tpl: task priority level of the event
651 * @notify_function: notification function of the event
652 * @notify_context: pointer passed to the notification function
653 * @event: created event
654 * @event_group: event group
656 * This function implements the CreateEventEx service.
658 * See the Unified Extensible Firmware Interface (UEFI) specification for
661 * Return: status code
663 efi_status_t EFIAPI
efi_create_event_ex(uint32_t type
, efi_uintn_t notify_tpl
,
664 void (EFIAPI
*notify_function
) (
665 struct efi_event
*event
,
667 void *notify_context
,
668 efi_guid_t
*event_group
,
669 struct efi_event
**event
)
673 EFI_ENTRY("%d, 0x%zx, %p, %p, %pUl", type
, notify_tpl
, notify_function
,
674 notify_context
, event_group
);
677 * The allowable input parameters are the same as in CreateEvent()
678 * except for the following two disallowed event types.
681 case EVT_SIGNAL_EXIT_BOOT_SERVICES
:
682 case EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE
:
683 ret
= EFI_INVALID_PARAMETER
;
687 ret
= efi_create_event(type
, notify_tpl
, notify_function
,
688 notify_context
, event_group
, event
);
690 return EFI_EXIT(ret
);
694 * efi_create_event_ext() - create an event
695 * @type: type of the event to create
696 * @notify_tpl: task priority level of the event
697 * @notify_function: notification function of the event
698 * @notify_context: pointer passed to the notification function
699 * @event: created event
701 * This function implements the CreateEvent service.
703 * See the Unified Extensible Firmware Interface (UEFI) specification for
706 * Return: status code
708 static efi_status_t EFIAPI
efi_create_event_ext(
709 uint32_t type
, efi_uintn_t notify_tpl
,
710 void (EFIAPI
*notify_function
) (
711 struct efi_event
*event
,
713 void *notify_context
, struct efi_event
**event
)
715 EFI_ENTRY("%d, 0x%zx, %p, %p", type
, notify_tpl
, notify_function
,
717 return EFI_EXIT(efi_create_event(type
, notify_tpl
, notify_function
,
718 notify_context
, NULL
, event
));
722 * efi_timer_check() - check if a timer event has occurred
724 * Check if a timer event has occurred or a queued notification function should
727 * Our timers have to work without interrupts, so we check whenever keyboard
728 * input or disk accesses happen if enough time elapsed for them to fire.
730 void efi_timer_check(void)
732 struct efi_event
*evt
;
733 u64 now
= timer_get_us();
735 list_for_each_entry(evt
, &efi_events
, link
) {
737 efi_queue_event(evt
, true);
738 if (!(evt
->type
& EVT_TIMER
) || now
< evt
->trigger_next
)
740 switch (evt
->trigger_type
) {
741 case EFI_TIMER_RELATIVE
:
742 evt
->trigger_type
= EFI_TIMER_STOP
;
744 case EFI_TIMER_PERIODIC
:
745 evt
->trigger_next
+= evt
->trigger_time
;
750 evt
->is_signaled
= false;
751 efi_signal_event(evt
, true);
757 * efi_set_timer() - set the trigger time for a timer event or stop the event
758 * @event: event for which the timer is set
759 * @type: type of the timer
760 * @trigger_time: trigger period in multiples of 100 ns
762 * This is the function for internal usage in U-Boot. For the API function
763 * implementing the SetTimer service see efi_set_timer_ext.
765 * Return: status code
767 efi_status_t
efi_set_timer(struct efi_event
*event
, enum efi_timer_delay type
,
768 uint64_t trigger_time
)
770 /* Check that the event is valid */
771 if (efi_is_event(event
) != EFI_SUCCESS
|| !(event
->type
& EVT_TIMER
))
772 return EFI_INVALID_PARAMETER
;
775 * The parameter defines a multiple of 100 ns.
776 * We use multiples of 1000 ns. So divide by 10.
778 do_div(trigger_time
, 10);
782 event
->trigger_next
= -1ULL;
784 case EFI_TIMER_PERIODIC
:
785 case EFI_TIMER_RELATIVE
:
786 event
->trigger_next
= timer_get_us() + trigger_time
;
789 return EFI_INVALID_PARAMETER
;
791 event
->trigger_type
= type
;
792 event
->trigger_time
= trigger_time
;
793 event
->is_signaled
= false;
798 * efi_set_timer_ext() - Set the trigger time for a timer event or stop the
800 * @event: event for which the timer is set
801 * @type: type of the timer
802 * @trigger_time: trigger period in multiples of 100 ns
804 * This function implements the SetTimer service.
806 * See the Unified Extensible Firmware Interface (UEFI) specification for
810 * Return: status code
812 static efi_status_t EFIAPI
efi_set_timer_ext(struct efi_event
*event
,
813 enum efi_timer_delay type
,
814 uint64_t trigger_time
)
816 EFI_ENTRY("%p, %d, %llx", event
, type
, trigger_time
);
817 return EFI_EXIT(efi_set_timer(event
, type
, trigger_time
));
821 * efi_wait_for_event() - wait for events to be signaled
822 * @num_events: number of events to be waited for
823 * @event: events to be waited for
824 * @index: index of the event that was signaled
826 * This function implements the WaitForEvent service.
828 * See the Unified Extensible Firmware Interface (UEFI) specification for
831 * Return: status code
833 static efi_status_t EFIAPI
efi_wait_for_event(efi_uintn_t num_events
,
834 struct efi_event
**event
,
839 EFI_ENTRY("%zd, %p, %p", num_events
, event
, index
);
841 /* Check parameters */
842 if (!num_events
|| !event
)
843 return EFI_EXIT(EFI_INVALID_PARAMETER
);
845 if (efi_tpl
!= TPL_APPLICATION
)
846 return EFI_EXIT(EFI_UNSUPPORTED
);
847 for (i
= 0; i
< num_events
; ++i
) {
848 if (efi_is_event(event
[i
]) != EFI_SUCCESS
)
849 return EFI_EXIT(EFI_INVALID_PARAMETER
);
850 if (!event
[i
]->type
|| event
[i
]->type
& EVT_NOTIFY_SIGNAL
)
851 return EFI_EXIT(EFI_INVALID_PARAMETER
);
852 if (!event
[i
]->is_signaled
)
853 efi_queue_event(event
[i
], true);
856 /* Wait for signal */
858 for (i
= 0; i
< num_events
; ++i
) {
859 if (event
[i
]->is_signaled
)
862 /* Allow events to occur. */
868 * Reset the signal which is passed to the caller to allow periodic
871 event
[i
]->is_signaled
= false;
875 return EFI_EXIT(EFI_SUCCESS
);
879 * efi_signal_event_ext() - signal an EFI event
880 * @event: event to signal
882 * This function implements the SignalEvent service.
884 * See the Unified Extensible Firmware Interface (UEFI) specification for
887 * This functions sets the signaled state of the event and queues the
888 * notification function for execution.
890 * Return: status code
892 static efi_status_t EFIAPI
efi_signal_event_ext(struct efi_event
*event
)
894 EFI_ENTRY("%p", event
);
895 if (efi_is_event(event
) != EFI_SUCCESS
)
896 return EFI_EXIT(EFI_INVALID_PARAMETER
);
897 efi_signal_event(event
, true);
898 return EFI_EXIT(EFI_SUCCESS
);
902 * efi_close_event() - close an EFI event
903 * @event: event to close
905 * This function implements the CloseEvent service.
907 * See the Unified Extensible Firmware Interface (UEFI) specification for
910 * Return: status code
912 static efi_status_t EFIAPI
efi_close_event(struct efi_event
*event
)
914 struct efi_register_notify_event
*item
, *next
;
916 EFI_ENTRY("%p", event
);
917 if (efi_is_event(event
) != EFI_SUCCESS
)
918 return EFI_EXIT(EFI_INVALID_PARAMETER
);
920 /* Remove protocol notify registrations for the event */
921 list_for_each_entry_safe(item
, next
, &efi_register_notify_events
,
923 if (event
== item
->event
) {
924 list_del(&item
->link
);
929 list_del(&event
->link
);
931 return EFI_EXIT(EFI_SUCCESS
);
935 * efi_check_event() - check if an event is signaled
936 * @event: event to check
938 * This function implements the CheckEvent service.
940 * See the Unified Extensible Firmware Interface (UEFI) specification for
943 * If an event is not signaled yet, the notification function is queued. The
944 * signaled state is cleared.
946 * Return: status code
948 static efi_status_t EFIAPI
efi_check_event(struct efi_event
*event
)
950 EFI_ENTRY("%p", event
);
952 if (efi_is_event(event
) != EFI_SUCCESS
||
953 event
->type
& EVT_NOTIFY_SIGNAL
)
954 return EFI_EXIT(EFI_INVALID_PARAMETER
);
955 if (!event
->is_signaled
)
956 efi_queue_event(event
, true);
957 if (event
->is_signaled
) {
958 event
->is_signaled
= false;
959 return EFI_EXIT(EFI_SUCCESS
);
961 return EFI_EXIT(EFI_NOT_READY
);
965 * efi_search_obj() - find the internal EFI object for a handle
966 * @handle: handle to find
970 struct efi_object
*efi_search_obj(const efi_handle_t handle
)
972 struct efi_object
*efiobj
;
977 list_for_each_entry(efiobj
, &efi_obj_list
, link
) {
978 if (efiobj
== handle
)
985 * efi_open_protocol_info_entry() - create open protocol info entry and add it
987 * @handler: handler of a protocol
989 * Return: open protocol info entry
991 static struct efi_open_protocol_info_entry
*efi_create_open_info(
992 struct efi_handler
*handler
)
994 struct efi_open_protocol_info_item
*item
;
996 item
= calloc(1, sizeof(struct efi_open_protocol_info_item
));
999 /* Append the item to the open protocol info list. */
1000 list_add_tail(&item
->link
, &handler
->open_infos
);
1006 * efi_delete_open_info() - remove an open protocol info entry from a protocol
1007 * @item: open protocol info entry to delete
1009 * Return: status code
1011 static efi_status_t
efi_delete_open_info(
1012 struct efi_open_protocol_info_item
*item
)
1014 list_del(&item
->link
);
1020 * efi_add_protocol() - install new protocol on a handle
1021 * @handle: handle on which the protocol shall be installed
1022 * @protocol: GUID of the protocol to be installed
1023 * @protocol_interface: interface of the protocol implementation
1025 * Return: status code
1027 efi_status_t
efi_add_protocol(const efi_handle_t handle
,
1028 const efi_guid_t
*protocol
,
1029 void *protocol_interface
)
1031 struct efi_object
*efiobj
;
1032 struct efi_handler
*handler
;
1034 struct efi_register_notify_event
*event
;
1036 efiobj
= efi_search_obj(handle
);
1038 return EFI_INVALID_PARAMETER
;
1039 ret
= efi_search_protocol(handle
, protocol
, NULL
);
1040 if (ret
!= EFI_NOT_FOUND
)
1041 return EFI_INVALID_PARAMETER
;
1042 handler
= calloc(1, sizeof(struct efi_handler
));
1044 return EFI_OUT_OF_RESOURCES
;
1045 handler
->guid
= protocol
;
1046 handler
->protocol_interface
= protocol_interface
;
1047 INIT_LIST_HEAD(&handler
->open_infos
);
1048 list_add_tail(&handler
->link
, &efiobj
->protocols
);
1050 /* Notify registered events */
1051 list_for_each_entry(event
, &efi_register_notify_events
, link
) {
1052 if (!guidcmp(protocol
, &event
->protocol
))
1053 efi_signal_event(event
->event
, true);
1056 if (!guidcmp(&efi_guid_device_path
, protocol
))
1057 EFI_PRINT("installed device path '%pD'\n", protocol_interface
);
1062 * efi_install_protocol_interface() - install protocol interface
1063 * @handle: handle on which the protocol shall be installed
1064 * @protocol: GUID of the protocol to be installed
1065 * @protocol_interface_type: type of the interface to be installed,
1066 * always EFI_NATIVE_INTERFACE
1067 * @protocol_interface: interface of the protocol implementation
1069 * This function implements the InstallProtocolInterface service.
1071 * See the Unified Extensible Firmware Interface (UEFI) specification for
1074 * Return: status code
1076 static efi_status_t EFIAPI
efi_install_protocol_interface(
1077 efi_handle_t
*handle
, const efi_guid_t
*protocol
,
1078 int protocol_interface_type
, void *protocol_interface
)
1082 EFI_ENTRY("%p, %pUl, %d, %p", handle
, protocol
, protocol_interface_type
,
1083 protocol_interface
);
1085 if (!handle
|| !protocol
||
1086 protocol_interface_type
!= EFI_NATIVE_INTERFACE
) {
1087 r
= EFI_INVALID_PARAMETER
;
1091 /* Create new handle if requested. */
1093 r
= efi_create_handle(handle
);
1094 if (r
!= EFI_SUCCESS
)
1096 EFI_PRINT("new handle %p\n", *handle
);
1098 EFI_PRINT("handle %p\n", *handle
);
1100 /* Add new protocol */
1101 r
= efi_add_protocol(*handle
, protocol
, protocol_interface
);
1107 * efi_get_drivers() - get all drivers associated to a controller
1108 * @handle: handle of the controller
1109 * @protocol: protocol GUID (optional)
1110 * @number_of_drivers: number of child controllers
1111 * @driver_handle_buffer: handles of the the drivers
1113 * The allocated buffer has to be freed with free().
1115 * Return: status code
1117 static efi_status_t
efi_get_drivers(efi_handle_t handle
,
1118 const efi_guid_t
*protocol
,
1119 efi_uintn_t
*number_of_drivers
,
1120 efi_handle_t
**driver_handle_buffer
)
1122 struct efi_handler
*handler
;
1123 struct efi_open_protocol_info_item
*item
;
1124 efi_uintn_t count
= 0, i
;
1127 /* Count all driver associations */
1128 list_for_each_entry(handler
, &handle
->protocols
, link
) {
1129 if (protocol
&& guidcmp(handler
->guid
, protocol
))
1131 list_for_each_entry(item
, &handler
->open_infos
, link
) {
1132 if (item
->info
.attributes
&
1133 EFI_OPEN_PROTOCOL_BY_DRIVER
)
1138 * Create buffer. In case of duplicate driver assignments the buffer
1139 * will be too large. But that does not harm.
1141 *number_of_drivers
= 0;
1142 *driver_handle_buffer
= calloc(count
, sizeof(efi_handle_t
));
1143 if (!*driver_handle_buffer
)
1144 return EFI_OUT_OF_RESOURCES
;
1145 /* Collect unique driver handles */
1146 list_for_each_entry(handler
, &handle
->protocols
, link
) {
1147 if (protocol
&& guidcmp(handler
->guid
, protocol
))
1149 list_for_each_entry(item
, &handler
->open_infos
, link
) {
1150 if (item
->info
.attributes
&
1151 EFI_OPEN_PROTOCOL_BY_DRIVER
) {
1152 /* Check this is a new driver */
1154 for (i
= 0; i
< *number_of_drivers
; ++i
) {
1155 if ((*driver_handle_buffer
)[i
] ==
1156 item
->info
.agent_handle
)
1159 /* Copy handle to buffer */
1161 i
= (*number_of_drivers
)++;
1162 (*driver_handle_buffer
)[i
] =
1163 item
->info
.agent_handle
;
1172 * efi_disconnect_all_drivers() - disconnect all drivers from a controller
1173 * @handle: handle of the controller
1174 * @protocol: protocol GUID (optional)
1175 * @child_handle: handle of the child to destroy
1177 * This function implements the DisconnectController service.
1179 * See the Unified Extensible Firmware Interface (UEFI) specification for
1182 * Return: status code
1184 static efi_status_t efi_disconnect_all_drivers
1185 (efi_handle_t handle
,
1186 const efi_guid_t
*protocol
,
1187 efi_handle_t child_handle
)
1189 efi_uintn_t number_of_drivers
;
1190 efi_handle_t
*driver_handle_buffer
;
1191 efi_status_t r
, ret
;
1193 ret
= efi_get_drivers(handle
, protocol
, &number_of_drivers
,
1194 &driver_handle_buffer
);
1195 if (ret
!= EFI_SUCCESS
)
1198 ret
= EFI_NOT_FOUND
;
1199 while (number_of_drivers
) {
1200 r
= EFI_CALL(efi_disconnect_controller(
1202 driver_handle_buffer
[--number_of_drivers
],
1204 if (r
== EFI_SUCCESS
)
1207 free(driver_handle_buffer
);
1212 * efi_uninstall_protocol() - uninstall protocol interface
1214 * @handle: handle from which the protocol shall be removed
1215 * @protocol: GUID of the protocol to be removed
1216 * @protocol_interface: interface to be removed
1218 * This function DOES NOT delete a handle without installed protocol.
1220 * Return: status code
1222 static efi_status_t efi_uninstall_protocol
1223 (efi_handle_t handle
, const efi_guid_t
*protocol
,
1224 void *protocol_interface
)
1226 struct efi_object
*efiobj
;
1227 struct efi_handler
*handler
;
1228 struct efi_open_protocol_info_item
*item
;
1229 struct efi_open_protocol_info_item
*pos
;
1233 efiobj
= efi_search_obj(handle
);
1235 r
= EFI_INVALID_PARAMETER
;
1238 /* Find the protocol on the handle */
1239 r
= efi_search_protocol(handle
, protocol
, &handler
);
1240 if (r
!= EFI_SUCCESS
)
1242 /* Disconnect controllers */
1243 efi_disconnect_all_drivers(efiobj
, protocol
, NULL
);
1244 if (!list_empty(&handler
->open_infos
)) {
1245 r
= EFI_ACCESS_DENIED
;
1248 /* Close protocol */
1249 list_for_each_entry_safe(item
, pos
, &handler
->open_infos
, link
) {
1250 if (item
->info
.attributes
==
1251 EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL
||
1252 item
->info
.attributes
== EFI_OPEN_PROTOCOL_GET_PROTOCOL
||
1253 item
->info
.attributes
== EFI_OPEN_PROTOCOL_TEST_PROTOCOL
)
1254 list_del(&item
->link
);
1256 if (!list_empty(&handler
->open_infos
)) {
1257 r
= EFI_ACCESS_DENIED
;
1260 r
= efi_remove_protocol(handle
, protocol
, protocol_interface
);
1266 * efi_uninstall_protocol_interface() - uninstall protocol interface
1267 * @handle: handle from which the protocol shall be removed
1268 * @protocol: GUID of the protocol to be removed
1269 * @protocol_interface: interface to be removed
1271 * This function implements the UninstallProtocolInterface service.
1273 * See the Unified Extensible Firmware Interface (UEFI) specification for
1276 * Return: status code
1278 static efi_status_t EFIAPI efi_uninstall_protocol_interface
1279 (efi_handle_t handle
, const efi_guid_t
*protocol
,
1280 void *protocol_interface
)
1284 EFI_ENTRY("%p, %pUl, %p", handle
, protocol
, protocol_interface
);
1286 ret
= efi_uninstall_protocol(handle
, protocol
, protocol_interface
);
1287 if (ret
!= EFI_SUCCESS
)
1290 /* If the last protocol has been removed, delete the handle. */
1291 if (list_empty(&handle
->protocols
)) {
1292 list_del(&handle
->link
);
1296 return EFI_EXIT(ret
);
1300 * efi_register_protocol_notify() - register an event for notification when a
1301 * protocol is installed.
1302 * @protocol: GUID of the protocol whose installation shall be notified
1303 * @event: event to be signaled upon installation of the protocol
1304 * @registration: key for retrieving the registration information
1306 * This function implements the RegisterProtocolNotify service.
1307 * See the Unified Extensible Firmware Interface (UEFI) specification
1310 * Return: status code
1312 static efi_status_t EFIAPI
efi_register_protocol_notify(
1313 const efi_guid_t
*protocol
,
1314 struct efi_event
*event
,
1315 void **registration
)
1317 struct efi_register_notify_event
*item
;
1318 efi_status_t ret
= EFI_SUCCESS
;
1320 EFI_ENTRY("%pUl, %p, %p", protocol
, event
, registration
);
1322 if (!protocol
|| !event
|| !registration
) {
1323 ret
= EFI_INVALID_PARAMETER
;
1327 item
= calloc(1, sizeof(struct efi_register_notify_event
));
1329 ret
= EFI_OUT_OF_RESOURCES
;
1333 item
->event
= event
;
1334 memcpy(&item
->protocol
, protocol
, sizeof(efi_guid_t
));
1336 list_add_tail(&item
->link
, &efi_register_notify_events
);
1338 *registration
= item
;
1340 return EFI_EXIT(ret
);
1344 * efi_search() - determine if an EFI handle implements a protocol
1345 * @search_type: selection criterion
1346 * @protocol: GUID of the protocol
1347 * @search_key: registration key
1350 * See the documentation of the LocateHandle service in the UEFI specification.
1352 * Return: 0 if the handle implements the protocol
1354 static int efi_search(enum efi_locate_search_type search_type
,
1355 const efi_guid_t
*protocol
, efi_handle_t handle
)
1359 switch (search_type
) {
1362 case BY_REGISTER_NOTIFY
:
1364 ret
= efi_search_protocol(handle
, protocol
, NULL
);
1365 return (ret
!= EFI_SUCCESS
);
1367 /* Invalid search type */
1373 * efi_locate_handle() - locate handles implementing a protocol
1375 * @search_type: selection criterion
1376 * @protocol: GUID of the protocol
1377 * @search_key: registration key
1378 * @buffer_size: size of the buffer to receive the handles in bytes
1379 * @buffer: buffer to receive the relevant handles
1381 * This function is meant for U-Boot internal calls. For the API implementation
1382 * of the LocateHandle service see efi_locate_handle_ext.
1384 * Return: status code
1386 static efi_status_t
efi_locate_handle(
1387 enum efi_locate_search_type search_type
,
1388 const efi_guid_t
*protocol
, void *search_key
,
1389 efi_uintn_t
*buffer_size
, efi_handle_t
*buffer
)
1391 struct efi_object
*efiobj
;
1392 efi_uintn_t size
= 0;
1393 struct efi_register_notify_event
*item
, *event
= NULL
;
1395 /* Check parameters */
1396 switch (search_type
) {
1399 case BY_REGISTER_NOTIFY
:
1401 return EFI_INVALID_PARAMETER
;
1402 /* Check that the registration key is valid */
1403 list_for_each_entry(item
, &efi_register_notify_events
, link
) {
1405 (struct efi_register_notify_event
*)search_key
) {
1411 return EFI_INVALID_PARAMETER
;
1413 protocol
= &event
->protocol
;
1417 return EFI_INVALID_PARAMETER
;
1420 return EFI_INVALID_PARAMETER
;
1423 /* Count how much space we need */
1424 list_for_each_entry(efiobj
, &efi_obj_list
, link
) {
1425 if (!efi_search(search_type
, protocol
, efiobj
))
1426 size
+= sizeof(void *);
1430 return EFI_NOT_FOUND
;
1433 return EFI_INVALID_PARAMETER
;
1435 if (*buffer_size
< size
) {
1436 *buffer_size
= size
;
1437 return EFI_BUFFER_TOO_SMALL
;
1440 *buffer_size
= size
;
1442 /* The buffer size is sufficient but there is not buffer */
1444 return EFI_INVALID_PARAMETER
;
1446 /* Then fill the array */
1447 list_for_each_entry(efiobj
, &efi_obj_list
, link
) {
1448 if (!efi_search(search_type
, protocol
, efiobj
))
1456 * efi_locate_handle_ext() - locate handles implementing a protocol.
1457 * @search_type: selection criterion
1458 * @protocol: GUID of the protocol
1459 * @search_key: registration key
1460 * @buffer_size: size of the buffer to receive the handles in bytes
1461 * @buffer: buffer to receive the relevant handles
1463 * This function implements the LocateHandle service.
1465 * See the Unified Extensible Firmware Interface (UEFI) specification for
1468 * Return: 0 if the handle implements the protocol
1470 static efi_status_t EFIAPI
efi_locate_handle_ext(
1471 enum efi_locate_search_type search_type
,
1472 const efi_guid_t
*protocol
, void *search_key
,
1473 efi_uintn_t
*buffer_size
, efi_handle_t
*buffer
)
1475 EFI_ENTRY("%d, %pUl, %p, %p, %p", search_type
, protocol
, search_key
,
1476 buffer_size
, buffer
);
1478 return EFI_EXIT(efi_locate_handle(search_type
, protocol
, search_key
,
1479 buffer_size
, buffer
));
1483 * efi_remove_configuration_table() - collapses configuration table entries,
1486 * @i: index of the table entry to be removed
1488 static void efi_remove_configuration_table(int i
)
1490 struct efi_configuration_table
*this = &systab
.tables
[i
];
1491 struct efi_configuration_table
*next
= &systab
.tables
[i
+ 1];
1492 struct efi_configuration_table
*end
= &systab
.tables
[systab
.nr_tables
];
1494 memmove(this, next
, (ulong
)end
- (ulong
)next
);
1499 * efi_install_configuration_table() - adds, updates, or removes a
1500 * configuration table
1501 * @guid: GUID of the installed table
1502 * @table: table to be installed
1504 * This function is used for internal calls. For the API implementation of the
1505 * InstallConfigurationTable service see efi_install_configuration_table_ext.
1507 * Return: status code
1509 efi_status_t
efi_install_configuration_table(const efi_guid_t
*guid
,
1512 struct efi_event
*evt
;
1516 return EFI_INVALID_PARAMETER
;
1518 /* Check for GUID override */
1519 for (i
= 0; i
< systab
.nr_tables
; i
++) {
1520 if (!guidcmp(guid
, &systab
.tables
[i
].guid
)) {
1522 systab
.tables
[i
].table
= table
;
1524 efi_remove_configuration_table(i
);
1530 return EFI_NOT_FOUND
;
1532 /* No override, check for overflow */
1533 if (i
>= EFI_MAX_CONFIGURATION_TABLES
)
1534 return EFI_OUT_OF_RESOURCES
;
1536 /* Add a new entry */
1537 memcpy(&systab
.tables
[i
].guid
, guid
, sizeof(*guid
));
1538 systab
.tables
[i
].table
= table
;
1539 systab
.nr_tables
= i
+ 1;
1542 /* systab.nr_tables may have changed. So we need to update the CRC32 */
1543 efi_update_table_header_crc32(&systab
.hdr
);
1545 /* Notify that the configuration table was changed */
1546 list_for_each_entry(evt
, &efi_events
, link
) {
1547 if (evt
->group
&& !guidcmp(evt
->group
, guid
)) {
1548 efi_signal_event(evt
, false);
1557 * efi_install_configuration_table_ex() - Adds, updates, or removes a
1558 * configuration table.
1559 * @guid: GUID of the installed table
1560 * @table: table to be installed
1562 * This function implements the InstallConfigurationTable service.
1564 * See the Unified Extensible Firmware Interface (UEFI) specification for
1567 * Return: status code
1569 static efi_status_t EFIAPI
efi_install_configuration_table_ext(efi_guid_t
*guid
,
1572 EFI_ENTRY("%pUl, %p", guid
, table
);
1573 return EFI_EXIT(efi_install_configuration_table(guid
, table
));
1577 * efi_setup_loaded_image() - initialize a loaded image
1579 * Initialize a loaded_image_info and loaded_image_info object with correct
1580 * protocols, boot-device, etc.
1582 * In case of an error *handle_ptr and *info_ptr are set to NULL and an error
1585 * @device_path: device path of the loaded image
1586 * @file_path: file path of the loaded image
1587 * @handle_ptr: handle of the loaded image
1588 * @info_ptr: loaded image protocol
1589 * Return: status code
1591 efi_status_t
efi_setup_loaded_image(struct efi_device_path
*device_path
,
1592 struct efi_device_path
*file_path
,
1593 struct efi_loaded_image_obj
**handle_ptr
,
1594 struct efi_loaded_image
**info_ptr
)
1597 struct efi_loaded_image
*info
= NULL
;
1598 struct efi_loaded_image_obj
*obj
= NULL
;
1599 struct efi_device_path
*dp
;
1601 /* In case of EFI_OUT_OF_RESOURCES avoid illegal free by caller. */
1605 info
= calloc(1, sizeof(*info
));
1607 return EFI_OUT_OF_RESOURCES
;
1608 obj
= calloc(1, sizeof(*obj
));
1611 return EFI_OUT_OF_RESOURCES
;
1613 obj
->header
.type
= EFI_OBJECT_TYPE_LOADED_IMAGE
;
1615 /* Add internal object to object list */
1616 efi_add_handle(&obj
->header
);
1618 info
->revision
= EFI_LOADED_IMAGE_PROTOCOL_REVISION
;
1619 info
->file_path
= file_path
;
1620 info
->system_table
= &systab
;
1623 info
->device_handle
= efi_dp_find_obj(device_path
, NULL
);
1625 dp
= efi_dp_append(device_path
, file_path
);
1627 ret
= EFI_OUT_OF_RESOURCES
;
1633 ret
= efi_add_protocol(&obj
->header
,
1634 &efi_guid_loaded_image_device_path
, dp
);
1635 if (ret
!= EFI_SUCCESS
)
1639 * When asking for the loaded_image interface, just
1640 * return handle which points to loaded_image_info
1642 ret
= efi_add_protocol(&obj
->header
,
1643 &efi_guid_loaded_image
, info
);
1644 if (ret
!= EFI_SUCCESS
)
1652 printf("ERROR: Failure to install protocols for loaded image\n");
1653 efi_delete_handle(&obj
->header
);
1659 * efi_load_image_from_path() - load an image using a file path
1661 * Read a file into a buffer allocated as EFI_BOOT_SERVICES_DATA. It is the
1662 * callers obligation to update the memory type as needed.
1664 * @file_path: the path of the image to load
1665 * @buffer: buffer containing the loaded image
1666 * @size: size of the loaded image
1667 * Return: status code
1670 efi_status_t
efi_load_image_from_path(struct efi_device_path
*file_path
,
1671 void **buffer
, efi_uintn_t
*size
)
1673 struct efi_file_info
*info
= NULL
;
1674 struct efi_file_handle
*f
;
1675 static efi_status_t ret
;
1679 /* In case of failure nothing is returned */
1684 f
= efi_file_from_path(file_path
);
1686 return EFI_DEVICE_ERROR
;
1690 EFI_CALL(ret
= f
->getinfo(f
, (efi_guid_t
*)&efi_file_info_guid
,
1692 if (ret
!= EFI_BUFFER_TOO_SMALL
) {
1693 ret
= EFI_DEVICE_ERROR
;
1698 EFI_CALL(ret
= f
->getinfo(f
, (efi_guid_t
*)&efi_file_info_guid
, &bs
,
1700 if (ret
!= EFI_SUCCESS
)
1704 * When reading the file we do not yet know if it contains an
1705 * application, a boottime driver, or a runtime driver. So here we
1706 * allocate a buffer as EFI_BOOT_SERVICES_DATA. The caller has to
1707 * update the reservation according to the image type.
1709 bs
= info
->file_size
;
1710 ret
= efi_allocate_pages(EFI_ALLOCATE_ANY_PAGES
,
1711 EFI_BOOT_SERVICES_DATA
,
1712 efi_size_in_pages(bs
), &addr
);
1713 if (ret
!= EFI_SUCCESS
) {
1714 ret
= EFI_OUT_OF_RESOURCES
;
1719 EFI_CALL(ret
= f
->read(f
, &bs
, (void *)(uintptr_t)addr
));
1720 if (ret
!= EFI_SUCCESS
)
1721 efi_free_pages(addr
, efi_size_in_pages(bs
));
1722 *buffer
= (void *)(uintptr_t)addr
;
1725 EFI_CALL(f
->close(f
));
1731 * efi_load_image() - load an EFI image into memory
1732 * @boot_policy: true for request originating from the boot manager
1733 * @parent_image: the caller's image handle
1734 * @file_path: the path of the image to load
1735 * @source_buffer: memory location from which the image is installed
1736 * @source_size: size of the memory area from which the image is installed
1737 * @image_handle: handle for the newly installed image
1739 * This function implements the LoadImage service.
1741 * See the Unified Extensible Firmware Interface (UEFI) specification
1744 * Return: status code
1746 efi_status_t EFIAPI
efi_load_image(bool boot_policy
,
1747 efi_handle_t parent_image
,
1748 struct efi_device_path
*file_path
,
1749 void *source_buffer
,
1750 efi_uintn_t source_size
,
1751 efi_handle_t
*image_handle
)
1753 struct efi_device_path
*dp
, *fp
;
1754 struct efi_loaded_image
*info
= NULL
;
1755 struct efi_loaded_image_obj
**image_obj
=
1756 (struct efi_loaded_image_obj
**)image_handle
;
1760 EFI_ENTRY("%d, %p, %pD, %p, %zd, %p", boot_policy
, parent_image
,
1761 file_path
, source_buffer
, source_size
, image_handle
);
1763 if (!image_handle
|| !efi_search_obj(parent_image
)) {
1764 ret
= EFI_INVALID_PARAMETER
;
1768 if (!source_buffer
&& !file_path
) {
1769 ret
= EFI_NOT_FOUND
;
1772 /* The parent image handle must refer to a loaded image */
1773 if (!parent_image
->type
) {
1774 ret
= EFI_INVALID_PARAMETER
;
1778 if (!source_buffer
) {
1779 ret
= efi_load_image_from_path(file_path
, &dest_buffer
,
1781 if (ret
!= EFI_SUCCESS
)
1784 dest_buffer
= source_buffer
;
1786 /* split file_path which contains both the device and file parts */
1787 efi_dp_split_file_path(file_path
, &dp
, &fp
);
1788 ret
= efi_setup_loaded_image(dp
, fp
, image_obj
, &info
);
1789 if (ret
== EFI_SUCCESS
)
1790 ret
= efi_load_pe(*image_obj
, dest_buffer
, info
);
1792 /* Release buffer to which file was loaded */
1793 efi_free_pages((uintptr_t)dest_buffer
,
1794 efi_size_in_pages(source_size
));
1795 if (ret
== EFI_SUCCESS
) {
1796 info
->system_table
= &systab
;
1797 info
->parent_handle
= parent_image
;
1799 /* The image is invalid. Release all associated resources. */
1800 efi_delete_handle(*image_handle
);
1801 *image_handle
= NULL
;
1805 return EFI_EXIT(ret
);
1809 * efi_exit_caches() - fix up caches for EFI payloads if necessary
1811 static void efi_exit_caches(void)
1813 #if defined(CONFIG_ARM) && !defined(CONFIG_ARM64)
1815 * Grub on 32bit ARM needs to have caches disabled before jumping into
1816 * a zImage, but does not know of all cache layers. Give it a hand.
1818 if (efi_is_direct_boot
)
1819 cleanup_before_linux();
1824 * efi_exit_boot_services() - stop all boot services
1825 * @image_handle: handle of the loaded image
1826 * @map_key: key of the memory map
1828 * This function implements the ExitBootServices service.
1830 * See the Unified Extensible Firmware Interface (UEFI) specification
1833 * All timer events are disabled. For exit boot services events the
1834 * notification function is called. The boot services are disabled in the
1837 * Return: status code
1839 static efi_status_t EFIAPI
efi_exit_boot_services(efi_handle_t image_handle
,
1840 unsigned long map_key
)
1842 struct efi_event
*evt
;
1844 EFI_ENTRY("%p, %ld", image_handle
, map_key
);
1846 /* Check that the caller has read the current memory map */
1847 if (map_key
!= efi_memory_map_key
)
1848 return EFI_INVALID_PARAMETER
;
1850 /* Make sure that notification functions are not called anymore */
1851 efi_tpl
= TPL_HIGH_LEVEL
;
1853 /* Check if ExitBootServices has already been called */
1854 if (!systab
.boottime
)
1855 return EFI_EXIT(EFI_SUCCESS
);
1857 /* Add related events to the event group */
1858 list_for_each_entry(evt
, &efi_events
, link
) {
1859 if (evt
->type
== EVT_SIGNAL_EXIT_BOOT_SERVICES
)
1860 evt
->group
= &efi_guid_event_group_exit_boot_services
;
1862 /* Notify that ExitBootServices is invoked. */
1863 list_for_each_entry(evt
, &efi_events
, link
) {
1865 !guidcmp(evt
->group
,
1866 &efi_guid_event_group_exit_boot_services
)) {
1867 efi_signal_event(evt
, false);
1872 /* TODO: Should persist EFI variables here */
1874 board_quiesce_devices();
1876 /* Fix up caches for EFI payloads if necessary */
1879 /* This stops all lingering devices */
1880 bootm_disable_interrupts();
1882 /* Disable boot time services */
1883 systab
.con_in_handle
= NULL
;
1884 systab
.con_in
= NULL
;
1885 systab
.con_out_handle
= NULL
;
1886 systab
.con_out
= NULL
;
1887 systab
.stderr_handle
= NULL
;
1888 systab
.std_err
= NULL
;
1889 systab
.boottime
= NULL
;
1891 /* Recalculate CRC32 */
1892 efi_update_table_header_crc32(&systab
.hdr
);
1894 /* Give the payload some time to boot */
1895 efi_set_watchdog(0);
1898 return EFI_EXIT(EFI_SUCCESS
);
1902 * efi_get_next_monotonic_count() - get next value of the counter
1903 * @count: returned value of the counter
1905 * This function implements the NextMonotonicCount service.
1907 * See the Unified Extensible Firmware Interface (UEFI) specification for
1910 * Return: status code
1912 static efi_status_t EFIAPI
efi_get_next_monotonic_count(uint64_t *count
)
1914 static uint64_t mono
;
1916 EFI_ENTRY("%p", count
);
1918 return EFI_EXIT(EFI_SUCCESS
);
1922 * efi_stall() - sleep
1923 * @microseconds: period to sleep in microseconds
1925 * This function implements the Stall service.
1927 * See the Unified Extensible Firmware Interface (UEFI) specification for
1930 * Return: status code
1932 static efi_status_t EFIAPI
efi_stall(unsigned long microseconds
)
1934 EFI_ENTRY("%ld", microseconds
);
1935 udelay(microseconds
);
1936 return EFI_EXIT(EFI_SUCCESS
);
1940 * efi_set_watchdog_timer() - reset the watchdog timer
1941 * @timeout: seconds before reset by watchdog
1942 * @watchdog_code: code to be logged when resetting
1943 * @data_size: size of buffer in bytes
1944 * @watchdog_data: buffer with data describing the reset reason
1946 * This function implements the SetWatchdogTimer service.
1948 * See the Unified Extensible Firmware Interface (UEFI) specification for
1951 * Return: status code
1953 static efi_status_t EFIAPI
efi_set_watchdog_timer(unsigned long timeout
,
1954 uint64_t watchdog_code
,
1955 unsigned long data_size
,
1956 uint16_t *watchdog_data
)
1958 EFI_ENTRY("%ld, 0x%llx, %ld, %p", timeout
, watchdog_code
,
1959 data_size
, watchdog_data
);
1960 return EFI_EXIT(efi_set_watchdog(timeout
));
1964 * efi_close_protocol() - close a protocol
1965 * @handle: handle on which the protocol shall be closed
1966 * @protocol: GUID of the protocol to close
1967 * @agent_handle: handle of the driver
1968 * @controller_handle: handle of the controller
1970 * This function implements the CloseProtocol service.
1972 * See the Unified Extensible Firmware Interface (UEFI) specification for
1975 * Return: status code
1977 static efi_status_t EFIAPI
efi_close_protocol(efi_handle_t handle
,
1978 const efi_guid_t
*protocol
,
1979 efi_handle_t agent_handle
,
1980 efi_handle_t controller_handle
)
1982 struct efi_handler
*handler
;
1983 struct efi_open_protocol_info_item
*item
;
1984 struct efi_open_protocol_info_item
*pos
;
1987 EFI_ENTRY("%p, %pUl, %p, %p", handle
, protocol
, agent_handle
,
1990 if (!efi_search_obj(agent_handle
) ||
1991 (controller_handle
&& !efi_search_obj(controller_handle
))) {
1992 r
= EFI_INVALID_PARAMETER
;
1995 r
= efi_search_protocol(handle
, protocol
, &handler
);
1996 if (r
!= EFI_SUCCESS
)
2000 list_for_each_entry_safe(item
, pos
, &handler
->open_infos
, link
) {
2001 if (item
->info
.agent_handle
== agent_handle
&&
2002 item
->info
.controller_handle
== controller_handle
) {
2003 efi_delete_open_info(item
);
2013 * efi_open_protocol_information() - provide information about then open status
2014 * of a protocol on a handle
2015 * @handle: handle for which the information shall be retrieved
2016 * @protocol: GUID of the protocol
2017 * @entry_buffer: buffer to receive the open protocol information
2018 * @entry_count: number of entries available in the buffer
2020 * This function implements the OpenProtocolInformation service.
2022 * See the Unified Extensible Firmware Interface (UEFI) specification for
2025 * Return: status code
2027 static efi_status_t EFIAPI
efi_open_protocol_information(
2028 efi_handle_t handle
, const efi_guid_t
*protocol
,
2029 struct efi_open_protocol_info_entry
**entry_buffer
,
2030 efi_uintn_t
*entry_count
)
2032 unsigned long buffer_size
;
2033 unsigned long count
;
2034 struct efi_handler
*handler
;
2035 struct efi_open_protocol_info_item
*item
;
2038 EFI_ENTRY("%p, %pUl, %p, %p", handle
, protocol
, entry_buffer
,
2041 /* Check parameters */
2042 if (!entry_buffer
) {
2043 r
= EFI_INVALID_PARAMETER
;
2046 r
= efi_search_protocol(handle
, protocol
, &handler
);
2047 if (r
!= EFI_SUCCESS
)
2052 list_for_each_entry(item
, &handler
->open_infos
, link
) {
2053 if (item
->info
.open_count
)
2056 *entry_count
= count
;
2057 *entry_buffer
= NULL
;
2064 buffer_size
= count
* sizeof(struct efi_open_protocol_info_entry
);
2065 r
= efi_allocate_pool(EFI_BOOT_SERVICES_DATA
, buffer_size
,
2066 (void **)entry_buffer
);
2067 if (r
!= EFI_SUCCESS
)
2069 list_for_each_entry_reverse(item
, &handler
->open_infos
, link
) {
2070 if (item
->info
.open_count
)
2071 (*entry_buffer
)[--count
] = item
->info
;
2078 * efi_protocols_per_handle() - get protocols installed on a handle
2079 * @handle: handle for which the information is retrieved
2080 * @protocol_buffer: buffer with protocol GUIDs
2081 * @protocol_buffer_count: number of entries in the buffer
2083 * This function implements the ProtocolsPerHandleService.
2085 * See the Unified Extensible Firmware Interface (UEFI) specification for
2088 * Return: status code
2090 static efi_status_t EFIAPI
efi_protocols_per_handle(
2091 efi_handle_t handle
, efi_guid_t
***protocol_buffer
,
2092 efi_uintn_t
*protocol_buffer_count
)
2094 unsigned long buffer_size
;
2095 struct efi_object
*efiobj
;
2096 struct list_head
*protocol_handle
;
2099 EFI_ENTRY("%p, %p, %p", handle
, protocol_buffer
,
2100 protocol_buffer_count
);
2102 if (!handle
|| !protocol_buffer
|| !protocol_buffer_count
)
2103 return EFI_EXIT(EFI_INVALID_PARAMETER
);
2105 *protocol_buffer
= NULL
;
2106 *protocol_buffer_count
= 0;
2108 efiobj
= efi_search_obj(handle
);
2110 return EFI_EXIT(EFI_INVALID_PARAMETER
);
2112 /* Count protocols */
2113 list_for_each(protocol_handle
, &efiobj
->protocols
) {
2114 ++*protocol_buffer_count
;
2118 if (*protocol_buffer_count
) {
2121 buffer_size
= sizeof(efi_guid_t
*) * *protocol_buffer_count
;
2122 r
= efi_allocate_pool(EFI_BOOT_SERVICES_DATA
, buffer_size
,
2123 (void **)protocol_buffer
);
2124 if (r
!= EFI_SUCCESS
)
2126 list_for_each(protocol_handle
, &efiobj
->protocols
) {
2127 struct efi_handler
*protocol
;
2129 protocol
= list_entry(protocol_handle
,
2130 struct efi_handler
, link
);
2131 (*protocol_buffer
)[j
] = (void *)protocol
->guid
;
2136 return EFI_EXIT(EFI_SUCCESS
);
2140 * efi_locate_handle_buffer() - locate handles implementing a protocol
2141 * @search_type: selection criterion
2142 * @protocol: GUID of the protocol
2143 * @search_key: registration key
2144 * @no_handles: number of returned handles
2145 * @buffer: buffer with the returned handles
2147 * This function implements the LocateHandleBuffer service.
2149 * See the Unified Extensible Firmware Interface (UEFI) specification for
2152 * Return: status code
2154 static efi_status_t EFIAPI
efi_locate_handle_buffer(
2155 enum efi_locate_search_type search_type
,
2156 const efi_guid_t
*protocol
, void *search_key
,
2157 efi_uintn_t
*no_handles
, efi_handle_t
**buffer
)
2160 efi_uintn_t buffer_size
= 0;
2162 EFI_ENTRY("%d, %pUl, %p, %p, %p", search_type
, protocol
, search_key
,
2163 no_handles
, buffer
);
2165 if (!no_handles
|| !buffer
) {
2166 r
= EFI_INVALID_PARAMETER
;
2171 r
= efi_locate_handle(search_type
, protocol
, search_key
, &buffer_size
,
2173 if (r
!= EFI_BUFFER_TOO_SMALL
)
2175 r
= efi_allocate_pool(EFI_BOOT_SERVICES_DATA
, buffer_size
,
2177 if (r
!= EFI_SUCCESS
)
2179 r
= efi_locate_handle(search_type
, protocol
, search_key
, &buffer_size
,
2181 if (r
== EFI_SUCCESS
)
2182 *no_handles
= buffer_size
/ sizeof(efi_handle_t
);
2188 * efi_locate_protocol() - find an interface implementing a protocol
2189 * @protocol: GUID of the protocol
2190 * @registration: registration key passed to the notification function
2191 * @protocol_interface: interface implementing the protocol
2193 * This function implements the LocateProtocol service.
2195 * See the Unified Extensible Firmware Interface (UEFI) specification for
2198 * Return: status code
2200 static efi_status_t EFIAPI
efi_locate_protocol(const efi_guid_t
*protocol
,
2202 void **protocol_interface
)
2204 struct list_head
*lhandle
;
2207 EFI_ENTRY("%pUl, %p, %p", protocol
, registration
, protocol_interface
);
2209 if (!protocol
|| !protocol_interface
)
2210 return EFI_EXIT(EFI_INVALID_PARAMETER
);
2212 list_for_each(lhandle
, &efi_obj_list
) {
2213 struct efi_object
*efiobj
;
2214 struct efi_handler
*handler
;
2216 efiobj
= list_entry(lhandle
, struct efi_object
, link
);
2218 ret
= efi_search_protocol(efiobj
, protocol
, &handler
);
2219 if (ret
== EFI_SUCCESS
) {
2220 *protocol_interface
= handler
->protocol_interface
;
2221 return EFI_EXIT(EFI_SUCCESS
);
2224 *protocol_interface
= NULL
;
2226 return EFI_EXIT(EFI_NOT_FOUND
);
2230 * efi_locate_device_path() - Get the device path and handle of an device
2231 * implementing a protocol
2232 * @protocol: GUID of the protocol
2233 * @device_path: device path
2234 * @device: handle of the device
2236 * This function implements the LocateDevicePath service.
2238 * See the Unified Extensible Firmware Interface (UEFI) specification for
2241 * Return: status code
2243 static efi_status_t EFIAPI
efi_locate_device_path(
2244 const efi_guid_t
*protocol
,
2245 struct efi_device_path
**device_path
,
2246 efi_handle_t
*device
)
2248 struct efi_device_path
*dp
;
2250 struct efi_handler
*handler
;
2251 efi_handle_t
*handles
;
2253 size_t len_best
= 0;
2254 efi_uintn_t no_handles
;
2258 EFI_ENTRY("%pUl, %p, %p", protocol
, device_path
, device
);
2260 if (!protocol
|| !device_path
|| !*device_path
|| !device
) {
2261 ret
= EFI_INVALID_PARAMETER
;
2265 /* Find end of device path */
2266 len
= efi_dp_instance_size(*device_path
);
2268 /* Get all handles implementing the protocol */
2269 ret
= EFI_CALL(efi_locate_handle_buffer(BY_PROTOCOL
, protocol
, NULL
,
2270 &no_handles
, &handles
));
2271 if (ret
!= EFI_SUCCESS
)
2274 for (i
= 0; i
< no_handles
; ++i
) {
2275 /* Find the device path protocol */
2276 ret
= efi_search_protocol(handles
[i
], &efi_guid_device_path
,
2278 if (ret
!= EFI_SUCCESS
)
2280 dp
= (struct efi_device_path
*)handler
->protocol_interface
;
2281 len_dp
= efi_dp_instance_size(dp
);
2283 * This handle can only be a better fit
2284 * if its device path length is longer than the best fit and
2285 * if its device path length is shorter of equal the searched
2288 if (len_dp
<= len_best
|| len_dp
> len
)
2290 /* Check if dp is a subpath of device_path */
2291 if (memcmp(*device_path
, dp
, len_dp
))
2293 *device
= handles
[i
];
2297 remainder
= (u8
*)*device_path
+ len_best
;
2298 *device_path
= (struct efi_device_path
*)remainder
;
2301 ret
= EFI_NOT_FOUND
;
2304 return EFI_EXIT(ret
);
2308 * efi_install_multiple_protocol_interfaces() - Install multiple protocol
2310 * @handle: handle on which the protocol interfaces shall be installed
2311 * @...: NULL terminated argument list with pairs of protocol GUIDS and
2314 * This function implements the MultipleProtocolInterfaces service.
2316 * See the Unified Extensible Firmware Interface (UEFI) specification for
2319 * Return: status code
2321 efi_status_t EFIAPI efi_install_multiple_protocol_interfaces
2322 (efi_handle_t
*handle
, ...)
2324 EFI_ENTRY("%p", handle
);
2327 const efi_guid_t
*protocol
;
2328 void *protocol_interface
;
2329 efi_status_t r
= EFI_SUCCESS
;
2333 return EFI_EXIT(EFI_INVALID_PARAMETER
);
2335 efi_va_start(argptr
, handle
);
2337 protocol
= efi_va_arg(argptr
, efi_guid_t
*);
2340 protocol_interface
= efi_va_arg(argptr
, void*);
2341 r
= EFI_CALL(efi_install_protocol_interface(
2343 EFI_NATIVE_INTERFACE
,
2344 protocol_interface
));
2345 if (r
!= EFI_SUCCESS
)
2350 if (r
== EFI_SUCCESS
)
2353 /* If an error occurred undo all changes. */
2354 efi_va_start(argptr
, handle
);
2356 protocol
= efi_va_arg(argptr
, efi_guid_t
*);
2357 protocol_interface
= efi_va_arg(argptr
, void*);
2358 EFI_CALL(efi_uninstall_protocol_interface(*handle
, protocol
,
2359 protocol_interface
));
2367 * efi_uninstall_multiple_protocol_interfaces() - uninstall multiple protocol
2369 * @handle: handle from which the protocol interfaces shall be removed
2370 * @...: NULL terminated argument list with pairs of protocol GUIDS and
2373 * This function implements the UninstallMultipleProtocolInterfaces service.
2375 * See the Unified Extensible Firmware Interface (UEFI) specification for
2378 * Return: status code
2380 static efi_status_t EFIAPI
efi_uninstall_multiple_protocol_interfaces(
2381 efi_handle_t handle
, ...)
2383 EFI_ENTRY("%p", handle
);
2386 const efi_guid_t
*protocol
;
2387 void *protocol_interface
;
2388 efi_status_t r
= EFI_SUCCESS
;
2392 return EFI_EXIT(EFI_INVALID_PARAMETER
);
2394 efi_va_start(argptr
, handle
);
2396 protocol
= efi_va_arg(argptr
, efi_guid_t
*);
2399 protocol_interface
= efi_va_arg(argptr
, void*);
2400 r
= efi_uninstall_protocol(handle
, protocol
,
2401 protocol_interface
);
2402 if (r
!= EFI_SUCCESS
)
2407 if (r
== EFI_SUCCESS
) {
2408 /* If the last protocol has been removed, delete the handle. */
2409 if (list_empty(&handle
->protocols
)) {
2410 list_del(&handle
->link
);
2416 /* If an error occurred undo all changes. */
2417 efi_va_start(argptr
, handle
);
2419 protocol
= efi_va_arg(argptr
, efi_guid_t
*);
2420 protocol_interface
= efi_va_arg(argptr
, void*);
2421 EFI_CALL(efi_install_protocol_interface(&handle
, protocol
,
2422 EFI_NATIVE_INTERFACE
,
2423 protocol_interface
));
2427 /* In case of an error always return EFI_INVALID_PARAMETER */
2428 return EFI_EXIT(EFI_INVALID_PARAMETER
);
2432 * efi_calculate_crc32() - calculate cyclic redundancy code
2433 * @data: buffer with data
2434 * @data_size: size of buffer in bytes
2435 * @crc32_p: cyclic redundancy code
2437 * This function implements the CalculateCrc32 service.
2439 * See the Unified Extensible Firmware Interface (UEFI) specification for
2442 * Return: status code
2444 static efi_status_t EFIAPI
efi_calculate_crc32(const void *data
,
2445 efi_uintn_t data_size
,
2448 EFI_ENTRY("%p, %zu", data
, data_size
);
2449 *crc32_p
= crc32(0, data
, data_size
);
2450 return EFI_EXIT(EFI_SUCCESS
);
2454 * efi_copy_mem() - copy memory
2455 * @destination: destination of the copy operation
2456 * @source: source of the copy operation
2457 * @length: number of bytes to copy
2459 * This function implements the CopyMem service.
2461 * See the Unified Extensible Firmware Interface (UEFI) specification for
2464 static void EFIAPI
efi_copy_mem(void *destination
, const void *source
,
2467 EFI_ENTRY("%p, %p, %ld", destination
, source
, (unsigned long)length
);
2468 memmove(destination
, source
, length
);
2469 EFI_EXIT(EFI_SUCCESS
);
2473 * efi_set_mem() - Fill memory with a byte value.
2474 * @buffer: buffer to fill
2475 * @size: size of buffer in bytes
2476 * @value: byte to copy to the buffer
2478 * This function implements the SetMem service.
2480 * See the Unified Extensible Firmware Interface (UEFI) specification for
2483 static void EFIAPI
efi_set_mem(void *buffer
, size_t size
, uint8_t value
)
2485 EFI_ENTRY("%p, %ld, 0x%x", buffer
, (unsigned long)size
, value
);
2486 memset(buffer
, value
, size
);
2487 EFI_EXIT(EFI_SUCCESS
);
2491 * efi_protocol_open() - open protocol interface on a handle
2492 * @handler: handler of a protocol
2493 * @protocol_interface: interface implementing the protocol
2494 * @agent_handle: handle of the driver
2495 * @controller_handle: handle of the controller
2496 * @attributes: attributes indicating how to open the protocol
2498 * Return: status code
2500 static efi_status_t
efi_protocol_open(
2501 struct efi_handler
*handler
,
2502 void **protocol_interface
, void *agent_handle
,
2503 void *controller_handle
, uint32_t attributes
)
2505 struct efi_open_protocol_info_item
*item
;
2506 struct efi_open_protocol_info_entry
*match
= NULL
;
2507 bool opened_by_driver
= false;
2508 bool opened_exclusive
= false;
2510 /* If there is no agent, only return the interface */
2514 /* For TEST_PROTOCOL ignore interface attribute */
2515 if (attributes
!= EFI_OPEN_PROTOCOL_TEST_PROTOCOL
)
2516 *protocol_interface
= NULL
;
2519 * Check if the protocol is already opened by a driver with the same
2520 * attributes or opened exclusively
2522 list_for_each_entry(item
, &handler
->open_infos
, link
) {
2523 if (item
->info
.agent_handle
== agent_handle
) {
2524 if ((attributes
& EFI_OPEN_PROTOCOL_BY_DRIVER
) &&
2525 (item
->info
.attributes
== attributes
))
2526 return EFI_ALREADY_STARTED
;
2528 if (item
->info
.attributes
& EFI_OPEN_PROTOCOL_EXCLUSIVE
)
2529 opened_exclusive
= true;
2532 /* Only one controller can open the protocol exclusively */
2533 if (opened_exclusive
&& attributes
&
2534 (EFI_OPEN_PROTOCOL_EXCLUSIVE
| EFI_OPEN_PROTOCOL_BY_DRIVER
))
2535 return EFI_ACCESS_DENIED
;
2537 /* Prepare exclusive opening */
2538 if (attributes
& EFI_OPEN_PROTOCOL_EXCLUSIVE
) {
2539 /* Try to disconnect controllers */
2540 list_for_each_entry(item
, &handler
->open_infos
, link
) {
2541 if (item
->info
.attributes
==
2542 EFI_OPEN_PROTOCOL_BY_DRIVER
)
2543 EFI_CALL(efi_disconnect_controller(
2544 item
->info
.controller_handle
,
2545 item
->info
.agent_handle
,
2548 opened_by_driver
= false;
2549 /* Check if all controllers are disconnected */
2550 list_for_each_entry(item
, &handler
->open_infos
, link
) {
2551 if (item
->info
.attributes
& EFI_OPEN_PROTOCOL_BY_DRIVER
)
2552 opened_by_driver
= true;
2554 /* Only one controller can be connected */
2555 if (opened_by_driver
)
2556 return EFI_ACCESS_DENIED
;
2559 /* Find existing entry */
2560 list_for_each_entry(item
, &handler
->open_infos
, link
) {
2561 if (item
->info
.agent_handle
== agent_handle
&&
2562 item
->info
.controller_handle
== controller_handle
)
2563 match
= &item
->info
;
2565 /* None found, create one */
2567 match
= efi_create_open_info(handler
);
2569 return EFI_OUT_OF_RESOURCES
;
2572 match
->agent_handle
= agent_handle
;
2573 match
->controller_handle
= controller_handle
;
2574 match
->attributes
= attributes
;
2575 match
->open_count
++;
2578 /* For TEST_PROTOCOL ignore interface attribute. */
2579 if (attributes
!= EFI_OPEN_PROTOCOL_TEST_PROTOCOL
)
2580 *protocol_interface
= handler
->protocol_interface
;
2586 * efi_open_protocol() - open protocol interface on a handle
2587 * @handle: handle on which the protocol shall be opened
2588 * @protocol: GUID of the protocol
2589 * @protocol_interface: interface implementing the protocol
2590 * @agent_handle: handle of the driver
2591 * @controller_handle: handle of the controller
2592 * @attributes: attributes indicating how to open the protocol
2594 * This function implements the OpenProtocol interface.
2596 * See the Unified Extensible Firmware Interface (UEFI) specification for
2599 * Return: status code
2601 static efi_status_t EFIAPI efi_open_protocol
2602 (efi_handle_t handle
, const efi_guid_t
*protocol
,
2603 void **protocol_interface
, efi_handle_t agent_handle
,
2604 efi_handle_t controller_handle
, uint32_t attributes
)
2606 struct efi_handler
*handler
;
2607 efi_status_t r
= EFI_INVALID_PARAMETER
;
2609 EFI_ENTRY("%p, %pUl, %p, %p, %p, 0x%x", handle
, protocol
,
2610 protocol_interface
, agent_handle
, controller_handle
,
2613 if (!handle
|| !protocol
||
2614 (!protocol_interface
&& attributes
!=
2615 EFI_OPEN_PROTOCOL_TEST_PROTOCOL
)) {
2619 switch (attributes
) {
2620 case EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL
:
2621 case EFI_OPEN_PROTOCOL_GET_PROTOCOL
:
2622 case EFI_OPEN_PROTOCOL_TEST_PROTOCOL
:
2624 case EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
:
2625 if (controller_handle
== handle
)
2628 case EFI_OPEN_PROTOCOL_BY_DRIVER
:
2629 case EFI_OPEN_PROTOCOL_BY_DRIVER
| EFI_OPEN_PROTOCOL_EXCLUSIVE
:
2630 /* Check that the controller handle is valid */
2631 if (!efi_search_obj(controller_handle
))
2634 case EFI_OPEN_PROTOCOL_EXCLUSIVE
:
2635 /* Check that the agent handle is valid */
2636 if (!efi_search_obj(agent_handle
))
2643 r
= efi_search_protocol(handle
, protocol
, &handler
);
2648 r
= EFI_UNSUPPORTED
;
2654 r
= efi_protocol_open(handler
, protocol_interface
, agent_handle
,
2655 controller_handle
, attributes
);
2661 * efi_start_image() - call the entry point of an image
2662 * @image_handle: handle of the image
2663 * @exit_data_size: size of the buffer
2664 * @exit_data: buffer to receive the exit data of the called image
2666 * This function implements the StartImage service.
2668 * See the Unified Extensible Firmware Interface (UEFI) specification for
2671 * Return: status code
2673 efi_status_t EFIAPI
efi_start_image(efi_handle_t image_handle
,
2674 efi_uintn_t
*exit_data_size
,
2677 struct efi_loaded_image_obj
*image_obj
=
2678 (struct efi_loaded_image_obj
*)image_handle
;
2681 efi_handle_t parent_image
= current_image
;
2683 EFI_ENTRY("%p, %p, %p", image_handle
, exit_data_size
, exit_data
);
2685 /* Check parameters */
2686 ret
= EFI_CALL(efi_open_protocol(image_handle
, &efi_guid_loaded_image
,
2688 EFI_OPEN_PROTOCOL_GET_PROTOCOL
));
2689 if (ret
!= EFI_SUCCESS
)
2690 return EFI_EXIT(EFI_INVALID_PARAMETER
);
2692 efi_is_direct_boot
= false;
2694 image_obj
->exit_data_size
= exit_data_size
;
2695 image_obj
->exit_data
= exit_data
;
2697 /* call the image! */
2698 if (setjmp(&image_obj
->exit_jmp
)) {
2700 * We called the entry point of the child image with EFI_CALL
2701 * in the lines below. The child image called the Exit() boot
2702 * service efi_exit() which executed the long jump that brought
2703 * us to the current line. This implies that the second half
2704 * of the EFI_CALL macro has not been executed.
2708 * efi_exit() called efi_restore_gd(). We have to undo this
2709 * otherwise __efi_entry_check() will put the wrong value into
2715 * To get ready to call EFI_EXIT below we have to execute the
2716 * missed out steps of EFI_CALL.
2718 assert(__efi_entry_check());
2719 EFI_PRINT("%lu returned by started image\n",
2720 (unsigned long)((uintptr_t)image_obj
->exit_status
&
2722 current_image
= parent_image
;
2723 return EFI_EXIT(image_obj
->exit_status
);
2726 current_image
= image_handle
;
2727 image_obj
->header
.type
= EFI_OBJECT_TYPE_STARTED_IMAGE
;
2728 EFI_PRINT("Jumping into 0x%p\n", image_obj
->entry
);
2729 ret
= EFI_CALL(image_obj
->entry(image_handle
, &systab
));
2732 * Usually UEFI applications call Exit() instead of returning.
2733 * But because the world doesn't consist of ponies and unicorns,
2734 * we're happy to emulate that behavior on behalf of a payload
2737 return EFI_CALL(systab
.boottime
->exit(image_handle
, ret
, 0, NULL
));
2741 * efi_delete_image() - delete loaded image from memory)
2743 * @image_obj: handle of the loaded image
2744 * @loaded_image_protocol: loaded image protocol
2746 static void efi_delete_image(struct efi_loaded_image_obj
*image_obj
,
2747 struct efi_loaded_image
*loaded_image_protocol
)
2749 efi_free_pages((uintptr_t)loaded_image_protocol
->image_base
,
2750 efi_size_in_pages(loaded_image_protocol
->image_size
));
2751 efi_delete_handle(&image_obj
->header
);
2755 * efi_unload_image() - unload an EFI image
2756 * @image_handle: handle of the image to be unloaded
2758 * This function implements the UnloadImage service.
2760 * See the Unified Extensible Firmware Interface (UEFI) specification for
2763 * Return: status code
2765 efi_status_t EFIAPI
efi_unload_image(efi_handle_t image_handle
)
2767 efi_status_t ret
= EFI_SUCCESS
;
2768 struct efi_object
*efiobj
;
2769 struct efi_loaded_image
*loaded_image_protocol
;
2771 EFI_ENTRY("%p", image_handle
);
2773 efiobj
= efi_search_obj(image_handle
);
2775 ret
= EFI_INVALID_PARAMETER
;
2778 /* Find the loaded image protocol */
2779 ret
= EFI_CALL(efi_open_protocol(image_handle
, &efi_guid_loaded_image
,
2780 (void **)&loaded_image_protocol
,
2782 EFI_OPEN_PROTOCOL_GET_PROTOCOL
));
2783 if (ret
!= EFI_SUCCESS
) {
2784 ret
= EFI_INVALID_PARAMETER
;
2787 switch (efiobj
->type
) {
2788 case EFI_OBJECT_TYPE_STARTED_IMAGE
:
2789 /* Call the unload function */
2790 if (!loaded_image_protocol
->unload
) {
2791 ret
= EFI_UNSUPPORTED
;
2794 ret
= EFI_CALL(loaded_image_protocol
->unload(image_handle
));
2795 if (ret
!= EFI_SUCCESS
)
2798 case EFI_OBJECT_TYPE_LOADED_IMAGE
:
2801 ret
= EFI_INVALID_PARAMETER
;
2804 efi_delete_image((struct efi_loaded_image_obj
*)efiobj
,
2805 loaded_image_protocol
);
2807 return EFI_EXIT(ret
);
2811 * efi_update_exit_data() - fill exit data parameters of StartImage()
2813 * @image_obj image handle
2814 * @exit_data_size size of the exit data buffer
2815 * @exit_data buffer with data returned by UEFI payload
2816 * Return: status code
2818 static efi_status_t
efi_update_exit_data(struct efi_loaded_image_obj
*image_obj
,
2819 efi_uintn_t exit_data_size
,
2825 * If exit_data is not provided to StartImage(), exit_data_size must be
2828 if (!image_obj
->exit_data
)
2830 if (image_obj
->exit_data_size
)
2831 *image_obj
->exit_data_size
= exit_data_size
;
2832 if (exit_data_size
&& exit_data
) {
2833 ret
= efi_allocate_pool(EFI_BOOT_SERVICES_DATA
,
2835 (void **)image_obj
->exit_data
);
2836 if (ret
!= EFI_SUCCESS
)
2838 memcpy(*image_obj
->exit_data
, exit_data
, exit_data_size
);
2840 image_obj
->exit_data
= NULL
;
2846 * efi_exit() - leave an EFI application or driver
2847 * @image_handle: handle of the application or driver that is exiting
2848 * @exit_status: status code
2849 * @exit_data_size: size of the buffer in bytes
2850 * @exit_data: buffer with data describing an error
2852 * This function implements the Exit service.
2854 * See the Unified Extensible Firmware Interface (UEFI) specification for
2857 * Return: status code
2859 static efi_status_t EFIAPI
efi_exit(efi_handle_t image_handle
,
2860 efi_status_t exit_status
,
2861 efi_uintn_t exit_data_size
,
2865 * TODO: We should call the unload procedure of the loaded
2869 struct efi_loaded_image
*loaded_image_protocol
;
2870 struct efi_loaded_image_obj
*image_obj
=
2871 (struct efi_loaded_image_obj
*)image_handle
;
2873 EFI_ENTRY("%p, %ld, %zu, %p", image_handle
, exit_status
,
2874 exit_data_size
, exit_data
);
2876 /* Check parameters */
2877 ret
= EFI_CALL(efi_open_protocol(image_handle
, &efi_guid_loaded_image
,
2878 (void **)&loaded_image_protocol
,
2880 EFI_OPEN_PROTOCOL_GET_PROTOCOL
));
2881 if (ret
!= EFI_SUCCESS
) {
2882 ret
= EFI_INVALID_PARAMETER
;
2886 /* Unloading of unstarted images */
2887 switch (image_obj
->header
.type
) {
2888 case EFI_OBJECT_TYPE_STARTED_IMAGE
:
2890 case EFI_OBJECT_TYPE_LOADED_IMAGE
:
2891 efi_delete_image(image_obj
, loaded_image_protocol
);
2895 /* Handle does not refer to loaded image */
2896 ret
= EFI_INVALID_PARAMETER
;
2899 /* A started image can only be unloaded it is the last one started. */
2900 if (image_handle
!= current_image
) {
2901 ret
= EFI_INVALID_PARAMETER
;
2905 /* Exit data is only foreseen in case of failure. */
2906 if (exit_status
!= EFI_SUCCESS
) {
2907 ret
= efi_update_exit_data(image_obj
, exit_data_size
,
2909 /* Exiting has priority. Don't return error to caller. */
2910 if (ret
!= EFI_SUCCESS
)
2911 EFI_PRINT("%s: out of memory\n", __func__
);
2913 if (image_obj
->image_type
== IMAGE_SUBSYSTEM_EFI_APPLICATION
||
2914 exit_status
!= EFI_SUCCESS
)
2915 efi_delete_image(image_obj
, loaded_image_protocol
);
2917 /* Make sure entry/exit counts for EFI world cross-overs match */
2918 EFI_EXIT(exit_status
);
2921 * But longjmp out with the U-Boot gd, not the application's, as
2922 * the other end is a setjmp call inside EFI context.
2926 image_obj
->exit_status
= exit_status
;
2927 longjmp(&image_obj
->exit_jmp
, 1);
2929 panic("EFI application exited");
2931 return EFI_EXIT(ret
);
2935 * efi_handle_protocol() - get interface of a protocol on a handle
2936 * @handle: handle on which the protocol shall be opened
2937 * @protocol: GUID of the protocol
2938 * @protocol_interface: interface implementing the protocol
2940 * This function implements the HandleProtocol service.
2942 * See the Unified Extensible Firmware Interface (UEFI) specification for
2945 * Return: status code
2947 static efi_status_t EFIAPI
efi_handle_protocol(efi_handle_t handle
,
2948 const efi_guid_t
*protocol
,
2949 void **protocol_interface
)
2951 return efi_open_protocol(handle
, protocol
, protocol_interface
, NULL
,
2952 NULL
, EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL
);
2956 * efi_bind_controller() - bind a single driver to a controller
2957 * @controller_handle: controller handle
2958 * @driver_image_handle: driver handle
2959 * @remain_device_path: remaining path
2961 * Return: status code
2963 static efi_status_t
efi_bind_controller(
2964 efi_handle_t controller_handle
,
2965 efi_handle_t driver_image_handle
,
2966 struct efi_device_path
*remain_device_path
)
2968 struct efi_driver_binding_protocol
*binding_protocol
;
2971 r
= EFI_CALL(efi_open_protocol(driver_image_handle
,
2972 &efi_guid_driver_binding_protocol
,
2973 (void **)&binding_protocol
,
2974 driver_image_handle
, NULL
,
2975 EFI_OPEN_PROTOCOL_GET_PROTOCOL
));
2976 if (r
!= EFI_SUCCESS
)
2978 r
= EFI_CALL(binding_protocol
->supported(binding_protocol
,
2980 remain_device_path
));
2981 if (r
== EFI_SUCCESS
)
2982 r
= EFI_CALL(binding_protocol
->start(binding_protocol
,
2984 remain_device_path
));
2985 EFI_CALL(efi_close_protocol(driver_image_handle
,
2986 &efi_guid_driver_binding_protocol
,
2987 driver_image_handle
, NULL
));
2992 * efi_connect_single_controller() - connect a single driver to a controller
2993 * @controller_handle: controller
2994 * @driver_image_handle: driver
2995 * @remain_device_path: remaining path
2997 * Return: status code
2999 static efi_status_t
efi_connect_single_controller(
3000 efi_handle_t controller_handle
,
3001 efi_handle_t
*driver_image_handle
,
3002 struct efi_device_path
*remain_device_path
)
3004 efi_handle_t
*buffer
;
3008 size_t connected
= 0;
3010 /* Get buffer with all handles with driver binding protocol */
3011 r
= EFI_CALL(efi_locate_handle_buffer(BY_PROTOCOL
,
3012 &efi_guid_driver_binding_protocol
,
3013 NULL
, &count
, &buffer
));
3014 if (r
!= EFI_SUCCESS
)
3017 /* Context Override */
3018 if (driver_image_handle
) {
3019 for (; *driver_image_handle
; ++driver_image_handle
) {
3020 for (i
= 0; i
< count
; ++i
) {
3021 if (buffer
[i
] == *driver_image_handle
) {
3023 r
= efi_bind_controller(
3025 *driver_image_handle
,
3026 remain_device_path
);
3028 * For drivers that do not support the
3029 * controller or are already connected
3030 * we receive an error code here.
3032 if (r
== EFI_SUCCESS
)
3040 * TODO: Some overrides are not yet implemented:
3041 * - Platform Driver Override
3042 * - Driver Family Override Search
3043 * - Bus Specific Driver Override
3046 /* Driver Binding Search */
3047 for (i
= 0; i
< count
; ++i
) {
3049 r
= efi_bind_controller(controller_handle
,
3051 remain_device_path
);
3052 if (r
== EFI_SUCCESS
)
3057 efi_free_pool(buffer
);
3059 return EFI_NOT_FOUND
;
3064 * efi_connect_controller() - connect a controller to a driver
3065 * @controller_handle: handle of the controller
3066 * @driver_image_handle: handle of the driver
3067 * @remain_device_path: device path of a child controller
3068 * @recursive: true to connect all child controllers
3070 * This function implements the ConnectController service.
3072 * See the Unified Extensible Firmware Interface (UEFI) specification for
3075 * First all driver binding protocol handles are tried for binding drivers.
3076 * Afterwards all handles that have opened a protocol of the controller
3077 * with EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER are connected to drivers.
3079 * Return: status code
3081 static efi_status_t EFIAPI
efi_connect_controller(
3082 efi_handle_t controller_handle
,
3083 efi_handle_t
*driver_image_handle
,
3084 struct efi_device_path
*remain_device_path
,
3088 efi_status_t ret
= EFI_NOT_FOUND
;
3089 struct efi_object
*efiobj
;
3091 EFI_ENTRY("%p, %p, %pD, %d", controller_handle
, driver_image_handle
,
3092 remain_device_path
, recursive
);
3094 efiobj
= efi_search_obj(controller_handle
);
3096 ret
= EFI_INVALID_PARAMETER
;
3100 r
= efi_connect_single_controller(controller_handle
,
3101 driver_image_handle
,
3102 remain_device_path
);
3103 if (r
== EFI_SUCCESS
)
3106 struct efi_handler
*handler
;
3107 struct efi_open_protocol_info_item
*item
;
3109 list_for_each_entry(handler
, &efiobj
->protocols
, link
) {
3110 list_for_each_entry(item
, &handler
->open_infos
, link
) {
3111 if (item
->info
.attributes
&
3112 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) {
3113 r
= EFI_CALL(efi_connect_controller(
3114 item
->info
.controller_handle
,
3115 driver_image_handle
,
3118 if (r
== EFI_SUCCESS
)
3124 /* Check for child controller specified by end node */
3125 if (ret
!= EFI_SUCCESS
&& remain_device_path
&&
3126 remain_device_path
->type
== DEVICE_PATH_TYPE_END
)
3129 return EFI_EXIT(ret
);
3133 * efi_reinstall_protocol_interface() - reinstall protocol interface
3134 * @handle: handle on which the protocol shall be reinstalled
3135 * @protocol: GUID of the protocol to be installed
3136 * @old_interface: interface to be removed
3137 * @new_interface: interface to be installed
3139 * This function implements the ReinstallProtocolInterface service.
3141 * See the Unified Extensible Firmware Interface (UEFI) specification for
3144 * The old interface is uninstalled. The new interface is installed.
3145 * Drivers are connected.
3147 * Return: status code
3149 static efi_status_t EFIAPI
efi_reinstall_protocol_interface(
3150 efi_handle_t handle
, const efi_guid_t
*protocol
,
3151 void *old_interface
, void *new_interface
)
3155 EFI_ENTRY("%p, %pUl, %p, %p", handle
, protocol
, old_interface
,
3158 /* Uninstall protocol but do not delete handle */
3159 ret
= efi_uninstall_protocol(handle
, protocol
, old_interface
);
3160 if (ret
!= EFI_SUCCESS
)
3163 /* Install the new protocol */
3164 ret
= efi_add_protocol(handle
, protocol
, new_interface
);
3166 * The UEFI spec does not specify what should happen to the handle
3167 * if in case of an error no protocol interface remains on the handle.
3168 * So let's do nothing here.
3170 if (ret
!= EFI_SUCCESS
)
3173 * The returned status code has to be ignored.
3174 * Do not create an error if no suitable driver for the handle exists.
3176 EFI_CALL(efi_connect_controller(handle
, NULL
, NULL
, true));
3178 return EFI_EXIT(ret
);
3182 * efi_get_child_controllers() - get all child controllers associated to a driver
3183 * @efiobj: handle of the controller
3184 * @driver_handle: handle of the driver
3185 * @number_of_children: number of child controllers
3186 * @child_handle_buffer: handles of the the child controllers
3188 * The allocated buffer has to be freed with free().
3190 * Return: status code
3192 static efi_status_t
efi_get_child_controllers(
3193 struct efi_object
*efiobj
,
3194 efi_handle_t driver_handle
,
3195 efi_uintn_t
*number_of_children
,
3196 efi_handle_t
**child_handle_buffer
)
3198 struct efi_handler
*handler
;
3199 struct efi_open_protocol_info_item
*item
;
3200 efi_uintn_t count
= 0, i
;
3203 /* Count all child controller associations */
3204 list_for_each_entry(handler
, &efiobj
->protocols
, link
) {
3205 list_for_each_entry(item
, &handler
->open_infos
, link
) {
3206 if (item
->info
.agent_handle
== driver_handle
&&
3207 item
->info
.attributes
&
3208 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
)
3213 * Create buffer. In case of duplicate child controller assignments
3214 * the buffer will be too large. But that does not harm.
3216 *number_of_children
= 0;
3217 *child_handle_buffer
= calloc(count
, sizeof(efi_handle_t
));
3218 if (!*child_handle_buffer
)
3219 return EFI_OUT_OF_RESOURCES
;
3220 /* Copy unique child handles */
3221 list_for_each_entry(handler
, &efiobj
->protocols
, link
) {
3222 list_for_each_entry(item
, &handler
->open_infos
, link
) {
3223 if (item
->info
.agent_handle
== driver_handle
&&
3224 item
->info
.attributes
&
3225 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) {
3226 /* Check this is a new child controller */
3228 for (i
= 0; i
< *number_of_children
; ++i
) {
3229 if ((*child_handle_buffer
)[i
] ==
3230 item
->info
.controller_handle
)
3233 /* Copy handle to buffer */
3235 i
= (*number_of_children
)++;
3236 (*child_handle_buffer
)[i
] =
3237 item
->info
.controller_handle
;
3246 * efi_disconnect_controller() - disconnect a controller from a driver
3247 * @controller_handle: handle of the controller
3248 * @driver_image_handle: handle of the driver
3249 * @child_handle: handle of the child to destroy
3251 * This function implements the DisconnectController service.
3253 * See the Unified Extensible Firmware Interface (UEFI) specification for
3256 * Return: status code
3258 static efi_status_t EFIAPI
efi_disconnect_controller(
3259 efi_handle_t controller_handle
,
3260 efi_handle_t driver_image_handle
,
3261 efi_handle_t child_handle
)
3263 struct efi_driver_binding_protocol
*binding_protocol
;
3264 efi_handle_t
*child_handle_buffer
= NULL
;
3265 size_t number_of_children
= 0;
3267 size_t stop_count
= 0;
3268 struct efi_object
*efiobj
;
3270 EFI_ENTRY("%p, %p, %p", controller_handle
, driver_image_handle
,
3273 efiobj
= efi_search_obj(controller_handle
);
3275 r
= EFI_INVALID_PARAMETER
;
3279 if (child_handle
&& !efi_search_obj(child_handle
)) {
3280 r
= EFI_INVALID_PARAMETER
;
3284 /* If no driver handle is supplied, disconnect all drivers */
3285 if (!driver_image_handle
) {
3286 r
= efi_disconnect_all_drivers(efiobj
, NULL
, child_handle
);
3290 /* Create list of child handles */
3292 number_of_children
= 1;
3293 child_handle_buffer
= &child_handle
;
3295 efi_get_child_controllers(efiobj
,
3296 driver_image_handle
,
3297 &number_of_children
,
3298 &child_handle_buffer
);
3301 /* Get the driver binding protocol */
3302 r
= EFI_CALL(efi_open_protocol(driver_image_handle
,
3303 &efi_guid_driver_binding_protocol
,
3304 (void **)&binding_protocol
,
3305 driver_image_handle
, NULL
,
3306 EFI_OPEN_PROTOCOL_GET_PROTOCOL
));
3307 if (r
!= EFI_SUCCESS
)
3309 /* Remove the children */
3310 if (number_of_children
) {
3311 r
= EFI_CALL(binding_protocol
->stop(binding_protocol
,
3314 child_handle_buffer
));
3315 if (r
== EFI_SUCCESS
)
3318 /* Remove the driver */
3320 r
= EFI_CALL(binding_protocol
->stop(binding_protocol
,
3323 if (r
== EFI_SUCCESS
)
3325 EFI_CALL(efi_close_protocol(driver_image_handle
,
3326 &efi_guid_driver_binding_protocol
,
3327 driver_image_handle
, NULL
));
3335 free(child_handle_buffer
);
3339 static struct efi_boot_services efi_boot_services
= {
3341 .signature
= EFI_BOOT_SERVICES_SIGNATURE
,
3342 .revision
= EFI_SPECIFICATION_VERSION
,
3343 .headersize
= sizeof(struct efi_boot_services
),
3345 .raise_tpl
= efi_raise_tpl
,
3346 .restore_tpl
= efi_restore_tpl
,
3347 .allocate_pages
= efi_allocate_pages_ext
,
3348 .free_pages
= efi_free_pages_ext
,
3349 .get_memory_map
= efi_get_memory_map_ext
,
3350 .allocate_pool
= efi_allocate_pool_ext
,
3351 .free_pool
= efi_free_pool_ext
,
3352 .create_event
= efi_create_event_ext
,
3353 .set_timer
= efi_set_timer_ext
,
3354 .wait_for_event
= efi_wait_for_event
,
3355 .signal_event
= efi_signal_event_ext
,
3356 .close_event
= efi_close_event
,
3357 .check_event
= efi_check_event
,
3358 .install_protocol_interface
= efi_install_protocol_interface
,
3359 .reinstall_protocol_interface
= efi_reinstall_protocol_interface
,
3360 .uninstall_protocol_interface
= efi_uninstall_protocol_interface
,
3361 .handle_protocol
= efi_handle_protocol
,
3363 .register_protocol_notify
= efi_register_protocol_notify
,
3364 .locate_handle
= efi_locate_handle_ext
,
3365 .locate_device_path
= efi_locate_device_path
,
3366 .install_configuration_table
= efi_install_configuration_table_ext
,
3367 .load_image
= efi_load_image
,
3368 .start_image
= efi_start_image
,
3370 .unload_image
= efi_unload_image
,
3371 .exit_boot_services
= efi_exit_boot_services
,
3372 .get_next_monotonic_count
= efi_get_next_monotonic_count
,
3374 .set_watchdog_timer
= efi_set_watchdog_timer
,
3375 .connect_controller
= efi_connect_controller
,
3376 .disconnect_controller
= efi_disconnect_controller
,
3377 .open_protocol
= efi_open_protocol
,
3378 .close_protocol
= efi_close_protocol
,
3379 .open_protocol_information
= efi_open_protocol_information
,
3380 .protocols_per_handle
= efi_protocols_per_handle
,
3381 .locate_handle_buffer
= efi_locate_handle_buffer
,
3382 .locate_protocol
= efi_locate_protocol
,
3383 .install_multiple_protocol_interfaces
=
3384 efi_install_multiple_protocol_interfaces
,
3385 .uninstall_multiple_protocol_interfaces
=
3386 efi_uninstall_multiple_protocol_interfaces
,
3387 .calculate_crc32
= efi_calculate_crc32
,
3388 .copy_mem
= efi_copy_mem
,
3389 .set_mem
= efi_set_mem
,
3390 .create_event_ex
= efi_create_event_ex
,
3393 static u16 __efi_runtime_data firmware_vendor
[] = L
"Das U-Boot";
3395 struct efi_system_table __efi_runtime_data systab
= {
3397 .signature
= EFI_SYSTEM_TABLE_SIGNATURE
,
3398 .revision
= EFI_SPECIFICATION_VERSION
,
3399 .headersize
= sizeof(struct efi_system_table
),
3401 .fw_vendor
= firmware_vendor
,
3402 .fw_revision
= FW_VERSION
<< 16 | FW_PATCHLEVEL
<< 8,
3403 .con_in
= (void *)&efi_con_in
,
3404 .con_out
= (void *)&efi_con_out
,
3405 .std_err
= (void *)&efi_con_out
,
3406 .runtime
= (void *)&efi_runtime_services
,
3407 .boottime
= (void *)&efi_boot_services
,
3413 * efi_initialize_system_table() - Initialize system table
3415 * Return: status code
3417 efi_status_t
efi_initialize_system_table(void)
3421 /* Allocate configuration table array */
3422 ret
= efi_allocate_pool(EFI_RUNTIME_SERVICES_DATA
,
3423 EFI_MAX_CONFIGURATION_TABLES
*
3424 sizeof(struct efi_configuration_table
),
3425 (void **)&systab
.tables
);
3427 /* Set CRC32 field in table headers */
3428 efi_update_table_header_crc32(&systab
.hdr
);
3429 efi_update_table_header_crc32(&efi_runtime_services
.hdr
);
3430 efi_update_table_header_crc32(&efi_boot_services
.hdr
);