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>
18 DECLARE_GLOBAL_DATA_PTR
;
20 /* Task priority level */
21 static efi_uintn_t efi_tpl
= TPL_APPLICATION
;
23 /* This list contains all the EFI objects our payload has access to */
24 LIST_HEAD(efi_obj_list
);
26 /* List of all events */
27 LIST_HEAD(efi_events
);
31 * The "gd" pointer lives in a register on ARM and AArch64 that we declare
32 * fixed when compiling U-Boot. However, the payload does not know about that
33 * restriction so we need to manually swap its and our view of that register on
34 * EFI callback entry/exit.
36 static volatile void *efi_gd
, *app_gd
;
39 static int entry_count
;
40 static int nesting_level
;
41 /* GUID of the device tree table */
42 const efi_guid_t efi_guid_fdt
= EFI_FDT_GUID
;
43 /* GUID of the EFI_DRIVER_BINDING_PROTOCOL */
44 const efi_guid_t efi_guid_driver_binding_protocol
=
45 EFI_DRIVER_BINDING_PROTOCOL_GUID
;
47 /* event group ExitBootServices() invoked */
48 const efi_guid_t efi_guid_event_group_exit_boot_services
=
49 EFI_EVENT_GROUP_EXIT_BOOT_SERVICES
;
50 /* event group SetVirtualAddressMap() invoked */
51 const efi_guid_t efi_guid_event_group_virtual_address_change
=
52 EFI_EVENT_GROUP_VIRTUAL_ADDRESS_CHANGE
;
53 /* event group memory map changed */
54 const efi_guid_t efi_guid_event_group_memory_map_change
=
55 EFI_EVENT_GROUP_MEMORY_MAP_CHANGE
;
56 /* event group boot manager about to boot */
57 const efi_guid_t efi_guid_event_group_ready_to_boot
=
58 EFI_EVENT_GROUP_READY_TO_BOOT
;
59 /* event group ResetSystem() invoked (before ExitBootServices) */
60 const efi_guid_t efi_guid_event_group_reset_system
=
61 EFI_EVENT_GROUP_RESET_SYSTEM
;
63 static efi_status_t EFIAPI
efi_disconnect_controller(
64 efi_handle_t controller_handle
,
65 efi_handle_t driver_image_handle
,
66 efi_handle_t child_handle
);
68 /* Called on every callback entry */
69 int __efi_entry_check(void)
71 int ret
= entry_count
++ == 0;
80 /* Called on every callback exit */
81 int __efi_exit_check(void)
83 int ret
= --entry_count
== 0;
90 /* Called from do_bootefi_exec() */
91 void efi_save_gd(void)
99 * Special case handler for error/abort that just forces things back to u-boot
100 * world so we can dump out an abort message, without any care about returning
101 * back to UEFI world.
103 void efi_restore_gd(void)
106 /* Only restore if we're already in EFI context */
114 * indent_string() - returns a string for indenting with two spaces per level
115 * @level: indent level
117 * A maximum of ten indent levels is supported. Higher indent levels will be
120 * Return: A string for indenting with two spaces per level is
123 static const char *indent_string(int level
)
125 const char *indent
= " ";
126 const int max
= strlen(indent
);
128 level
= min(max
, level
* 2);
129 return &indent
[max
- level
];
132 const char *__efi_nesting(void)
134 return indent_string(nesting_level
);
137 const char *__efi_nesting_inc(void)
139 return indent_string(nesting_level
++);
142 const char *__efi_nesting_dec(void)
144 return indent_string(--nesting_level
);
148 * efi_queue_event() - queue an EFI event
149 * @event: event to signal
150 * @check_tpl: check the TPL level
152 * This function queues the notification function of the event for future
155 * The notification function is called if the task priority level of the event
156 * is higher than the current task priority level.
158 * For the SignalEvent service see efi_signal_event_ext.
161 static void efi_queue_event(struct efi_event
*event
, bool check_tpl
)
163 if (event
->notify_function
) {
164 event
->is_queued
= true;
166 if (check_tpl
&& efi_tpl
>= event
->notify_tpl
)
168 EFI_CALL_VOID(event
->notify_function(event
,
169 event
->notify_context
));
171 event
->is_queued
= false;
175 * is_valid_tpl() - check if the task priority level is valid
177 * @tpl: TPL level to check
178 * Return: status code
180 efi_status_t
is_valid_tpl(efi_uintn_t tpl
)
183 case TPL_APPLICATION
:
189 return EFI_INVALID_PARAMETER
;
194 * efi_signal_event() - signal an EFI event
195 * @event: event to signal
196 * @check_tpl: check the TPL level
198 * This function signals an event. If the event belongs to an event group all
199 * events of the group are signaled. If they are of type EVT_NOTIFY_SIGNAL
200 * their notification function is queued.
202 * For the SignalEvent service see efi_signal_event_ext.
204 void efi_signal_event(struct efi_event
*event
, bool check_tpl
)
207 struct efi_event
*evt
;
210 * The signaled state has to set before executing any
211 * notification function
213 list_for_each_entry(evt
, &efi_events
, link
) {
214 if (!evt
->group
|| guidcmp(evt
->group
, event
->group
))
216 if (evt
->is_signaled
)
218 evt
->is_signaled
= true;
219 if (evt
->type
& EVT_NOTIFY_SIGNAL
&&
220 evt
->notify_function
)
221 evt
->is_queued
= true;
223 list_for_each_entry(evt
, &efi_events
, link
) {
224 if (!evt
->group
|| guidcmp(evt
->group
, event
->group
))
227 efi_queue_event(evt
, check_tpl
);
229 } else if (!event
->is_signaled
) {
230 event
->is_signaled
= true;
231 if (event
->type
& EVT_NOTIFY_SIGNAL
)
232 efi_queue_event(event
, check_tpl
);
237 * efi_raise_tpl() - raise the task priority level
238 * @new_tpl: new value of the task priority level
240 * This function implements the RaiseTpl service.
242 * See the Unified Extensible Firmware Interface (UEFI) specification for
245 * Return: old value of the task priority level
247 static unsigned long EFIAPI
efi_raise_tpl(efi_uintn_t new_tpl
)
249 efi_uintn_t old_tpl
= efi_tpl
;
251 EFI_ENTRY("0x%zx", new_tpl
);
253 if (new_tpl
< efi_tpl
)
254 debug("WARNING: new_tpl < current_tpl in %s\n", __func__
);
256 if (efi_tpl
> TPL_HIGH_LEVEL
)
257 efi_tpl
= TPL_HIGH_LEVEL
;
259 EFI_EXIT(EFI_SUCCESS
);
264 * efi_restore_tpl() - lower the task priority level
265 * @old_tpl: value of the task priority level to be restored
267 * This function implements the RestoreTpl service.
269 * See the Unified Extensible Firmware Interface (UEFI) specification for
272 static void EFIAPI
efi_restore_tpl(efi_uintn_t old_tpl
)
274 EFI_ENTRY("0x%zx", old_tpl
);
276 if (old_tpl
> efi_tpl
)
277 debug("WARNING: old_tpl > current_tpl in %s\n", __func__
);
279 if (efi_tpl
> TPL_HIGH_LEVEL
)
280 efi_tpl
= TPL_HIGH_LEVEL
;
283 * Lowering the TPL may have made queued events eligible for execution.
287 EFI_EXIT(EFI_SUCCESS
);
291 * efi_allocate_pages_ext() - allocate memory pages
292 * @type: type of allocation to be performed
293 * @memory_type: usage type of the allocated memory
294 * @pages: number of pages to be allocated
295 * @memory: allocated memory
297 * This function implements the AllocatePages service.
299 * See the Unified Extensible Firmware Interface (UEFI) specification for
302 * Return: status code
304 static efi_status_t EFIAPI
efi_allocate_pages_ext(int type
, int memory_type
,
310 EFI_ENTRY("%d, %d, 0x%zx, %p", type
, memory_type
, pages
, memory
);
311 r
= efi_allocate_pages(type
, memory_type
, pages
, memory
);
316 * efi_free_pages_ext() - Free memory pages.
317 * @memory: start of the memory area to be freed
318 * @pages: number of pages to be freed
320 * This function implements the FreePages service.
322 * See the Unified Extensible Firmware Interface (UEFI) specification for
325 * Return: status code
327 static efi_status_t EFIAPI
efi_free_pages_ext(uint64_t memory
,
332 EFI_ENTRY("%llx, 0x%zx", memory
, pages
);
333 r
= efi_free_pages(memory
, pages
);
338 * efi_get_memory_map_ext() - get map describing memory usage
339 * @memory_map_size: on entry the size, in bytes, of the memory map buffer,
340 * on exit the size of the copied memory map
341 * @memory_map: buffer to which the memory map is written
342 * @map_key: key for the memory map
343 * @descriptor_size: size of an individual memory descriptor
344 * @descriptor_version: version number of the memory descriptor structure
346 * This function implements the GetMemoryMap service.
348 * See the Unified Extensible Firmware Interface (UEFI) specification for
351 * Return: status code
353 static efi_status_t EFIAPI
efi_get_memory_map_ext(
354 efi_uintn_t
*memory_map_size
,
355 struct efi_mem_desc
*memory_map
,
356 efi_uintn_t
*map_key
,
357 efi_uintn_t
*descriptor_size
,
358 uint32_t *descriptor_version
)
362 EFI_ENTRY("%p, %p, %p, %p, %p", memory_map_size
, memory_map
,
363 map_key
, descriptor_size
, descriptor_version
);
364 r
= efi_get_memory_map(memory_map_size
, memory_map
, map_key
,
365 descriptor_size
, descriptor_version
);
370 * efi_allocate_pool_ext() - allocate memory from pool
371 * @pool_type: type of the pool from which memory is to be allocated
372 * @size: number of bytes to be allocated
373 * @buffer: allocated memory
375 * This function implements the AllocatePool service.
377 * See the Unified Extensible Firmware Interface (UEFI) specification for
380 * Return: status code
382 static efi_status_t EFIAPI
efi_allocate_pool_ext(int pool_type
,
388 EFI_ENTRY("%d, %zd, %p", pool_type
, size
, buffer
);
389 r
= efi_allocate_pool(pool_type
, size
, buffer
);
394 * efi_free_pool_ext() - free memory from pool
395 * @buffer: start of memory to be freed
397 * This function implements the FreePool service.
399 * See the Unified Extensible Firmware Interface (UEFI) specification for
402 * Return: status code
404 static efi_status_t EFIAPI
efi_free_pool_ext(void *buffer
)
408 EFI_ENTRY("%p", buffer
);
409 r
= efi_free_pool(buffer
);
414 * efi_add_handle() - add a new object to the object list
415 * @obj: object to be added
417 * The protocols list is initialized. The object handle is set.
419 void efi_add_handle(struct efi_object
*obj
)
423 INIT_LIST_HEAD(&obj
->protocols
);
425 list_add_tail(&obj
->link
, &efi_obj_list
);
429 * efi_create_handle() - create handle
430 * @handle: new handle
432 * Return: status code
434 efi_status_t
efi_create_handle(efi_handle_t
*handle
)
436 struct efi_object
*obj
;
438 obj
= calloc(1, sizeof(struct efi_object
));
440 return EFI_OUT_OF_RESOURCES
;
443 *handle
= obj
->handle
;
449 * efi_search_protocol() - find a protocol on a handle.
451 * @protocol_guid: GUID of the protocol
452 * @handler: reference to the protocol
454 * Return: status code
456 efi_status_t
efi_search_protocol(const efi_handle_t handle
,
457 const efi_guid_t
*protocol_guid
,
458 struct efi_handler
**handler
)
460 struct efi_object
*efiobj
;
461 struct list_head
*lhandle
;
463 if (!handle
|| !protocol_guid
)
464 return EFI_INVALID_PARAMETER
;
465 efiobj
= efi_search_obj(handle
);
467 return EFI_INVALID_PARAMETER
;
468 list_for_each(lhandle
, &efiobj
->protocols
) {
469 struct efi_handler
*protocol
;
471 protocol
= list_entry(lhandle
, struct efi_handler
, link
);
472 if (!guidcmp(protocol
->guid
, protocol_guid
)) {
478 return EFI_NOT_FOUND
;
482 * efi_remove_protocol() - delete protocol from a handle
483 * @handle: handle from which the protocol shall be deleted
484 * @protocol: GUID of the protocol to be deleted
485 * @protocol_interface: interface of the protocol implementation
487 * Return: status code
489 efi_status_t
efi_remove_protocol(const efi_handle_t handle
,
490 const efi_guid_t
*protocol
,
491 void *protocol_interface
)
493 struct efi_handler
*handler
;
496 ret
= efi_search_protocol(handle
, protocol
, &handler
);
497 if (ret
!= EFI_SUCCESS
)
499 if (guidcmp(handler
->guid
, protocol
))
500 return EFI_INVALID_PARAMETER
;
501 if (handler
->protocol_interface
!= protocol_interface
)
502 return EFI_INVALID_PARAMETER
;
503 list_del(&handler
->link
);
509 * efi_remove_all_protocols() - delete all protocols from a handle
510 * @handle: handle from which the protocols shall be deleted
512 * Return: status code
514 efi_status_t
efi_remove_all_protocols(const efi_handle_t handle
)
516 struct efi_object
*efiobj
;
517 struct efi_handler
*protocol
;
518 struct efi_handler
*pos
;
520 efiobj
= efi_search_obj(handle
);
522 return EFI_INVALID_PARAMETER
;
523 list_for_each_entry_safe(protocol
, pos
, &efiobj
->protocols
, link
) {
526 ret
= efi_remove_protocol(handle
, protocol
->guid
,
527 protocol
->protocol_interface
);
528 if (ret
!= EFI_SUCCESS
)
535 * efi_delete_handle() - delete handle
537 * @obj: handle to delete
539 void efi_delete_handle(struct efi_object
*obj
)
543 efi_remove_all_protocols(obj
->handle
);
544 list_del(&obj
->link
);
549 * efi_is_event() - check if a pointer is a valid event
550 * @event: pointer to check
552 * Return: status code
554 static efi_status_t
efi_is_event(const struct efi_event
*event
)
556 const struct efi_event
*evt
;
559 return EFI_INVALID_PARAMETER
;
560 list_for_each_entry(evt
, &efi_events
, link
) {
564 return EFI_INVALID_PARAMETER
;
568 * efi_create_event() - create an event
569 * @type: type of the event to create
570 * @notify_tpl: task priority level of the event
571 * @notify_function: notification function of the event
572 * @notify_context: pointer passed to the notification function
573 * @group: event group
574 * @event: created event
576 * This function is used inside U-Boot code to create an event.
578 * For the API function implementing the CreateEvent service see
579 * efi_create_event_ext.
581 * Return: status code
583 efi_status_t
efi_create_event(uint32_t type
, efi_uintn_t notify_tpl
,
584 void (EFIAPI
*notify_function
) (
585 struct efi_event
*event
,
587 void *notify_context
, efi_guid_t
*group
,
588 struct efi_event
**event
)
590 struct efi_event
*evt
;
593 return EFI_INVALID_PARAMETER
;
598 case EVT_NOTIFY_SIGNAL
:
599 case EVT_TIMER
| EVT_NOTIFY_SIGNAL
:
600 case EVT_NOTIFY_WAIT
:
601 case EVT_TIMER
| EVT_NOTIFY_WAIT
:
602 case EVT_SIGNAL_EXIT_BOOT_SERVICES
:
603 case EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE
:
606 return EFI_INVALID_PARAMETER
;
609 if ((type
& (EVT_NOTIFY_WAIT
| EVT_NOTIFY_SIGNAL
)) &&
610 (is_valid_tpl(notify_tpl
) != EFI_SUCCESS
))
611 return EFI_INVALID_PARAMETER
;
613 evt
= calloc(1, sizeof(struct efi_event
));
615 return EFI_OUT_OF_RESOURCES
;
617 evt
->notify_tpl
= notify_tpl
;
618 evt
->notify_function
= notify_function
;
619 evt
->notify_context
= notify_context
;
621 /* Disable timers on boot up */
622 evt
->trigger_next
= -1ULL;
623 evt
->is_queued
= false;
624 evt
->is_signaled
= false;
625 list_add_tail(&evt
->link
, &efi_events
);
631 * efi_create_event_ex() - create an event in a group
632 * @type: type of the event to create
633 * @notify_tpl: task priority level of the event
634 * @notify_function: notification function of the event
635 * @notify_context: pointer passed to the notification function
636 * @event: created event
637 * @event_group: event group
639 * This function implements the CreateEventEx service.
641 * See the Unified Extensible Firmware Interface (UEFI) specification for
644 * Return: status code
646 efi_status_t EFIAPI
efi_create_event_ex(uint32_t type
, efi_uintn_t notify_tpl
,
647 void (EFIAPI
*notify_function
) (
648 struct efi_event
*event
,
650 void *notify_context
,
651 efi_guid_t
*event_group
,
652 struct efi_event
**event
)
654 EFI_ENTRY("%d, 0x%zx, %p, %p, %pUl", type
, notify_tpl
, notify_function
,
655 notify_context
, event_group
);
656 return EFI_EXIT(efi_create_event(type
, notify_tpl
, notify_function
,
657 notify_context
, event_group
, event
));
661 * efi_create_event_ext() - create an event
662 * @type: type of the event to create
663 * @notify_tpl: task priority level of the event
664 * @notify_function: notification function of the event
665 * @notify_context: pointer passed to the notification function
666 * @event: created event
668 * This function implements the CreateEvent service.
670 * See the Unified Extensible Firmware Interface (UEFI) specification for
673 * Return: status code
675 static efi_status_t EFIAPI
efi_create_event_ext(
676 uint32_t type
, efi_uintn_t notify_tpl
,
677 void (EFIAPI
*notify_function
) (
678 struct efi_event
*event
,
680 void *notify_context
, struct efi_event
**event
)
682 EFI_ENTRY("%d, 0x%zx, %p, %p", type
, notify_tpl
, notify_function
,
684 return EFI_EXIT(efi_create_event(type
, notify_tpl
, notify_function
,
685 notify_context
, NULL
, event
));
689 * efi_timer_check() - check if a timer event has occurred
691 * Check if a timer event has occurred or a queued notification function should
694 * Our timers have to work without interrupts, so we check whenever keyboard
695 * input or disk accesses happen if enough time elapsed for them to fire.
697 void efi_timer_check(void)
699 struct efi_event
*evt
;
700 u64 now
= timer_get_us();
702 list_for_each_entry(evt
, &efi_events
, link
) {
704 efi_queue_event(evt
, true);
705 if (!(evt
->type
& EVT_TIMER
) || now
< evt
->trigger_next
)
707 switch (evt
->trigger_type
) {
708 case EFI_TIMER_RELATIVE
:
709 evt
->trigger_type
= EFI_TIMER_STOP
;
711 case EFI_TIMER_PERIODIC
:
712 evt
->trigger_next
+= evt
->trigger_time
;
717 evt
->is_signaled
= false;
718 efi_signal_event(evt
, true);
724 * efi_set_timer() - set the trigger time for a timer event or stop the event
725 * @event: event for which the timer is set
726 * @type: type of the timer
727 * @trigger_time: trigger period in multiples of 100 ns
729 * This is the function for internal usage in U-Boot. For the API function
730 * implementing the SetTimer service see efi_set_timer_ext.
732 * Return: status code
734 efi_status_t
efi_set_timer(struct efi_event
*event
, enum efi_timer_delay type
,
735 uint64_t trigger_time
)
737 /* Check that the event is valid */
738 if (efi_is_event(event
) != EFI_SUCCESS
|| !(event
->type
& EVT_TIMER
))
739 return EFI_INVALID_PARAMETER
;
742 * The parameter defines a multiple of 100 ns.
743 * We use multiples of 1000 ns. So divide by 10.
745 do_div(trigger_time
, 10);
749 event
->trigger_next
= -1ULL;
751 case EFI_TIMER_PERIODIC
:
752 case EFI_TIMER_RELATIVE
:
753 event
->trigger_next
= timer_get_us() + trigger_time
;
756 return EFI_INVALID_PARAMETER
;
758 event
->trigger_type
= type
;
759 event
->trigger_time
= trigger_time
;
760 event
->is_signaled
= false;
765 * efi_set_timer_ext() - Set the trigger time for a timer event or stop the
767 * @event: event for which the timer is set
768 * @type: type of the timer
769 * @trigger_time: trigger period in multiples of 100 ns
771 * This function implements the SetTimer service.
773 * See the Unified Extensible Firmware Interface (UEFI) specification for
777 * Return: status code
779 static efi_status_t EFIAPI
efi_set_timer_ext(struct efi_event
*event
,
780 enum efi_timer_delay type
,
781 uint64_t trigger_time
)
783 EFI_ENTRY("%p, %d, %llx", event
, type
, trigger_time
);
784 return EFI_EXIT(efi_set_timer(event
, type
, trigger_time
));
788 * efi_wait_for_event() - wait for events to be signaled
789 * @num_events: number of events to be waited for
790 * @event: events to be waited for
791 * @index: index of the event that was signaled
793 * This function implements the WaitForEvent service.
795 * See the Unified Extensible Firmware Interface (UEFI) specification for
798 * Return: status code
800 static efi_status_t EFIAPI
efi_wait_for_event(efi_uintn_t num_events
,
801 struct efi_event
**event
,
806 EFI_ENTRY("%zd, %p, %p", num_events
, event
, index
);
808 /* Check parameters */
809 if (!num_events
|| !event
)
810 return EFI_EXIT(EFI_INVALID_PARAMETER
);
812 if (efi_tpl
!= TPL_APPLICATION
)
813 return EFI_EXIT(EFI_UNSUPPORTED
);
814 for (i
= 0; i
< num_events
; ++i
) {
815 if (efi_is_event(event
[i
]) != EFI_SUCCESS
)
816 return EFI_EXIT(EFI_INVALID_PARAMETER
);
817 if (!event
[i
]->type
|| event
[i
]->type
& EVT_NOTIFY_SIGNAL
)
818 return EFI_EXIT(EFI_INVALID_PARAMETER
);
819 if (!event
[i
]->is_signaled
)
820 efi_queue_event(event
[i
], true);
823 /* Wait for signal */
825 for (i
= 0; i
< num_events
; ++i
) {
826 if (event
[i
]->is_signaled
)
829 /* Allow events to occur. */
835 * Reset the signal which is passed to the caller to allow periodic
838 event
[i
]->is_signaled
= false;
842 return EFI_EXIT(EFI_SUCCESS
);
846 * efi_signal_event_ext() - signal an EFI event
847 * @event: event to signal
849 * This function implements the SignalEvent service.
851 * See the Unified Extensible Firmware Interface (UEFI) specification for
854 * This functions sets the signaled state of the event and queues the
855 * notification function for execution.
857 * Return: status code
859 static efi_status_t EFIAPI
efi_signal_event_ext(struct efi_event
*event
)
861 EFI_ENTRY("%p", event
);
862 if (efi_is_event(event
) != EFI_SUCCESS
)
863 return EFI_EXIT(EFI_INVALID_PARAMETER
);
864 efi_signal_event(event
, true);
865 return EFI_EXIT(EFI_SUCCESS
);
869 * efi_close_event() - close an EFI event
870 * @event: event to close
872 * This function implements the CloseEvent service.
874 * See the Unified Extensible Firmware Interface (UEFI) specification for
877 * Return: status code
879 static efi_status_t EFIAPI
efi_close_event(struct efi_event
*event
)
881 EFI_ENTRY("%p", event
);
882 if (efi_is_event(event
) != EFI_SUCCESS
)
883 return EFI_EXIT(EFI_INVALID_PARAMETER
);
884 list_del(&event
->link
);
886 return EFI_EXIT(EFI_SUCCESS
);
890 * efi_check_event() - check if an event is signaled
891 * @event: event to check
893 * This function implements the CheckEvent service.
895 * See the Unified Extensible Firmware Interface (UEFI) specification for
898 * If an event is not signaled yet, the notification function is queued. The
899 * signaled state is cleared.
901 * Return: status code
903 static efi_status_t EFIAPI
efi_check_event(struct efi_event
*event
)
905 EFI_ENTRY("%p", event
);
907 if (efi_is_event(event
) != EFI_SUCCESS
||
908 event
->type
& EVT_NOTIFY_SIGNAL
)
909 return EFI_EXIT(EFI_INVALID_PARAMETER
);
910 if (!event
->is_signaled
)
911 efi_queue_event(event
, true);
912 if (event
->is_signaled
) {
913 event
->is_signaled
= false;
914 return EFI_EXIT(EFI_SUCCESS
);
916 return EFI_EXIT(EFI_NOT_READY
);
920 * efi_search_obj() - find the internal EFI object for a handle
921 * @handle: handle to find
925 struct efi_object
*efi_search_obj(const efi_handle_t handle
)
927 struct efi_object
*efiobj
;
929 list_for_each_entry(efiobj
, &efi_obj_list
, link
) {
930 if (efiobj
->handle
== handle
)
938 * efi_open_protocol_info_entry() - create open protocol info entry and add it
940 * @handler: handler of a protocol
942 * Return: open protocol info entry
944 static struct efi_open_protocol_info_entry
*efi_create_open_info(
945 struct efi_handler
*handler
)
947 struct efi_open_protocol_info_item
*item
;
949 item
= calloc(1, sizeof(struct efi_open_protocol_info_item
));
952 /* Append the item to the open protocol info list. */
953 list_add_tail(&item
->link
, &handler
->open_infos
);
959 * efi_delete_open_info() - remove an open protocol info entry from a protocol
960 * @item: open protocol info entry to delete
962 * Return: status code
964 static efi_status_t
efi_delete_open_info(
965 struct efi_open_protocol_info_item
*item
)
967 list_del(&item
->link
);
973 * efi_add_protocol() - install new protocol on a handle
974 * @handle: handle on which the protocol shall be installed
975 * @protocol: GUID of the protocol to be installed
976 * @protocol_interface: interface of the protocol implementation
978 * Return: status code
980 efi_status_t
efi_add_protocol(const efi_handle_t handle
,
981 const efi_guid_t
*protocol
,
982 void *protocol_interface
)
984 struct efi_object
*efiobj
;
985 struct efi_handler
*handler
;
988 efiobj
= efi_search_obj(handle
);
990 return EFI_INVALID_PARAMETER
;
991 ret
= efi_search_protocol(handle
, protocol
, NULL
);
992 if (ret
!= EFI_NOT_FOUND
)
993 return EFI_INVALID_PARAMETER
;
994 handler
= calloc(1, sizeof(struct efi_handler
));
996 return EFI_OUT_OF_RESOURCES
;
997 handler
->guid
= protocol
;
998 handler
->protocol_interface
= protocol_interface
;
999 INIT_LIST_HEAD(&handler
->open_infos
);
1000 list_add_tail(&handler
->link
, &efiobj
->protocols
);
1001 if (!guidcmp(&efi_guid_device_path
, protocol
))
1002 EFI_PRINT("installed device path '%pD'\n", protocol_interface
);
1007 * efi_install_protocol_interface() - install protocol interface
1008 * @handle: handle on which the protocol shall be installed
1009 * @protocol: GUID of the protocol to be installed
1010 * @protocol_interface_type: type of the interface to be installed,
1011 * always EFI_NATIVE_INTERFACE
1012 * @protocol_interface: interface of the protocol implementation
1014 * This function implements the InstallProtocolInterface service.
1016 * See the Unified Extensible Firmware Interface (UEFI) specification for
1019 * Return: status code
1021 static efi_status_t EFIAPI
efi_install_protocol_interface(
1022 void **handle
, const efi_guid_t
*protocol
,
1023 int protocol_interface_type
, void *protocol_interface
)
1027 EFI_ENTRY("%p, %pUl, %d, %p", handle
, protocol
, protocol_interface_type
,
1028 protocol_interface
);
1030 if (!handle
|| !protocol
||
1031 protocol_interface_type
!= EFI_NATIVE_INTERFACE
) {
1032 r
= EFI_INVALID_PARAMETER
;
1036 /* Create new handle if requested. */
1038 r
= efi_create_handle(handle
);
1039 if (r
!= EFI_SUCCESS
)
1041 debug("%sEFI: new handle %p\n", indent_string(nesting_level
),
1044 debug("%sEFI: handle %p\n", indent_string(nesting_level
),
1047 /* Add new protocol */
1048 r
= efi_add_protocol(*handle
, protocol
, protocol_interface
);
1054 * efi_get_drivers() - get all drivers associated to a controller
1055 * @efiobj: handle of the controller
1056 * @protocol: protocol GUID (optional)
1057 * @number_of_drivers: number of child controllers
1058 * @driver_handle_buffer: handles of the the drivers
1060 * The allocated buffer has to be freed with free().
1062 * Return: status code
1064 static efi_status_t
efi_get_drivers(struct efi_object
*efiobj
,
1065 const efi_guid_t
*protocol
,
1066 efi_uintn_t
*number_of_drivers
,
1067 efi_handle_t
**driver_handle_buffer
)
1069 struct efi_handler
*handler
;
1070 struct efi_open_protocol_info_item
*item
;
1071 efi_uintn_t count
= 0, i
;
1074 /* Count all driver associations */
1075 list_for_each_entry(handler
, &efiobj
->protocols
, link
) {
1076 if (protocol
&& guidcmp(handler
->guid
, protocol
))
1078 list_for_each_entry(item
, &handler
->open_infos
, link
) {
1079 if (item
->info
.attributes
&
1080 EFI_OPEN_PROTOCOL_BY_DRIVER
)
1085 * Create buffer. In case of duplicate driver assignments the buffer
1086 * will be too large. But that does not harm.
1088 *number_of_drivers
= 0;
1089 *driver_handle_buffer
= calloc(count
, sizeof(efi_handle_t
));
1090 if (!*driver_handle_buffer
)
1091 return EFI_OUT_OF_RESOURCES
;
1092 /* Collect unique driver handles */
1093 list_for_each_entry(handler
, &efiobj
->protocols
, link
) {
1094 if (protocol
&& guidcmp(handler
->guid
, protocol
))
1096 list_for_each_entry(item
, &handler
->open_infos
, link
) {
1097 if (item
->info
.attributes
&
1098 EFI_OPEN_PROTOCOL_BY_DRIVER
) {
1099 /* Check this is a new driver */
1101 for (i
= 0; i
< *number_of_drivers
; ++i
) {
1102 if ((*driver_handle_buffer
)[i
] ==
1103 item
->info
.agent_handle
)
1106 /* Copy handle to buffer */
1108 i
= (*number_of_drivers
)++;
1109 (*driver_handle_buffer
)[i
] =
1110 item
->info
.agent_handle
;
1119 * efi_disconnect_all_drivers() - disconnect all drivers from a controller
1120 * @efiobj: handle of the controller
1121 * @protocol: protocol GUID (optional)
1122 * @child_handle: handle of the child to destroy
1124 * This function implements the DisconnectController service.
1126 * See the Unified Extensible Firmware Interface (UEFI) specification for
1129 * Return: status code
1131 static efi_status_t
efi_disconnect_all_drivers(
1132 struct efi_object
*efiobj
,
1133 const efi_guid_t
*protocol
,
1134 efi_handle_t child_handle
)
1136 efi_uintn_t number_of_drivers
;
1137 efi_handle_t
*driver_handle_buffer
;
1138 efi_status_t r
, ret
;
1140 ret
= efi_get_drivers(efiobj
, protocol
, &number_of_drivers
,
1141 &driver_handle_buffer
);
1142 if (ret
!= EFI_SUCCESS
)
1145 ret
= EFI_NOT_FOUND
;
1146 while (number_of_drivers
) {
1147 r
= EFI_CALL(efi_disconnect_controller(
1149 driver_handle_buffer
[--number_of_drivers
],
1151 if (r
== EFI_SUCCESS
)
1154 free(driver_handle_buffer
);
1159 * efi_uninstall_protocol_interface() - uninstall protocol interface
1160 * @handle: handle from which the protocol shall be removed
1161 * @protocol: GUID of the protocol to be removed
1162 * @protocol_interface: interface to be removed
1164 * This function implements the UninstallProtocolInterface service.
1166 * See the Unified Extensible Firmware Interface (UEFI) specification for
1169 * Return: status code
1171 static efi_status_t EFIAPI
efi_uninstall_protocol_interface(
1172 efi_handle_t handle
, const efi_guid_t
*protocol
,
1173 void *protocol_interface
)
1175 struct efi_object
*efiobj
;
1176 struct efi_handler
*handler
;
1177 struct efi_open_protocol_info_item
*item
;
1178 struct efi_open_protocol_info_item
*pos
;
1181 EFI_ENTRY("%p, %pUl, %p", handle
, protocol
, protocol_interface
);
1184 efiobj
= efi_search_obj(handle
);
1186 r
= EFI_INVALID_PARAMETER
;
1189 /* Find the protocol on the handle */
1190 r
= efi_search_protocol(handle
, protocol
, &handler
);
1191 if (r
!= EFI_SUCCESS
)
1193 /* Disconnect controllers */
1194 efi_disconnect_all_drivers(efiobj
, protocol
, NULL
);
1195 if (!list_empty(&handler
->open_infos
)) {
1196 r
= EFI_ACCESS_DENIED
;
1199 /* Close protocol */
1200 list_for_each_entry_safe(item
, pos
, &handler
->open_infos
, link
) {
1201 if (item
->info
.attributes
==
1202 EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL
||
1203 item
->info
.attributes
== EFI_OPEN_PROTOCOL_GET_PROTOCOL
||
1204 item
->info
.attributes
== EFI_OPEN_PROTOCOL_TEST_PROTOCOL
)
1205 list_del(&item
->link
);
1207 if (!list_empty(&handler
->open_infos
)) {
1208 r
= EFI_ACCESS_DENIED
;
1211 r
= efi_remove_protocol(handle
, protocol
, protocol_interface
);
1217 * efi_register_protocol_notify() - register an event for notification when a
1218 * protocol is installed.
1219 * @protocol: GUID of the protocol whose installation shall be notified
1220 * @event: event to be signaled upon installation of the protocol
1221 * @registration: key for retrieving the registration information
1223 * This function implements the RegisterProtocolNotify service.
1224 * See the Unified Extensible Firmware Interface (UEFI) specification
1227 * Return: status code
1229 static efi_status_t EFIAPI
efi_register_protocol_notify(
1230 const efi_guid_t
*protocol
,
1231 struct efi_event
*event
,
1232 void **registration
)
1234 EFI_ENTRY("%pUl, %p, %p", protocol
, event
, registration
);
1235 return EFI_EXIT(EFI_OUT_OF_RESOURCES
);
1239 * efi_search() - determine if an EFI handle implements a protocol
1240 * @search_type: selection criterion
1241 * @protocol: GUID of the protocol
1242 * @search_key: registration key
1245 * See the documentation of the LocateHandle service in the UEFI specification.
1247 * Return: 0 if the handle implements the protocol
1249 static int efi_search(enum efi_locate_search_type search_type
,
1250 const efi_guid_t
*protocol
, void *search_key
,
1251 struct efi_object
*efiobj
)
1255 switch (search_type
) {
1258 case BY_REGISTER_NOTIFY
:
1259 /* TODO: RegisterProtocolNotify is not implemented yet */
1262 ret
= efi_search_protocol(efiobj
->handle
, protocol
, NULL
);
1263 return (ret
!= EFI_SUCCESS
);
1265 /* Invalid search type */
1271 * efi_locate_handle() - locate handles implementing a protocol
1272 * @search_type: selection criterion
1273 * @protocol: GUID of the protocol
1274 * @search_key: registration key
1275 * @buffer_size: size of the buffer to receive the handles in bytes
1276 * @buffer: buffer to receive the relevant handles
1278 * This function is meant for U-Boot internal calls. For the API implementation
1279 * of the LocateHandle service see efi_locate_handle_ext.
1281 * Return: status code
1283 static efi_status_t
efi_locate_handle(
1284 enum efi_locate_search_type search_type
,
1285 const efi_guid_t
*protocol
, void *search_key
,
1286 efi_uintn_t
*buffer_size
, efi_handle_t
*buffer
)
1288 struct efi_object
*efiobj
;
1289 efi_uintn_t size
= 0;
1291 /* Check parameters */
1292 switch (search_type
) {
1295 case BY_REGISTER_NOTIFY
:
1297 return EFI_INVALID_PARAMETER
;
1298 /* RegisterProtocolNotify is not implemented yet */
1299 return EFI_UNSUPPORTED
;
1302 return EFI_INVALID_PARAMETER
;
1305 return EFI_INVALID_PARAMETER
;
1309 * efi_locate_handle_buffer uses this function for
1310 * the calculation of the necessary buffer size.
1311 * So do not require a buffer for buffersize == 0.
1313 if (!buffer_size
|| (*buffer_size
&& !buffer
))
1314 return EFI_INVALID_PARAMETER
;
1316 /* Count how much space we need */
1317 list_for_each_entry(efiobj
, &efi_obj_list
, link
) {
1318 if (!efi_search(search_type
, protocol
, search_key
, efiobj
))
1319 size
+= sizeof(void *);
1322 if (*buffer_size
< size
) {
1323 *buffer_size
= size
;
1324 return EFI_BUFFER_TOO_SMALL
;
1327 *buffer_size
= size
;
1329 return EFI_NOT_FOUND
;
1331 /* Then fill the array */
1332 list_for_each_entry(efiobj
, &efi_obj_list
, link
) {
1333 if (!efi_search(search_type
, protocol
, search_key
, efiobj
))
1334 *buffer
++ = efiobj
->handle
;
1341 * efi_locate_handle_ext() - locate handles implementing a protocol.
1342 * @search_type: selection criterion
1343 * @protocol: GUID of the protocol
1344 * @search_key: registration key
1345 * @buffer_size: size of the buffer to receive the handles in bytes
1346 * @buffer: buffer to receive the relevant handles
1348 * This function implements the LocateHandle service.
1350 * See the Unified Extensible Firmware Interface (UEFI) specification for
1353 * Return: 0 if the handle implements the protocol
1355 static efi_status_t EFIAPI
efi_locate_handle_ext(
1356 enum efi_locate_search_type search_type
,
1357 const efi_guid_t
*protocol
, void *search_key
,
1358 efi_uintn_t
*buffer_size
, efi_handle_t
*buffer
)
1360 EFI_ENTRY("%d, %pUl, %p, %p, %p", search_type
, protocol
, search_key
,
1361 buffer_size
, buffer
);
1363 return EFI_EXIT(efi_locate_handle(search_type
, protocol
, search_key
,
1364 buffer_size
, buffer
));
1368 * efi_remove_configuration_table() - collapses configuration table entries,
1371 * @i: index of the table entry to be removed
1373 static void efi_remove_configuration_table(int i
)
1375 struct efi_configuration_table
*this = &systab
.tables
[i
];
1376 struct efi_configuration_table
*next
= &systab
.tables
[i
+ 1];
1377 struct efi_configuration_table
*end
= &systab
.tables
[systab
.nr_tables
];
1379 memmove(this, next
, (ulong
)end
- (ulong
)next
);
1384 * efi_install_configuration_table() - adds, updates, or removes a
1385 * configuration table
1386 * @guid: GUID of the installed table
1387 * @table: table to be installed
1389 * This function is used for internal calls. For the API implementation of the
1390 * InstallConfigurationTable service see efi_install_configuration_table_ext.
1392 * Return: status code
1394 efi_status_t
efi_install_configuration_table(const efi_guid_t
*guid
,
1397 struct efi_event
*evt
;
1401 return EFI_INVALID_PARAMETER
;
1403 /* Check for GUID override */
1404 for (i
= 0; i
< systab
.nr_tables
; i
++) {
1405 if (!guidcmp(guid
, &systab
.tables
[i
].guid
)) {
1407 systab
.tables
[i
].table
= table
;
1409 efi_remove_configuration_table(i
);
1415 return EFI_NOT_FOUND
;
1417 /* No override, check for overflow */
1418 if (i
>= EFI_MAX_CONFIGURATION_TABLES
)
1419 return EFI_OUT_OF_RESOURCES
;
1421 /* Add a new entry */
1422 memcpy(&systab
.tables
[i
].guid
, guid
, sizeof(*guid
));
1423 systab
.tables
[i
].table
= table
;
1424 systab
.nr_tables
= i
+ 1;
1427 /* systab.nr_tables may have changed. So we need to update the CRC32 */
1428 efi_update_table_header_crc32(&systab
.hdr
);
1430 /* Notify that the configuration table was changed */
1431 list_for_each_entry(evt
, &efi_events
, link
) {
1432 if (evt
->group
&& !guidcmp(evt
->group
, guid
)) {
1433 efi_signal_event(evt
, false);
1442 * efi_install_configuration_table_ex() - Adds, updates, or removes a
1443 * configuration table.
1444 * @guid: GUID of the installed table
1445 * @table: table to be installed
1447 * This function implements the InstallConfigurationTable service.
1449 * See the Unified Extensible Firmware Interface (UEFI) specification for
1452 * Return: status code
1454 static efi_status_t EFIAPI
efi_install_configuration_table_ext(efi_guid_t
*guid
,
1457 EFI_ENTRY("%pUl, %p", guid
, table
);
1458 return EFI_EXIT(efi_install_configuration_table(guid
, table
));
1462 * efi_setup_loaded_image() - initialize a loaded image
1463 * @info: loaded image info to be passed to the entry point of the image
1464 * @obj: internal object associated with the loaded image
1465 * @device_path: device path of the loaded image
1466 * @file_path: file path of the loaded image
1468 * Initialize a loaded_image_info and loaded_image_info object with correct
1469 * protocols, boot-device, etc.
1471 * Return: status code
1473 efi_status_t
efi_setup_loaded_image(struct efi_device_path
*device_path
,
1474 struct efi_device_path
*file_path
,
1475 struct efi_loaded_image_obj
**handle_ptr
,
1476 struct efi_loaded_image
**info_ptr
)
1479 struct efi_loaded_image
*info
;
1480 struct efi_loaded_image_obj
*obj
;
1482 info
= calloc(1, sizeof(*info
));
1484 return EFI_OUT_OF_RESOURCES
;
1485 obj
= calloc(1, sizeof(*obj
));
1488 return EFI_OUT_OF_RESOURCES
;
1491 /* Add internal object to object list */
1492 efi_add_handle(&obj
->parent
);
1499 info
->revision
= EFI_LOADED_IMAGE_PROTOCOL_REVISION
;
1500 info
->file_path
= file_path
;
1501 info
->system_table
= &systab
;
1504 info
->device_handle
= efi_dp_find_obj(device_path
, NULL
);
1506 * When asking for the device path interface, return
1507 * bootefi_device_path
1509 ret
= efi_add_protocol(obj
->parent
.handle
,
1510 &efi_guid_device_path
, device_path
);
1511 if (ret
!= EFI_SUCCESS
)
1516 * When asking for the loaded_image interface, just
1517 * return handle which points to loaded_image_info
1519 ret
= efi_add_protocol(obj
->parent
.handle
,
1520 &efi_guid_loaded_image
, info
);
1521 if (ret
!= EFI_SUCCESS
)
1526 printf("ERROR: Failure to install protocols for loaded image\n");
1531 * efi_load_image_from_path() - load an image using a file path
1532 * @file_path: the path of the image to load
1533 * @buffer: buffer containing the loaded image
1535 * Return: status code
1537 efi_status_t
efi_load_image_from_path(struct efi_device_path
*file_path
,
1540 struct efi_file_info
*info
= NULL
;
1541 struct efi_file_handle
*f
;
1542 static efi_status_t ret
;
1545 f
= efi_file_from_path(file_path
);
1547 return EFI_DEVICE_ERROR
;
1550 EFI_CALL(ret
= f
->getinfo(f
, (efi_guid_t
*)&efi_file_info_guid
,
1552 if (ret
== EFI_BUFFER_TOO_SMALL
) {
1554 EFI_CALL(ret
= f
->getinfo(f
, (efi_guid_t
*)&efi_file_info_guid
,
1557 if (ret
!= EFI_SUCCESS
)
1560 ret
= efi_allocate_pool(EFI_LOADER_DATA
, info
->file_size
, buffer
);
1564 bs
= info
->file_size
;
1565 EFI_CALL(ret
= f
->read(f
, &bs
, *buffer
));
1569 EFI_CALL(f
->close(f
));
1571 if (ret
!= EFI_SUCCESS
) {
1572 efi_free_pool(*buffer
);
1580 * efi_load_image() - load an EFI image into memory
1581 * @boot_policy: true for request originating from the boot manager
1582 * @parent_image: the caller's image handle
1583 * @file_path: the path of the image to load
1584 * @source_buffer: memory location from which the image is installed
1585 * @source_size: size of the memory area from which the image is installed
1586 * @image_handle: handle for the newly installed image
1588 * This function implements the LoadImage service.
1590 * See the Unified Extensible Firmware Interface (UEFI) specification
1593 * Return: status code
1595 static efi_status_t EFIAPI
efi_load_image(bool boot_policy
,
1596 efi_handle_t parent_image
,
1597 struct efi_device_path
*file_path
,
1598 void *source_buffer
,
1599 efi_uintn_t source_size
,
1600 efi_handle_t
*image_handle
)
1602 struct efi_loaded_image
*info
;
1603 struct efi_loaded_image_obj
**image_obj
=
1604 (struct efi_loaded_image_obj
**)image_handle
;
1607 EFI_ENTRY("%d, %p, %pD, %p, %zd, %p", boot_policy
, parent_image
,
1608 file_path
, source_buffer
, source_size
, image_handle
);
1610 if (!image_handle
|| !parent_image
) {
1611 ret
= EFI_INVALID_PARAMETER
;
1615 if (!source_buffer
&& !file_path
) {
1616 ret
= EFI_NOT_FOUND
;
1620 if (!source_buffer
) {
1621 struct efi_device_path
*dp
, *fp
;
1623 ret
= efi_load_image_from_path(file_path
, &source_buffer
);
1624 if (ret
!= EFI_SUCCESS
)
1627 * split file_path which contains both the device and
1630 efi_dp_split_file_path(file_path
, &dp
, &fp
);
1631 ret
= efi_setup_loaded_image(dp
, fp
, image_obj
, &info
);
1632 if (ret
!= EFI_SUCCESS
)
1635 /* In this case, file_path is the "device" path, i.e.
1636 * something like a HARDWARE_DEVICE:MEMORY_MAPPED
1638 ret
= efi_setup_loaded_image(file_path
, NULL
, image_obj
, &info
);
1639 if (ret
!= EFI_SUCCESS
)
1642 (*image_obj
)->entry
= efi_load_pe(*image_obj
, source_buffer
, info
);
1643 if (!(*image_obj
)->entry
) {
1644 ret
= EFI_UNSUPPORTED
;
1647 info
->system_table
= &systab
;
1648 info
->parent_handle
= parent_image
;
1649 return EFI_EXIT(EFI_SUCCESS
);
1651 efi_delete_handle(*image_handle
);
1652 *image_handle
= NULL
;
1655 return EFI_EXIT(ret
);
1659 * efi_start_image() - call the entry point of an image
1660 * @image_handle: handle of the image
1661 * @exit_data_size: size of the buffer
1662 * @exit_data: buffer to receive the exit data of the called image
1664 * This function implements the StartImage service.
1666 * See the Unified Extensible Firmware Interface (UEFI) specification for
1669 * Return: status code
1671 static efi_status_t EFIAPI
efi_start_image(efi_handle_t image_handle
,
1672 unsigned long *exit_data_size
,
1675 struct efi_loaded_image_obj
*image_obj
=
1676 (struct efi_loaded_image_obj
*)image_handle
;
1679 EFI_ENTRY("%p, %p, %p", image_handle
, exit_data_size
, exit_data
);
1681 /* call the image! */
1682 if (setjmp(&image_obj
->exit_jmp
)) {
1684 * We called the entry point of the child image with EFI_CALL
1685 * in the lines below. The child image called the Exit() boot
1686 * service efi_exit() which executed the long jump that brought
1687 * us to the current line. This implies that the second half
1688 * of the EFI_CALL macro has not been executed.
1692 * efi_exit() called efi_restore_gd(). We have to undo this
1693 * otherwise __efi_entry_check() will put the wrong value into
1699 * To get ready to call EFI_EXIT below we have to execute the
1700 * missed out steps of EFI_CALL.
1702 assert(__efi_entry_check());
1703 debug("%sEFI: %lu returned by started image\n",
1704 __efi_nesting_dec(),
1705 (unsigned long)((uintptr_t)image_obj
->exit_status
&
1707 return EFI_EXIT(image_obj
->exit_status
);
1710 ret
= EFI_CALL(image_obj
->entry(image_handle
, &systab
));
1713 * Usually UEFI applications call Exit() instead of returning.
1714 * But because the world doesn't consist of ponies and unicorns,
1715 * we're happy to emulate that behavior on behalf of a payload
1718 return EFI_CALL(systab
.boottime
->exit(image_handle
, ret
, 0, NULL
));
1722 * efi_exit() - leave an EFI application or driver
1723 * @image_handle: handle of the application or driver that is exiting
1724 * @exit_status: status code
1725 * @exit_data_size: size of the buffer in bytes
1726 * @exit_data: buffer with data describing an error
1728 * This function implements the Exit service.
1730 * See the Unified Extensible Firmware Interface (UEFI) specification for
1733 * Return: status code
1735 static efi_status_t EFIAPI
efi_exit(efi_handle_t image_handle
,
1736 efi_status_t exit_status
,
1737 unsigned long exit_data_size
,
1741 * TODO: We should call the unload procedure of the loaded
1744 struct efi_loaded_image_obj
*image_obj
=
1745 (struct efi_loaded_image_obj
*)image_handle
;
1747 EFI_ENTRY("%p, %ld, %ld, %p", image_handle
, exit_status
,
1748 exit_data_size
, exit_data
);
1750 /* Make sure entry/exit counts for EFI world cross-overs match */
1751 EFI_EXIT(exit_status
);
1754 * But longjmp out with the U-Boot gd, not the application's, as
1755 * the other end is a setjmp call inside EFI context.
1759 image_obj
->exit_status
= exit_status
;
1760 longjmp(&image_obj
->exit_jmp
, 1);
1762 panic("EFI application exited");
1766 * efi_unload_image() - unload an EFI image
1767 * @image_handle: handle of the image to be unloaded
1769 * This function implements the UnloadImage service.
1771 * See the Unified Extensible Firmware Interface (UEFI) specification for
1774 * Return: status code
1776 static efi_status_t EFIAPI
efi_unload_image(efi_handle_t image_handle
)
1778 struct efi_object
*efiobj
;
1780 EFI_ENTRY("%p", image_handle
);
1781 efiobj
= efi_search_obj(image_handle
);
1783 list_del(&efiobj
->link
);
1785 return EFI_EXIT(EFI_SUCCESS
);
1789 * efi_exit_boot_services() - stop all boot services
1790 * @image_handle: handle of the loaded image
1791 * @map_key: key of the memory map
1793 * This function implements the ExitBootServices service.
1795 * See the Unified Extensible Firmware Interface (UEFI) specification
1798 * All timer events are disabled. For exit boot services events the
1799 * notification function is called. The boot services are disabled in the
1802 * Return: status code
1804 static efi_status_t EFIAPI
efi_exit_boot_services(efi_handle_t image_handle
,
1805 unsigned long map_key
)
1807 struct efi_event
*evt
;
1809 EFI_ENTRY("%p, %ld", image_handle
, map_key
);
1811 /* Check that the caller has read the current memory map */
1812 if (map_key
!= efi_memory_map_key
)
1813 return EFI_INVALID_PARAMETER
;
1815 /* Make sure that notification functions are not called anymore */
1816 efi_tpl
= TPL_HIGH_LEVEL
;
1818 /* Check if ExitBootServices has already been called */
1819 if (!systab
.boottime
)
1820 return EFI_EXIT(EFI_SUCCESS
);
1822 /* Add related events to the event group */
1823 list_for_each_entry(evt
, &efi_events
, link
) {
1824 if (evt
->type
== EVT_SIGNAL_EXIT_BOOT_SERVICES
)
1825 evt
->group
= &efi_guid_event_group_exit_boot_services
;
1827 /* Notify that ExitBootServices is invoked. */
1828 list_for_each_entry(evt
, &efi_events
, link
) {
1830 !guidcmp(evt
->group
,
1831 &efi_guid_event_group_exit_boot_services
)) {
1832 efi_signal_event(evt
, false);
1837 /* TODO: Should persist EFI variables here */
1839 board_quiesce_devices();
1841 /* This stops all lingering devices */
1842 bootm_disable_interrupts();
1844 /* Disable boot time services */
1845 systab
.con_in_handle
= NULL
;
1846 systab
.con_in
= NULL
;
1847 systab
.con_out_handle
= NULL
;
1848 systab
.con_out
= NULL
;
1849 systab
.stderr_handle
= NULL
;
1850 systab
.std_err
= NULL
;
1851 systab
.boottime
= NULL
;
1853 /* Recalculate CRC32 */
1854 efi_update_table_header_crc32(&systab
.hdr
);
1856 /* Give the payload some time to boot */
1857 efi_set_watchdog(0);
1860 return EFI_EXIT(EFI_SUCCESS
);
1864 * efi_get_next_monotonic_count() - get next value of the counter
1865 * @count: returned value of the counter
1867 * This function implements the NextMonotonicCount service.
1869 * See the Unified Extensible Firmware Interface (UEFI) specification for
1872 * Return: status code
1874 static efi_status_t EFIAPI
efi_get_next_monotonic_count(uint64_t *count
)
1876 static uint64_t mono
;
1878 EFI_ENTRY("%p", count
);
1880 return EFI_EXIT(EFI_SUCCESS
);
1884 * efi_stall() - sleep
1885 * @microseconds: period to sleep in microseconds
1887 * This function implements the Stall service.
1889 * See the Unified Extensible Firmware Interface (UEFI) specification for
1892 * Return: status code
1894 static efi_status_t EFIAPI
efi_stall(unsigned long microseconds
)
1896 EFI_ENTRY("%ld", microseconds
);
1897 udelay(microseconds
);
1898 return EFI_EXIT(EFI_SUCCESS
);
1902 * efi_set_watchdog_timer() - reset the watchdog timer
1903 * @timeout: seconds before reset by watchdog
1904 * @watchdog_code: code to be logged when resetting
1905 * @data_size: size of buffer in bytes
1906 * @watchdog_data: buffer with data describing the reset reason
1908 * This function implements the SetWatchdogTimer service.
1910 * See the Unified Extensible Firmware Interface (UEFI) specification for
1913 * Return: status code
1915 static efi_status_t EFIAPI
efi_set_watchdog_timer(unsigned long timeout
,
1916 uint64_t watchdog_code
,
1917 unsigned long data_size
,
1918 uint16_t *watchdog_data
)
1920 EFI_ENTRY("%ld, 0x%llx, %ld, %p", timeout
, watchdog_code
,
1921 data_size
, watchdog_data
);
1922 return EFI_EXIT(efi_set_watchdog(timeout
));
1926 * efi_close_protocol() - close a protocol
1927 * @handle: handle on which the protocol shall be closed
1928 * @protocol: GUID of the protocol to close
1929 * @agent_handle: handle of the driver
1930 * @controller_handle: handle of the controller
1932 * This function implements the CloseProtocol service.
1934 * See the Unified Extensible Firmware Interface (UEFI) specification for
1937 * Return: status code
1939 static efi_status_t EFIAPI
efi_close_protocol(efi_handle_t handle
,
1940 const efi_guid_t
*protocol
,
1941 efi_handle_t agent_handle
,
1942 efi_handle_t controller_handle
)
1944 struct efi_handler
*handler
;
1945 struct efi_open_protocol_info_item
*item
;
1946 struct efi_open_protocol_info_item
*pos
;
1949 EFI_ENTRY("%p, %pUl, %p, %p", handle
, protocol
, agent_handle
,
1952 if (!agent_handle
) {
1953 r
= EFI_INVALID_PARAMETER
;
1956 r
= efi_search_protocol(handle
, protocol
, &handler
);
1957 if (r
!= EFI_SUCCESS
)
1961 list_for_each_entry_safe(item
, pos
, &handler
->open_infos
, link
) {
1962 if (item
->info
.agent_handle
== agent_handle
&&
1963 item
->info
.controller_handle
== controller_handle
) {
1964 efi_delete_open_info(item
);
1974 * efi_open_protocol_information() - provide information about then open status
1975 * of a protocol on a handle
1976 * @handle: handle for which the information shall be retrieved
1977 * @protocol: GUID of the protocol
1978 * @entry_buffer: buffer to receive the open protocol information
1979 * @entry_count: number of entries available in the buffer
1981 * This function implements the OpenProtocolInformation service.
1983 * See the Unified Extensible Firmware Interface (UEFI) specification for
1986 * Return: status code
1988 static efi_status_t EFIAPI
efi_open_protocol_information(
1989 efi_handle_t handle
, const efi_guid_t
*protocol
,
1990 struct efi_open_protocol_info_entry
**entry_buffer
,
1991 efi_uintn_t
*entry_count
)
1993 unsigned long buffer_size
;
1994 unsigned long count
;
1995 struct efi_handler
*handler
;
1996 struct efi_open_protocol_info_item
*item
;
1999 EFI_ENTRY("%p, %pUl, %p, %p", handle
, protocol
, entry_buffer
,
2002 /* Check parameters */
2003 if (!entry_buffer
) {
2004 r
= EFI_INVALID_PARAMETER
;
2007 r
= efi_search_protocol(handle
, protocol
, &handler
);
2008 if (r
!= EFI_SUCCESS
)
2013 list_for_each_entry(item
, &handler
->open_infos
, link
) {
2014 if (item
->info
.open_count
)
2017 *entry_count
= count
;
2018 *entry_buffer
= NULL
;
2025 buffer_size
= count
* sizeof(struct efi_open_protocol_info_entry
);
2026 r
= efi_allocate_pool(EFI_ALLOCATE_ANY_PAGES
, buffer_size
,
2027 (void **)entry_buffer
);
2028 if (r
!= EFI_SUCCESS
)
2030 list_for_each_entry_reverse(item
, &handler
->open_infos
, link
) {
2031 if (item
->info
.open_count
)
2032 (*entry_buffer
)[--count
] = item
->info
;
2039 * efi_protocols_per_handle() - get protocols installed on a handle
2040 * @handle: handle for which the information is retrieved
2041 * @protocol_buffer: buffer with protocol GUIDs
2042 * @protocol_buffer_count: number of entries in the buffer
2044 * This function implements the ProtocolsPerHandleService.
2046 * See the Unified Extensible Firmware Interface (UEFI) specification for
2049 * Return: status code
2051 static efi_status_t EFIAPI
efi_protocols_per_handle(
2052 efi_handle_t handle
, efi_guid_t
***protocol_buffer
,
2053 efi_uintn_t
*protocol_buffer_count
)
2055 unsigned long buffer_size
;
2056 struct efi_object
*efiobj
;
2057 struct list_head
*protocol_handle
;
2060 EFI_ENTRY("%p, %p, %p", handle
, protocol_buffer
,
2061 protocol_buffer_count
);
2063 if (!handle
|| !protocol_buffer
|| !protocol_buffer_count
)
2064 return EFI_EXIT(EFI_INVALID_PARAMETER
);
2066 *protocol_buffer
= NULL
;
2067 *protocol_buffer_count
= 0;
2069 efiobj
= efi_search_obj(handle
);
2071 return EFI_EXIT(EFI_INVALID_PARAMETER
);
2073 /* Count protocols */
2074 list_for_each(protocol_handle
, &efiobj
->protocols
) {
2075 ++*protocol_buffer_count
;
2079 if (*protocol_buffer_count
) {
2082 buffer_size
= sizeof(efi_guid_t
*) * *protocol_buffer_count
;
2083 r
= efi_allocate_pool(EFI_ALLOCATE_ANY_PAGES
, buffer_size
,
2084 (void **)protocol_buffer
);
2085 if (r
!= EFI_SUCCESS
)
2087 list_for_each(protocol_handle
, &efiobj
->protocols
) {
2088 struct efi_handler
*protocol
;
2090 protocol
= list_entry(protocol_handle
,
2091 struct efi_handler
, link
);
2092 (*protocol_buffer
)[j
] = (void *)protocol
->guid
;
2097 return EFI_EXIT(EFI_SUCCESS
);
2101 * efi_locate_handle_buffer() - locate handles implementing a protocol
2102 * @search_type: selection criterion
2103 * @protocol: GUID of the protocol
2104 * @search_key: registration key
2105 * @no_handles: number of returned handles
2106 * @buffer: buffer with the returned handles
2108 * This function implements the LocateHandleBuffer service.
2110 * See the Unified Extensible Firmware Interface (UEFI) specification for
2113 * Return: status code
2115 static efi_status_t EFIAPI
efi_locate_handle_buffer(
2116 enum efi_locate_search_type search_type
,
2117 const efi_guid_t
*protocol
, void *search_key
,
2118 efi_uintn_t
*no_handles
, efi_handle_t
**buffer
)
2121 efi_uintn_t buffer_size
= 0;
2123 EFI_ENTRY("%d, %pUl, %p, %p, %p", search_type
, protocol
, search_key
,
2124 no_handles
, buffer
);
2126 if (!no_handles
|| !buffer
) {
2127 r
= EFI_INVALID_PARAMETER
;
2132 r
= efi_locate_handle(search_type
, protocol
, search_key
, &buffer_size
,
2134 if (r
!= EFI_BUFFER_TOO_SMALL
)
2136 r
= efi_allocate_pool(EFI_ALLOCATE_ANY_PAGES
, buffer_size
,
2138 if (r
!= EFI_SUCCESS
)
2140 r
= efi_locate_handle(search_type
, protocol
, search_key
, &buffer_size
,
2142 if (r
== EFI_SUCCESS
)
2143 *no_handles
= buffer_size
/ sizeof(efi_handle_t
);
2149 * efi_locate_protocol() - find an interface implementing a protocol
2150 * @protocol: GUID of the protocol
2151 * @registration: registration key passed to the notification function
2152 * @protocol_interface: interface implementing the protocol
2154 * This function implements the LocateProtocol service.
2156 * See the Unified Extensible Firmware Interface (UEFI) specification for
2159 * Return: status code
2161 static efi_status_t EFIAPI
efi_locate_protocol(const efi_guid_t
*protocol
,
2163 void **protocol_interface
)
2165 struct list_head
*lhandle
;
2168 EFI_ENTRY("%pUl, %p, %p", protocol
, registration
, protocol_interface
);
2170 if (!protocol
|| !protocol_interface
)
2171 return EFI_EXIT(EFI_INVALID_PARAMETER
);
2173 list_for_each(lhandle
, &efi_obj_list
) {
2174 struct efi_object
*efiobj
;
2175 struct efi_handler
*handler
;
2177 efiobj
= list_entry(lhandle
, struct efi_object
, link
);
2179 ret
= efi_search_protocol(efiobj
->handle
, protocol
, &handler
);
2180 if (ret
== EFI_SUCCESS
) {
2181 *protocol_interface
= handler
->protocol_interface
;
2182 return EFI_EXIT(EFI_SUCCESS
);
2185 *protocol_interface
= NULL
;
2187 return EFI_EXIT(EFI_NOT_FOUND
);
2191 * efi_locate_device_path() - Get the device path and handle of an device
2192 * implementing a protocol
2193 * @protocol: GUID of the protocol
2194 * @device_path: device path
2195 * @device: handle of the device
2197 * This function implements the LocateDevicePath service.
2199 * See the Unified Extensible Firmware Interface (UEFI) specification for
2202 * Return: status code
2204 static efi_status_t EFIAPI
efi_locate_device_path(
2205 const efi_guid_t
*protocol
,
2206 struct efi_device_path
**device_path
,
2207 efi_handle_t
*device
)
2209 struct efi_device_path
*dp
;
2211 struct efi_handler
*handler
;
2212 efi_handle_t
*handles
;
2214 size_t len_best
= 0;
2215 efi_uintn_t no_handles
;
2219 EFI_ENTRY("%pUl, %p, %p", protocol
, device_path
, device
);
2221 if (!protocol
|| !device_path
|| !*device_path
|| !device
) {
2222 ret
= EFI_INVALID_PARAMETER
;
2226 /* Find end of device path */
2227 len
= efi_dp_instance_size(*device_path
);
2229 /* Get all handles implementing the protocol */
2230 ret
= EFI_CALL(efi_locate_handle_buffer(BY_PROTOCOL
, protocol
, NULL
,
2231 &no_handles
, &handles
));
2232 if (ret
!= EFI_SUCCESS
)
2235 for (i
= 0; i
< no_handles
; ++i
) {
2236 /* Find the device path protocol */
2237 ret
= efi_search_protocol(handles
[i
], &efi_guid_device_path
,
2239 if (ret
!= EFI_SUCCESS
)
2241 dp
= (struct efi_device_path
*)handler
->protocol_interface
;
2242 len_dp
= efi_dp_instance_size(dp
);
2244 * This handle can only be a better fit
2245 * if its device path length is longer than the best fit and
2246 * if its device path length is shorter of equal the searched
2249 if (len_dp
<= len_best
|| len_dp
> len
)
2251 /* Check if dp is a subpath of device_path */
2252 if (memcmp(*device_path
, dp
, len_dp
))
2254 *device
= handles
[i
];
2258 remainder
= (u8
*)*device_path
+ len_best
;
2259 *device_path
= (struct efi_device_path
*)remainder
;
2262 ret
= EFI_NOT_FOUND
;
2265 return EFI_EXIT(ret
);
2269 * efi_install_multiple_protocol_interfaces() - Install multiple protocol
2271 * @handle: handle on which the protocol interfaces shall be installed
2272 * @...: NULL terminated argument list with pairs of protocol GUIDS and
2275 * This function implements the MultipleProtocolInterfaces service.
2277 * See the Unified Extensible Firmware Interface (UEFI) specification for
2280 * Return: status code
2282 static efi_status_t EFIAPI
efi_install_multiple_protocol_interfaces(
2285 EFI_ENTRY("%p", handle
);
2288 const efi_guid_t
*protocol
;
2289 void *protocol_interface
;
2290 efi_status_t r
= EFI_SUCCESS
;
2294 return EFI_EXIT(EFI_INVALID_PARAMETER
);
2296 efi_va_start(argptr
, handle
);
2298 protocol
= efi_va_arg(argptr
, efi_guid_t
*);
2301 protocol_interface
= efi_va_arg(argptr
, void*);
2302 r
= EFI_CALL(efi_install_protocol_interface(
2304 EFI_NATIVE_INTERFACE
,
2305 protocol_interface
));
2306 if (r
!= EFI_SUCCESS
)
2311 if (r
== EFI_SUCCESS
)
2314 /* If an error occurred undo all changes. */
2315 efi_va_start(argptr
, handle
);
2317 protocol
= efi_va_arg(argptr
, efi_guid_t
*);
2318 protocol_interface
= efi_va_arg(argptr
, void*);
2319 EFI_CALL(efi_uninstall_protocol_interface(handle
, protocol
,
2320 protocol_interface
));
2328 * efi_uninstall_multiple_protocol_interfaces() - uninstall multiple protocol
2330 * @handle: handle from which the protocol interfaces shall be removed
2331 * @...: NULL terminated argument list with pairs of protocol GUIDS and
2334 * This function implements the UninstallMultipleProtocolInterfaces service.
2336 * See the Unified Extensible Firmware Interface (UEFI) specification for
2339 * Return: status code
2341 static efi_status_t EFIAPI
efi_uninstall_multiple_protocol_interfaces(
2344 EFI_ENTRY("%p", handle
);
2347 const efi_guid_t
*protocol
;
2348 void *protocol_interface
;
2349 efi_status_t r
= EFI_SUCCESS
;
2353 return EFI_EXIT(EFI_INVALID_PARAMETER
);
2355 efi_va_start(argptr
, handle
);
2357 protocol
= efi_va_arg(argptr
, efi_guid_t
*);
2360 protocol_interface
= efi_va_arg(argptr
, void*);
2361 r
= EFI_CALL(efi_uninstall_protocol_interface(
2363 protocol_interface
));
2364 if (r
!= EFI_SUCCESS
)
2369 if (r
== EFI_SUCCESS
)
2372 /* If an error occurred undo all changes. */
2373 efi_va_start(argptr
, handle
);
2375 protocol
= efi_va_arg(argptr
, efi_guid_t
*);
2376 protocol_interface
= efi_va_arg(argptr
, void*);
2377 EFI_CALL(efi_install_protocol_interface(&handle
, protocol
,
2378 EFI_NATIVE_INTERFACE
,
2379 protocol_interface
));
2387 * efi_calculate_crc32() - calculate cyclic redundancy code
2388 * @data: buffer with data
2389 * @data_size: size of buffer in bytes
2390 * @crc32_p: cyclic redundancy code
2392 * This function implements the CalculateCrc32 service.
2394 * See the Unified Extensible Firmware Interface (UEFI) specification for
2397 * Return: status code
2399 static efi_status_t EFIAPI
efi_calculate_crc32(const void *data
,
2400 efi_uintn_t data_size
,
2403 EFI_ENTRY("%p, %zu", data
, data_size
);
2404 *crc32_p
= crc32(0, data
, data_size
);
2405 return EFI_EXIT(EFI_SUCCESS
);
2409 * efi_copy_mem() - copy memory
2410 * @destination: destination of the copy operation
2411 * @source: source of the copy operation
2412 * @length: number of bytes to copy
2414 * This function implements the CopyMem service.
2416 * See the Unified Extensible Firmware Interface (UEFI) specification for
2419 static void EFIAPI
efi_copy_mem(void *destination
, const void *source
,
2422 EFI_ENTRY("%p, %p, %ld", destination
, source
, (unsigned long)length
);
2423 memcpy(destination
, source
, length
);
2424 EFI_EXIT(EFI_SUCCESS
);
2428 * efi_set_mem() - Fill memory with a byte value.
2429 * @buffer: buffer to fill
2430 * @size: size of buffer in bytes
2431 * @value: byte to copy to the buffer
2433 * This function implements the SetMem service.
2435 * See the Unified Extensible Firmware Interface (UEFI) specification for
2438 static void EFIAPI
efi_set_mem(void *buffer
, size_t size
, uint8_t value
)
2440 EFI_ENTRY("%p, %ld, 0x%x", buffer
, (unsigned long)size
, value
);
2441 memset(buffer
, value
, size
);
2442 EFI_EXIT(EFI_SUCCESS
);
2446 * efi_protocol_open() - open protocol interface on a handle
2447 * @handler: handler of a protocol
2448 * @protocol_interface: interface implementing the protocol
2449 * @agent_handle: handle of the driver
2450 * @controller_handle: handle of the controller
2451 * @attributes: attributes indicating how to open the protocol
2453 * Return: status code
2455 static efi_status_t
efi_protocol_open(
2456 struct efi_handler
*handler
,
2457 void **protocol_interface
, void *agent_handle
,
2458 void *controller_handle
, uint32_t attributes
)
2460 struct efi_open_protocol_info_item
*item
;
2461 struct efi_open_protocol_info_entry
*match
= NULL
;
2462 bool opened_by_driver
= false;
2463 bool opened_exclusive
= false;
2465 /* If there is no agent, only return the interface */
2469 /* For TEST_PROTOCOL ignore interface attribute */
2470 if (attributes
!= EFI_OPEN_PROTOCOL_TEST_PROTOCOL
)
2471 *protocol_interface
= NULL
;
2474 * Check if the protocol is already opened by a driver with the same
2475 * attributes or opened exclusively
2477 list_for_each_entry(item
, &handler
->open_infos
, link
) {
2478 if (item
->info
.agent_handle
== agent_handle
) {
2479 if ((attributes
& EFI_OPEN_PROTOCOL_BY_DRIVER
) &&
2480 (item
->info
.attributes
== attributes
))
2481 return EFI_ALREADY_STARTED
;
2483 if (item
->info
.attributes
& EFI_OPEN_PROTOCOL_EXCLUSIVE
)
2484 opened_exclusive
= true;
2487 /* Only one controller can open the protocol exclusively */
2488 if (opened_exclusive
&& attributes
&
2489 (EFI_OPEN_PROTOCOL_EXCLUSIVE
| EFI_OPEN_PROTOCOL_BY_DRIVER
))
2490 return EFI_ACCESS_DENIED
;
2492 /* Prepare exclusive opening */
2493 if (attributes
& EFI_OPEN_PROTOCOL_EXCLUSIVE
) {
2494 /* Try to disconnect controllers */
2495 list_for_each_entry(item
, &handler
->open_infos
, link
) {
2496 if (item
->info
.attributes
==
2497 EFI_OPEN_PROTOCOL_BY_DRIVER
)
2498 EFI_CALL(efi_disconnect_controller(
2499 item
->info
.controller_handle
,
2500 item
->info
.agent_handle
,
2503 opened_by_driver
= false;
2504 /* Check if all controllers are disconnected */
2505 list_for_each_entry(item
, &handler
->open_infos
, link
) {
2506 if (item
->info
.attributes
& EFI_OPEN_PROTOCOL_BY_DRIVER
)
2507 opened_by_driver
= true;
2509 /* Only one controller can be conncected */
2510 if (opened_by_driver
)
2511 return EFI_ACCESS_DENIED
;
2514 /* Find existing entry */
2515 list_for_each_entry(item
, &handler
->open_infos
, link
) {
2516 if (item
->info
.agent_handle
== agent_handle
&&
2517 item
->info
.controller_handle
== controller_handle
)
2518 match
= &item
->info
;
2520 /* None found, create one */
2522 match
= efi_create_open_info(handler
);
2524 return EFI_OUT_OF_RESOURCES
;
2527 match
->agent_handle
= agent_handle
;
2528 match
->controller_handle
= controller_handle
;
2529 match
->attributes
= attributes
;
2530 match
->open_count
++;
2533 /* For TEST_PROTOCOL ignore interface attribute. */
2534 if (attributes
!= EFI_OPEN_PROTOCOL_TEST_PROTOCOL
)
2535 *protocol_interface
= handler
->protocol_interface
;
2541 * efi_open_protocol() - open protocol interface on a handle
2542 * @handle: handle on which the protocol shall be opened
2543 * @protocol: GUID of the protocol
2544 * @protocol_interface: interface implementing the protocol
2545 * @agent_handle: handle of the driver
2546 * @controller_handle: handle of the controller
2547 * @attributes: attributes indicating how to open the protocol
2549 * This function implements the OpenProtocol interface.
2551 * See the Unified Extensible Firmware Interface (UEFI) specification for
2554 * Return: status code
2556 static efi_status_t EFIAPI
efi_open_protocol(
2557 void *handle
, const efi_guid_t
*protocol
,
2558 void **protocol_interface
, void *agent_handle
,
2559 void *controller_handle
, uint32_t attributes
)
2561 struct efi_handler
*handler
;
2562 efi_status_t r
= EFI_INVALID_PARAMETER
;
2564 EFI_ENTRY("%p, %pUl, %p, %p, %p, 0x%x", handle
, protocol
,
2565 protocol_interface
, agent_handle
, controller_handle
,
2568 if (!handle
|| !protocol
||
2569 (!protocol_interface
&& attributes
!=
2570 EFI_OPEN_PROTOCOL_TEST_PROTOCOL
)) {
2574 switch (attributes
) {
2575 case EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL
:
2576 case EFI_OPEN_PROTOCOL_GET_PROTOCOL
:
2577 case EFI_OPEN_PROTOCOL_TEST_PROTOCOL
:
2579 case EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
:
2580 if (controller_handle
== handle
)
2583 case EFI_OPEN_PROTOCOL_BY_DRIVER
:
2584 case EFI_OPEN_PROTOCOL_BY_DRIVER
| EFI_OPEN_PROTOCOL_EXCLUSIVE
:
2585 /* Check that the controller handle is valid */
2586 if (!efi_search_obj(controller_handle
))
2589 case EFI_OPEN_PROTOCOL_EXCLUSIVE
:
2590 /* Check that the agent handle is valid */
2591 if (!efi_search_obj(agent_handle
))
2598 r
= efi_search_protocol(handle
, protocol
, &handler
);
2599 if (r
!= EFI_SUCCESS
)
2602 r
= efi_protocol_open(handler
, protocol_interface
, agent_handle
,
2603 controller_handle
, attributes
);
2609 * efi_handle_protocol() - get interface of a protocol on a handle
2610 * @handle: handle on which the protocol shall be opened
2611 * @protocol: GUID of the protocol
2612 * @protocol_interface: interface implementing the protocol
2614 * This function implements the HandleProtocol service.
2616 * See the Unified Extensible Firmware Interface (UEFI) specification for
2619 * Return: status code
2621 static efi_status_t EFIAPI
efi_handle_protocol(efi_handle_t handle
,
2622 const efi_guid_t
*protocol
,
2623 void **protocol_interface
)
2625 return efi_open_protocol(handle
, protocol
, protocol_interface
, NULL
,
2626 NULL
, EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL
);
2630 * efi_bind_controller() - bind a single driver to a controller
2631 * @controller_handle: controller handle
2632 * @driver_image_handle: driver handle
2633 * @remain_device_path: remaining path
2635 * Return: status code
2637 static efi_status_t
efi_bind_controller(
2638 efi_handle_t controller_handle
,
2639 efi_handle_t driver_image_handle
,
2640 struct efi_device_path
*remain_device_path
)
2642 struct efi_driver_binding_protocol
*binding_protocol
;
2645 r
= EFI_CALL(efi_open_protocol(driver_image_handle
,
2646 &efi_guid_driver_binding_protocol
,
2647 (void **)&binding_protocol
,
2648 driver_image_handle
, NULL
,
2649 EFI_OPEN_PROTOCOL_GET_PROTOCOL
));
2650 if (r
!= EFI_SUCCESS
)
2652 r
= EFI_CALL(binding_protocol
->supported(binding_protocol
,
2654 remain_device_path
));
2655 if (r
== EFI_SUCCESS
)
2656 r
= EFI_CALL(binding_protocol
->start(binding_protocol
,
2658 remain_device_path
));
2659 EFI_CALL(efi_close_protocol(driver_image_handle
,
2660 &efi_guid_driver_binding_protocol
,
2661 driver_image_handle
, NULL
));
2666 * efi_connect_single_controller() - connect a single driver to a controller
2667 * @controller_handle: controller
2668 * @driver_image_handle: driver
2669 * @remain_device_path: remaining path
2671 * Return: status code
2673 static efi_status_t
efi_connect_single_controller(
2674 efi_handle_t controller_handle
,
2675 efi_handle_t
*driver_image_handle
,
2676 struct efi_device_path
*remain_device_path
)
2678 efi_handle_t
*buffer
;
2682 size_t connected
= 0;
2684 /* Get buffer with all handles with driver binding protocol */
2685 r
= EFI_CALL(efi_locate_handle_buffer(BY_PROTOCOL
,
2686 &efi_guid_driver_binding_protocol
,
2687 NULL
, &count
, &buffer
));
2688 if (r
!= EFI_SUCCESS
)
2691 /* Context Override */
2692 if (driver_image_handle
) {
2693 for (; *driver_image_handle
; ++driver_image_handle
) {
2694 for (i
= 0; i
< count
; ++i
) {
2695 if (buffer
[i
] == *driver_image_handle
) {
2697 r
= efi_bind_controller(
2699 *driver_image_handle
,
2700 remain_device_path
);
2702 * For drivers that do not support the
2703 * controller or are already connected
2704 * we receive an error code here.
2706 if (r
== EFI_SUCCESS
)
2714 * TODO: Some overrides are not yet implemented:
2715 * - Platform Driver Override
2716 * - Driver Family Override Search
2717 * - Bus Specific Driver Override
2720 /* Driver Binding Search */
2721 for (i
= 0; i
< count
; ++i
) {
2723 r
= efi_bind_controller(controller_handle
,
2725 remain_device_path
);
2726 if (r
== EFI_SUCCESS
)
2731 efi_free_pool(buffer
);
2733 return EFI_NOT_FOUND
;
2738 * efi_connect_controller() - connect a controller to a driver
2739 * @controller_handle: handle of the controller
2740 * @driver_image_handle: handle of the driver
2741 * @remain_device_path: device path of a child controller
2742 * @recursive: true to connect all child controllers
2744 * This function implements the ConnectController service.
2746 * See the Unified Extensible Firmware Interface (UEFI) specification for
2749 * First all driver binding protocol handles are tried for binding drivers.
2750 * Afterwards all handles that have opened a protocol of the controller
2751 * with EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER are connected to drivers.
2753 * Return: status code
2755 static efi_status_t EFIAPI
efi_connect_controller(
2756 efi_handle_t controller_handle
,
2757 efi_handle_t
*driver_image_handle
,
2758 struct efi_device_path
*remain_device_path
,
2762 efi_status_t ret
= EFI_NOT_FOUND
;
2763 struct efi_object
*efiobj
;
2765 EFI_ENTRY("%p, %p, %p, %d", controller_handle
, driver_image_handle
,
2766 remain_device_path
, recursive
);
2768 efiobj
= efi_search_obj(controller_handle
);
2770 ret
= EFI_INVALID_PARAMETER
;
2774 r
= efi_connect_single_controller(controller_handle
,
2775 driver_image_handle
,
2776 remain_device_path
);
2777 if (r
== EFI_SUCCESS
)
2780 struct efi_handler
*handler
;
2781 struct efi_open_protocol_info_item
*item
;
2783 list_for_each_entry(handler
, &efiobj
->protocols
, link
) {
2784 list_for_each_entry(item
, &handler
->open_infos
, link
) {
2785 if (item
->info
.attributes
&
2786 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) {
2787 r
= EFI_CALL(efi_connect_controller(
2788 item
->info
.controller_handle
,
2789 driver_image_handle
,
2792 if (r
== EFI_SUCCESS
)
2798 /* Check for child controller specified by end node */
2799 if (ret
!= EFI_SUCCESS
&& remain_device_path
&&
2800 remain_device_path
->type
== DEVICE_PATH_TYPE_END
)
2803 return EFI_EXIT(ret
);
2807 * efi_reinstall_protocol_interface() - reinstall protocol interface
2808 * @handle: handle on which the protocol shall be reinstalled
2809 * @protocol: GUID of the protocol to be installed
2810 * @old_interface: interface to be removed
2811 * @new_interface: interface to be installed
2813 * This function implements the ReinstallProtocolInterface service.
2815 * See the Unified Extensible Firmware Interface (UEFI) specification for
2818 * The old interface is uninstalled. The new interface is installed.
2819 * Drivers are connected.
2821 * Return: status code
2823 static efi_status_t EFIAPI
efi_reinstall_protocol_interface(
2824 efi_handle_t handle
, const efi_guid_t
*protocol
,
2825 void *old_interface
, void *new_interface
)
2829 EFI_ENTRY("%p, %pUl, %p, %p", handle
, protocol
, old_interface
,
2831 ret
= EFI_CALL(efi_uninstall_protocol_interface(handle
, protocol
,
2833 if (ret
!= EFI_SUCCESS
)
2835 ret
= EFI_CALL(efi_install_protocol_interface(&handle
, protocol
,
2836 EFI_NATIVE_INTERFACE
,
2838 if (ret
!= EFI_SUCCESS
)
2841 * The returned status code has to be ignored.
2842 * Do not create an error if no suitable driver for the handle exists.
2844 EFI_CALL(efi_connect_controller(handle
, NULL
, NULL
, true));
2846 return EFI_EXIT(ret
);
2850 * efi_get_child_controllers() - get all child controllers associated to a driver
2851 * @efiobj: handle of the controller
2852 * @driver_handle: handle of the driver
2853 * @number_of_children: number of child controllers
2854 * @child_handle_buffer: handles of the the child controllers
2856 * The allocated buffer has to be freed with free().
2858 * Return: status code
2860 static efi_status_t
efi_get_child_controllers(
2861 struct efi_object
*efiobj
,
2862 efi_handle_t driver_handle
,
2863 efi_uintn_t
*number_of_children
,
2864 efi_handle_t
**child_handle_buffer
)
2866 struct efi_handler
*handler
;
2867 struct efi_open_protocol_info_item
*item
;
2868 efi_uintn_t count
= 0, i
;
2871 /* Count all child controller associations */
2872 list_for_each_entry(handler
, &efiobj
->protocols
, link
) {
2873 list_for_each_entry(item
, &handler
->open_infos
, link
) {
2874 if (item
->info
.agent_handle
== driver_handle
&&
2875 item
->info
.attributes
&
2876 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
)
2881 * Create buffer. In case of duplicate child controller assignments
2882 * the buffer will be too large. But that does not harm.
2884 *number_of_children
= 0;
2885 *child_handle_buffer
= calloc(count
, sizeof(efi_handle_t
));
2886 if (!*child_handle_buffer
)
2887 return EFI_OUT_OF_RESOURCES
;
2888 /* Copy unique child handles */
2889 list_for_each_entry(handler
, &efiobj
->protocols
, link
) {
2890 list_for_each_entry(item
, &handler
->open_infos
, link
) {
2891 if (item
->info
.agent_handle
== driver_handle
&&
2892 item
->info
.attributes
&
2893 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
) {
2894 /* Check this is a new child controller */
2896 for (i
= 0; i
< *number_of_children
; ++i
) {
2897 if ((*child_handle_buffer
)[i
] ==
2898 item
->info
.controller_handle
)
2901 /* Copy handle to buffer */
2903 i
= (*number_of_children
)++;
2904 (*child_handle_buffer
)[i
] =
2905 item
->info
.controller_handle
;
2914 * efi_disconnect_controller() - disconnect a controller from a driver
2915 * @controller_handle: handle of the controller
2916 * @driver_image_handle: handle of the driver
2917 * @child_handle: handle of the child to destroy
2919 * This function implements the DisconnectController service.
2921 * See the Unified Extensible Firmware Interface (UEFI) specification for
2924 * Return: status code
2926 static efi_status_t EFIAPI
efi_disconnect_controller(
2927 efi_handle_t controller_handle
,
2928 efi_handle_t driver_image_handle
,
2929 efi_handle_t child_handle
)
2931 struct efi_driver_binding_protocol
*binding_protocol
;
2932 efi_handle_t
*child_handle_buffer
= NULL
;
2933 size_t number_of_children
= 0;
2935 size_t stop_count
= 0;
2936 struct efi_object
*efiobj
;
2938 EFI_ENTRY("%p, %p, %p", controller_handle
, driver_image_handle
,
2941 efiobj
= efi_search_obj(controller_handle
);
2943 r
= EFI_INVALID_PARAMETER
;
2947 if (child_handle
&& !efi_search_obj(child_handle
)) {
2948 r
= EFI_INVALID_PARAMETER
;
2952 /* If no driver handle is supplied, disconnect all drivers */
2953 if (!driver_image_handle
) {
2954 r
= efi_disconnect_all_drivers(efiobj
, NULL
, child_handle
);
2958 /* Create list of child handles */
2960 number_of_children
= 1;
2961 child_handle_buffer
= &child_handle
;
2963 efi_get_child_controllers(efiobj
,
2964 driver_image_handle
,
2965 &number_of_children
,
2966 &child_handle_buffer
);
2969 /* Get the driver binding protocol */
2970 r
= EFI_CALL(efi_open_protocol(driver_image_handle
,
2971 &efi_guid_driver_binding_protocol
,
2972 (void **)&binding_protocol
,
2973 driver_image_handle
, NULL
,
2974 EFI_OPEN_PROTOCOL_GET_PROTOCOL
));
2975 if (r
!= EFI_SUCCESS
)
2977 /* Remove the children */
2978 if (number_of_children
) {
2979 r
= EFI_CALL(binding_protocol
->stop(binding_protocol
,
2982 child_handle_buffer
));
2983 if (r
== EFI_SUCCESS
)
2986 /* Remove the driver */
2988 r
= EFI_CALL(binding_protocol
->stop(binding_protocol
,
2991 if (r
== EFI_SUCCESS
)
2993 EFI_CALL(efi_close_protocol(driver_image_handle
,
2994 &efi_guid_driver_binding_protocol
,
2995 driver_image_handle
, NULL
));
3003 free(child_handle_buffer
);
3007 static struct efi_boot_services efi_boot_services
= {
3009 .signature
= EFI_BOOT_SERVICES_SIGNATURE
,
3010 .revision
= EFI_SPECIFICATION_VERSION
,
3011 .headersize
= sizeof(struct efi_boot_services
),
3013 .raise_tpl
= efi_raise_tpl
,
3014 .restore_tpl
= efi_restore_tpl
,
3015 .allocate_pages
= efi_allocate_pages_ext
,
3016 .free_pages
= efi_free_pages_ext
,
3017 .get_memory_map
= efi_get_memory_map_ext
,
3018 .allocate_pool
= efi_allocate_pool_ext
,
3019 .free_pool
= efi_free_pool_ext
,
3020 .create_event
= efi_create_event_ext
,
3021 .set_timer
= efi_set_timer_ext
,
3022 .wait_for_event
= efi_wait_for_event
,
3023 .signal_event
= efi_signal_event_ext
,
3024 .close_event
= efi_close_event
,
3025 .check_event
= efi_check_event
,
3026 .install_protocol_interface
= efi_install_protocol_interface
,
3027 .reinstall_protocol_interface
= efi_reinstall_protocol_interface
,
3028 .uninstall_protocol_interface
= efi_uninstall_protocol_interface
,
3029 .handle_protocol
= efi_handle_protocol
,
3031 .register_protocol_notify
= efi_register_protocol_notify
,
3032 .locate_handle
= efi_locate_handle_ext
,
3033 .locate_device_path
= efi_locate_device_path
,
3034 .install_configuration_table
= efi_install_configuration_table_ext
,
3035 .load_image
= efi_load_image
,
3036 .start_image
= efi_start_image
,
3038 .unload_image
= efi_unload_image
,
3039 .exit_boot_services
= efi_exit_boot_services
,
3040 .get_next_monotonic_count
= efi_get_next_monotonic_count
,
3042 .set_watchdog_timer
= efi_set_watchdog_timer
,
3043 .connect_controller
= efi_connect_controller
,
3044 .disconnect_controller
= efi_disconnect_controller
,
3045 .open_protocol
= efi_open_protocol
,
3046 .close_protocol
= efi_close_protocol
,
3047 .open_protocol_information
= efi_open_protocol_information
,
3048 .protocols_per_handle
= efi_protocols_per_handle
,
3049 .locate_handle_buffer
= efi_locate_handle_buffer
,
3050 .locate_protocol
= efi_locate_protocol
,
3051 .install_multiple_protocol_interfaces
=
3052 efi_install_multiple_protocol_interfaces
,
3053 .uninstall_multiple_protocol_interfaces
=
3054 efi_uninstall_multiple_protocol_interfaces
,
3055 .calculate_crc32
= efi_calculate_crc32
,
3056 .copy_mem
= efi_copy_mem
,
3057 .set_mem
= efi_set_mem
,
3058 .create_event_ex
= efi_create_event_ex
,
3061 static u16 __efi_runtime_data firmware_vendor
[] = L
"Das U-Boot";
3063 struct efi_system_table __efi_runtime_data systab
= {
3065 .signature
= EFI_SYSTEM_TABLE_SIGNATURE
,
3066 .revision
= EFI_SPECIFICATION_VERSION
,
3067 .headersize
= sizeof(struct efi_system_table
),
3069 .fw_vendor
= firmware_vendor
,
3070 .fw_revision
= FW_VERSION
<< 16 | FW_PATCHLEVEL
<< 8,
3071 .con_in
= (void *)&efi_con_in
,
3072 .con_out
= (void *)&efi_con_out
,
3073 .std_err
= (void *)&efi_con_out
,
3074 .runtime
= (void *)&efi_runtime_services
,
3075 .boottime
= (void *)&efi_boot_services
,
3081 * efi_initialize_system_table() - Initialize system table
3083 * Return: status code
3085 efi_status_t
efi_initialize_system_table(void)
3089 /* Allocate configuration table array */
3090 ret
= efi_allocate_pool(EFI_RUNTIME_SERVICES_DATA
,
3091 EFI_MAX_CONFIGURATION_TABLES
*
3092 sizeof(struct efi_configuration_table
),
3093 (void **)&systab
.tables
);
3095 /* Set CRC32 field in table headers */
3096 efi_update_table_header_crc32(&systab
.hdr
);
3097 efi_update_table_header_crc32(&efi_runtime_services
.hdr
);
3098 efi_update_table_header_crc32(&efi_boot_services
.hdr
);