aboutsummaryrefslogtreecommitdiff
path: root/lib
diff options
context:
space:
mode:
Diffstat (limited to 'lib')
-rw-r--r--lib/efi_driver/efi_block_device.c137
-rw-r--r--lib/efi_driver/efi_uclass.c64
-rw-r--r--lib/efi_loader/efi_boottime.c304
-rw-r--r--lib/efi_loader/efi_capsule.c29
-rw-r--r--lib/efi_loader/efi_console.c14
-rw-r--r--lib/efi_loader/efi_device_path.c3
-rw-r--r--lib/efi_loader/efi_disk.c51
-rw-r--r--lib/efi_loader/efi_helper.c19
-rw-r--r--lib/efi_loader/efi_load_initrd.c15
-rw-r--r--lib/efi_loader/efi_load_options.c13
-rw-r--r--lib/efi_loader/efi_root_node.c48
-rw-r--r--lib/efi_loader/efi_setup.c8
-rw-r--r--lib/efi_loader/efi_string.c24
-rw-r--r--lib/efi_loader/efi_tcg2.c10
-rw-r--r--lib/efi_selftest/efi_selftest_events.c18
-rw-r--r--lib/efi_selftest/efi_selftest_exitbootservices.c6
-rw-r--r--lib/efi_selftest/efi_selftest_tpl.c47
-rw-r--r--lib/efi_selftest/efi_selftest_watchdog.c30
18 files changed, 530 insertions, 310 deletions
diff --git a/lib/efi_driver/efi_block_device.c b/lib/efi_driver/efi_block_device.c
index 3177ab67b81..add00eeebbe 100644
--- a/lib/efi_driver/efi_block_device.c
+++ b/lib/efi_driver/efi_block_device.c
@@ -37,11 +37,11 @@
#include <dm/root.h>
#include <dm/tag.h>
-/*
- * EFI attributes of the udevice handled by this driver.
+/**
+ * struct efi_blk_plat - attributes of a block device
*
- * handle handle of the controller on which this driver is installed
- * io block io protocol proxied by this driver
+ * @handle: handle of the controller on which this driver is installed
+ * @io: block io protocol proxied by this driver
*/
struct efi_blk_plat {
efi_handle_t handle;
@@ -49,7 +49,7 @@ struct efi_blk_plat {
};
/**
- * Read from block device
+ * efi_bl_read() - read from block device
*
* @dev: device
* @blknr: first block to be read
@@ -78,7 +78,7 @@ static ulong efi_bl_read(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt,
}
/**
- * Write to block device
+ * efi_bl_write() - write to block device
*
* @dev: device
* @blknr: first block to be write
@@ -108,45 +108,41 @@ static ulong efi_bl_write(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt,
}
/**
- * Create a block device for a handle
+ * efi_bl_create_block_device() - create a block device for a handle
*
* @handle: handle
* @interface: block io protocol
- * Return: 0 = success
+ * Return: status code
*/
-static int efi_bl_bind(efi_handle_t handle, void *interface)
+static efi_status_t
+efi_bl_create_block_device(efi_handle_t handle, void *interface)
{
- struct udevice *bdev, *parent = dm_root();
- int ret, devnum;
+ struct udevice *bdev = NULL, *parent = dm_root();
+ efi_status_t ret;
+ int devnum;
char *name;
- struct efi_object *obj = efi_search_obj(handle);
struct efi_block_io *io = interface;
struct efi_blk_plat *plat;
- EFI_PRINT("%s: handle %p, interface %p\n", __func__, handle, io);
-
- if (!obj)
- return -ENOENT;
-
devnum = blk_find_max_devnum(UCLASS_EFI_LOADER);
if (devnum == -ENODEV)
devnum = 0;
else if (devnum < 0)
- return devnum;
+ return EFI_OUT_OF_RESOURCES;
name = calloc(1, 18); /* strlen("efiblk#2147483648") + 1 */
if (!name)
- return -ENOMEM;
+ return EFI_OUT_OF_RESOURCES;
sprintf(name, "efiblk#%d", devnum);
/* Create driver model udevice for the EFI block io device */
- ret = blk_create_device(parent, "efi_blk", name, UCLASS_EFI_LOADER,
- devnum, io->media->block_size,
- (lbaint_t)io->media->last_block, &bdev);
- if (ret)
- return ret;
- if (!bdev)
- return -ENOENT;
+ if (blk_create_device(parent, "efi_blk", name, UCLASS_EFI_LOADER,
+ devnum, io->media->block_size,
+ (lbaint_t)io->media->last_block, &bdev)) {
+ ret = EFI_OUT_OF_RESOURCES;
+ free(name);
+ goto err;
+ }
/* Set the DM_FLAG_NAME_ALLOCED flag to avoid a memory leak */
device_set_name_alloced(bdev);
@@ -154,20 +150,78 @@ static int efi_bl_bind(efi_handle_t handle, void *interface)
plat->handle = handle;
plat->io = interface;
- /*
- * FIXME: necessary because we won't do almost nothing in
- * efi_disk_create() when called from device_probe().
- */
- if (efi_link_dev(handle, bdev))
- /* FIXME: cleanup for bdev */
- return ret;
-
- ret = device_probe(bdev);
- if (ret)
- return ret;
+ if (efi_link_dev(handle, bdev)) {
+ ret = EFI_OUT_OF_RESOURCES;
+ goto err;
+ }
+
+ if (device_probe(bdev)) {
+ ret = EFI_DEVICE_ERROR;
+ goto err;
+ }
EFI_PRINT("%s: block device '%s' created\n", __func__, bdev->name);
- return 0;
+ return EFI_SUCCESS;
+
+err:
+ efi_unlink_dev(handle);
+ if (bdev)
+ device_unbind(bdev);
+
+ return ret;
+}
+
+/**
+ * efi_bl_bind() - bind to a block io protocol
+ *
+ * @this: driver binding protocol
+ * @handle: handle
+ * @interface: block io protocol
+ * Return: status code
+ */
+static efi_status_t efi_bl_bind(
+ struct efi_driver_binding_extended_protocol *this,
+ efi_handle_t handle, void *interface)
+{
+ efi_status_t ret = EFI_SUCCESS;
+ struct efi_object *obj = efi_search_obj(handle);
+
+ EFI_PRINT("%s: handle %p, interface %p\n", __func__, handle, interface);
+
+ if (!obj || !interface)
+ return EFI_INVALID_PARAMETER;
+
+ if (!handle->dev)
+ ret = efi_bl_create_block_device(handle, interface);
+
+ return ret;
+}
+
+/**
+ * efi_bl_init() - initialize block device driver
+ *
+ * @this: extended driver binding protocol
+ */
+static efi_status_t
+efi_bl_init(struct efi_driver_binding_extended_protocol *this)
+{
+ int ret;
+
+ ret = event_register("efi_disk add", EVT_DM_POST_PROBE,
+ efi_disk_probe, this);
+ if (ret) {
+ log_err("Event registration for efi_disk add failed\n");
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ ret = event_register("efi_disk del", EVT_DM_PRE_REMOVE,
+ efi_disk_remove, this);
+ if (ret) {
+ log_err("Event registration for efi_disk del failed\n");
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ return EFI_SUCCESS;
}
/* Block device driver operators */
@@ -178,9 +232,9 @@ static const struct blk_ops efi_blk_ops = {
/* Identify as block device driver */
U_BOOT_DRIVER(efi_blk) = {
- .name = "efi_blk",
- .id = UCLASS_BLK,
- .ops = &efi_blk_ops,
+ .name = "efi_blk",
+ .id = UCLASS_BLK,
+ .ops = &efi_blk_ops,
.plat_auto = sizeof(struct efi_blk_plat),
};
@@ -188,6 +242,7 @@ U_BOOT_DRIVER(efi_blk) = {
static const struct efi_driver_ops driver_ops = {
.protocol = &efi_block_io_guid,
.child_protocol = &efi_block_io_guid,
+ .init = efi_bl_init,
.bind = efi_bl_bind,
};
diff --git a/lib/efi_driver/efi_uclass.c b/lib/efi_driver/efi_uclass.c
index 74dd0032437..45f93519887 100644
--- a/lib/efi_driver/efi_uclass.c
+++ b/lib/efi_driver/efi_uclass.c
@@ -11,7 +11,7 @@
* The uclass provides the bind, start, and stop entry points for the driver
* binding protocol.
*
- * In bind() and stop() it checks if the controller implements the protocol
+ * In supported() and bind() it checks if the controller implements the protocol
* supported by the EFI driver. In the start() function it calls the bind()
* function of the EFI driver. In the stop() function it destroys the child
* controllers.
@@ -97,10 +97,9 @@ static efi_status_t EFIAPI efi_uc_supported(
ret = check_node_type(controller_handle);
- r = EFI_CALL(systab.boottime->close_protocol(
- controller_handle, bp->ops->protocol,
- this->driver_binding_handle,
- controller_handle));
+ r = efi_close_protocol(controller_handle, bp->ops->protocol,
+ this->driver_binding_handle,
+ controller_handle);
if (r != EFI_SUCCESS)
ret = EFI_UNSUPPORTED;
out:
@@ -144,18 +143,18 @@ static efi_status_t EFIAPI efi_uc_start(
goto out;
}
ret = check_node_type(controller_handle);
- if (ret != EFI_SUCCESS) {
- r = EFI_CALL(systab.boottime->close_protocol(
- controller_handle, bp->ops->protocol,
- this->driver_binding_handle,
- controller_handle));
- if (r != EFI_SUCCESS)
- EFI_PRINT("Failure to close handle\n");
+ if (ret != EFI_SUCCESS)
+ goto err;
+ ret = bp->ops->bind(bp, controller_handle, interface);
+ if (ret == EFI_SUCCESS)
goto out;
- }
- /* TODO: driver specific stuff */
- bp->ops->bind(controller_handle, interface);
+err:
+ r = efi_close_protocol(controller_handle, bp->ops->protocol,
+ this->driver_binding_handle,
+ controller_handle);
+ if (r != EFI_SUCCESS)
+ EFI_PRINT("Failure to close handle\n");
out:
return EFI_EXIT(ret);
@@ -176,9 +175,8 @@ static efi_status_t disconnect_child(efi_handle_t controller_handle,
efi_guid_t *guid_controller = NULL;
efi_guid_t *guid_child_controller = NULL;
- ret = EFI_CALL(systab.boottime->close_protocol(
- controller_handle, guid_controller,
- child_handle, child_handle));
+ ret = efi_close_protocol(controller_handle, guid_controller,
+ child_handle, child_handle);
if (ret != EFI_SUCCESS) {
EFI_PRINT("Cannot close protocol\n");
return ret;
@@ -224,9 +222,10 @@ static efi_status_t EFIAPI efi_uc_stop(
ret = disconnect_child(controller_handle,
child_handle_buffer[i]);
if (ret != EFI_SUCCESS)
- return ret;
+ goto out;
}
- return EFI_SUCCESS;
+ ret = EFI_SUCCESS;
+ goto out;
}
/* Destroy all children */
@@ -245,14 +244,14 @@ static efi_status_t EFIAPI efi_uc_stop(
goto out;
}
}
- ret = EFI_CALL(systab.boottime->free_pool(entry_buffer));
+ ret = efi_free_pool(entry_buffer);
if (ret != EFI_SUCCESS)
log_err("Cannot free EFI memory pool\n");
/* Detach driver from controller */
- ret = EFI_CALL(systab.boottime->close_protocol(
- controller_handle, bp->ops->protocol,
- this->driver_binding_handle, controller_handle));
+ ret = efi_close_protocol(controller_handle, bp->ops->protocol,
+ this->driver_binding_handle,
+ controller_handle);
out:
return EFI_EXIT(ret);
}
@@ -283,7 +282,7 @@ static efi_status_t efi_add_driver(struct driver *drv)
bp->bp.start = efi_uc_start;
bp->bp.stop = efi_uc_stop;
bp->bp.version = 0xffffffff;
- bp->ops = drv->ops;
+ bp->ops = ops;
ret = efi_create_handle(&bp->bp.driver_binding_handle);
if (ret != EFI_SUCCESS) {
@@ -293,13 +292,20 @@ static efi_status_t efi_add_driver(struct driver *drv)
bp->bp.image_handle = bp->bp.driver_binding_handle;
ret = efi_add_protocol(bp->bp.driver_binding_handle,
&efi_guid_driver_binding_protocol, bp);
- if (ret != EFI_SUCCESS) {
- efi_delete_handle(bp->bp.driver_binding_handle);
- free(bp);
- goto out;
+ if (ret != EFI_SUCCESS)
+ goto err;
+ if (ops->init) {
+ ret = ops->init(bp);
+ if (ret != EFI_SUCCESS)
+ goto err;
}
out:
return ret;
+
+err:
+ efi_delete_handle(bp->bp.driver_binding_handle);
+ free(bp);
+ return ret;
}
/**
diff --git a/lib/efi_loader/efi_boottime.c b/lib/efi_loader/efi_boottime.c
index 1bfd094e89f..a56021559bb 100644
--- a/lib/efi_loader/efi_boottime.c
+++ b/lib/efi_loader/efi_boottime.c
@@ -1993,7 +1993,7 @@ efi_status_t efi_load_image_from_path(bool boot_policy,
if (ret != EFI_SUCCESS)
efi_free_pages(addr, pages);
out:
- EFI_CALL(efi_close_protocol(device, guid, efi_root, NULL));
+ efi_close_protocol(device, guid, efi_root, NULL);
if (ret == EFI_SUCCESS) {
*buffer = (void *)(uintptr_t)addr;
*size = buffer_size;
@@ -2290,45 +2290,70 @@ static efi_status_t EFIAPI efi_set_watchdog_timer(unsigned long timeout,
* @agent_handle: handle of the driver
* @controller_handle: handle of the controller
*
- * This function implements the CloseProtocol service.
+ * This is the function implementing the CloseProtocol service is for internal
+ * usage in U-Boot. For API usage wrapper efi_close_protocol_ext() is provided.
*
* See the Unified Extensible Firmware Interface (UEFI) specification for
* details.
*
* Return: status code
*/
-efi_status_t EFIAPI efi_close_protocol(efi_handle_t handle,
- const efi_guid_t *protocol,
- efi_handle_t agent_handle,
- efi_handle_t controller_handle)
+efi_status_t efi_close_protocol(efi_handle_t handle, const efi_guid_t *protocol,
+ efi_handle_t agent_handle,
+ efi_handle_t controller_handle)
{
struct efi_handler *handler;
struct efi_open_protocol_info_item *item;
struct efi_open_protocol_info_item *pos;
- efi_status_t r;
-
- EFI_ENTRY("%p, %pUs, %p, %p", handle, protocol, agent_handle,
- controller_handle);
+ efi_status_t ret;
if (!efi_search_obj(agent_handle) ||
- (controller_handle && !efi_search_obj(controller_handle))) {
- r = EFI_INVALID_PARAMETER;
- goto out;
- }
- r = efi_search_protocol(handle, protocol, &handler);
- if (r != EFI_SUCCESS)
- goto out;
+ (controller_handle && !efi_search_obj(controller_handle)))
+ return EFI_INVALID_PARAMETER;
+ ret = efi_search_protocol(handle, protocol, &handler);
+ if (ret != EFI_SUCCESS)
+ return ret;
- r = EFI_NOT_FOUND;
+ ret = EFI_NOT_FOUND;
list_for_each_entry_safe(item, pos, &handler->open_infos, link) {
if (item->info.agent_handle == agent_handle &&
item->info.controller_handle == controller_handle) {
efi_delete_open_info(item);
- r = EFI_SUCCESS;
+ ret = EFI_SUCCESS;
}
}
-out:
- return EFI_EXIT(r);
+
+ return ret;
+}
+
+/**
+ * efi_close_protocol_ext() - close a protocol
+ * @handle: handle on which the protocol shall be closed
+ * @protocol: GUID of the protocol to close
+ * @agent_handle: handle of the driver
+ * @controller_handle: handle of the controller
+ *
+ * This function implements the CloseProtocol service.
+ *
+ * See the Unified Extensible Firmware Interface (UEFI) specification for
+ * details.
+ *
+ * Return: status code
+ */
+static efi_status_t EFIAPI
+efi_close_protocol_ext(efi_handle_t handle, const efi_guid_t *protocol,
+ efi_handle_t agent_handle,
+ efi_handle_t controller_handle)
+{
+ efi_status_t ret;
+
+ EFI_ENTRY("%p, %pUs, %p, %p", handle, protocol, agent_handle,
+ controller_handle);
+
+ ret = efi_close_protocol(handle, protocol,
+ agent_handle, controller_handle);
+
+ return EFI_EXIT(ret);
}
/**
@@ -2590,35 +2615,31 @@ found:
}
/**
- * efi_install_multiple_protocol_interfaces() - Install multiple protocol
+ * efi_install_multiple_protocol_interfaces_int() - Install multiple protocol
* interfaces
* @handle: handle on which the protocol interfaces shall be installed
- * @...: NULL terminated argument list with pairs of protocol GUIDS and
- * interfaces
+ * @argptr: va_list of args
*
- * This function implements the MultipleProtocolInterfaces service.
- *
- * See the Unified Extensible Firmware Interface (UEFI) specification for
- * details.
+ * Core functionality of efi_install_multiple_protocol_interfaces
+ * Must not be called directly
*
* Return: status code
*/
-efi_status_t EFIAPI efi_install_multiple_protocol_interfaces
- (efi_handle_t *handle, ...)
+static efi_status_t EFIAPI
+efi_install_multiple_protocol_interfaces_int(efi_handle_t *handle,
+ efi_va_list argptr)
{
- EFI_ENTRY("%p", handle);
-
- efi_va_list argptr;
const efi_guid_t *protocol;
void *protocol_interface;
efi_handle_t old_handle;
- efi_status_t r = EFI_SUCCESS;
+ efi_status_t ret = EFI_SUCCESS;
int i = 0;
+ efi_va_list argptr_copy;
if (!handle)
- return EFI_EXIT(EFI_INVALID_PARAMETER);
+ return EFI_INVALID_PARAMETER;
- efi_va_start(argptr, handle);
+ efi_va_copy(argptr_copy, argptr);
for (;;) {
protocol = efi_va_arg(argptr, efi_guid_t*);
if (!protocol)
@@ -2628,104 +2649,212 @@ efi_status_t EFIAPI efi_install_multiple_protocol_interfaces
if (!guidcmp(protocol, &efi_guid_device_path)) {
struct efi_device_path *dp = protocol_interface;
- r = EFI_CALL(efi_locate_device_path(protocol, &dp,
- &old_handle));
- if (r == EFI_SUCCESS &&
+ ret = EFI_CALL(efi_locate_device_path(protocol, &dp,
+ &old_handle));
+ if (ret == EFI_SUCCESS &&
dp->type == DEVICE_PATH_TYPE_END) {
EFI_PRINT("Path %pD already installed\n",
protocol_interface);
- r = EFI_ALREADY_STARTED;
+ ret = EFI_ALREADY_STARTED;
break;
}
}
- r = EFI_CALL(efi_install_protocol_interface(
- handle, protocol,
- EFI_NATIVE_INTERFACE,
- protocol_interface));
- if (r != EFI_SUCCESS)
+ ret = EFI_CALL(efi_install_protocol_interface(handle, protocol,
+ EFI_NATIVE_INTERFACE,
+ protocol_interface));
+ if (ret != EFI_SUCCESS)
break;
i++;
}
- efi_va_end(argptr);
- if (r == EFI_SUCCESS)
- return EFI_EXIT(r);
+ if (ret == EFI_SUCCESS)
+ goto out;
/* If an error occurred undo all changes. */
- efi_va_start(argptr, handle);
for (; i; --i) {
- protocol = efi_va_arg(argptr, efi_guid_t*);
- protocol_interface = efi_va_arg(argptr, void*);
+ protocol = efi_va_arg(argptr_copy, efi_guid_t*);
+ protocol_interface = efi_va_arg(argptr_copy, void*);
EFI_CALL(efi_uninstall_protocol_interface(*handle, protocol,
protocol_interface));
}
- efi_va_end(argptr);
- return EFI_EXIT(r);
+out:
+ efi_va_end(argptr_copy);
+ return ret;
+
}
/**
- * efi_uninstall_multiple_protocol_interfaces() - uninstall multiple protocol
- * interfaces
- * @handle: handle from which the protocol interfaces shall be removed
+ * efi_install_multiple_protocol_interfaces() - Install multiple protocol
+ * interfaces
+ * @handle: handle on which the protocol interfaces shall be installed
* @...: NULL terminated argument list with pairs of protocol GUIDS and
* interfaces
*
- * This function implements the UninstallMultipleProtocolInterfaces service.
+ *
+ * This is the function for internal usage in U-Boot. For the API function
+ * implementing the InstallMultipleProtocol service see
+ * efi_install_multiple_protocol_interfaces_ext()
+ *
+ * Return: status code
+ */
+efi_status_t EFIAPI
+efi_install_multiple_protocol_interfaces(efi_handle_t *handle, ...)
+{
+ efi_status_t ret;
+ efi_va_list argptr;
+
+ efi_va_start(argptr, handle);
+ ret = efi_install_multiple_protocol_interfaces_int(handle, argptr);
+ efi_va_end(argptr);
+ return ret;
+}
+
+/**
+ * efi_install_multiple_protocol_interfaces_ext() - Install multiple protocol
+ * interfaces
+ * @handle: handle on which the protocol interfaces shall be installed
+ * @...: NULL terminated argument list with pairs of protocol GUIDS and
+ * interfaces
+ *
+ * This function implements the MultipleProtocolInterfaces service.
*
* See the Unified Extensible Firmware Interface (UEFI) specification for
* details.
*
* Return: status code
*/
-static efi_status_t EFIAPI efi_uninstall_multiple_protocol_interfaces(
- efi_handle_t handle, ...)
+static efi_status_t EFIAPI
+efi_install_multiple_protocol_interfaces_ext(efi_handle_t *handle, ...)
{
EFI_ENTRY("%p", handle);
-
+ efi_status_t ret;
efi_va_list argptr;
+
+ efi_va_start(argptr, handle);
+ ret = efi_install_multiple_protocol_interfaces_int(handle, argptr);
+ efi_va_end(argptr);
+ return EFI_EXIT(ret);
+}
+
+/**
+ * efi_uninstall_multiple_protocol_interfaces_int() - wrapper for uninstall
+ * multiple protocol
+ * interfaces
+ * @handle: handle from which the protocol interfaces shall be removed
+ * @argptr: va_list of args
+ *
+ * Core functionality of efi_uninstall_multiple_protocol_interfaces
+ * Must not be called directly
+ *
+ * Return: status code
+ */
+static efi_status_t EFIAPI
+efi_uninstall_multiple_protocol_interfaces_int(efi_handle_t handle,
+ efi_va_list argptr)
+{
const efi_guid_t *protocol;
void *protocol_interface;
- efi_status_t r = EFI_SUCCESS;
+ efi_status_t ret;
size_t i = 0;
+ efi_va_list argptr_copy;
if (!handle)
- return EFI_EXIT(EFI_INVALID_PARAMETER);
+ return EFI_INVALID_PARAMETER;
- efi_va_start(argptr, handle);
+ efi_va_copy(argptr_copy, argptr);
for (;;) {
protocol = efi_va_arg(argptr, efi_guid_t*);
if (!protocol)
break;
protocol_interface = efi_va_arg(argptr, void*);
- r = efi_uninstall_protocol(handle, protocol,
- protocol_interface);
- if (r != EFI_SUCCESS)
+ ret = efi_uninstall_protocol(handle, protocol,
+ protocol_interface);
+ if (ret != EFI_SUCCESS)
break;
i++;
}
- efi_va_end(argptr);
- if (r == EFI_SUCCESS) {
+ if (ret == EFI_SUCCESS) {
/* If the last protocol has been removed, delete the handle. */
if (list_empty(&handle->protocols)) {
list_del(&handle->link);
free(handle);
}
- return EFI_EXIT(r);
+ goto out;
}
/* If an error occurred undo all changes. */
- efi_va_start(argptr, handle);
for (; i; --i) {
- protocol = efi_va_arg(argptr, efi_guid_t*);
- protocol_interface = efi_va_arg(argptr, void*);
+ protocol = efi_va_arg(argptr_copy, efi_guid_t*);
+ protocol_interface = efi_va_arg(argptr_copy, void*);
EFI_CALL(efi_install_protocol_interface(&handle, protocol,
EFI_NATIVE_INTERFACE,
protocol_interface));
}
+ /*
+ * If any errors are generated while the protocol interfaces are being
+ * uninstalled, then the protocols uninstalled prior to the error will
+ * be reinstalled using InstallProtocolInterface() and the status code
+ * EFI_INVALID_PARAMETER is returned.
+ */
+ ret = EFI_INVALID_PARAMETER;
+
+out:
+ efi_va_end(argptr_copy);
+ return ret;
+}
+
+/**
+ * efi_uninstall_multiple_protocol_interfaces() - uninstall multiple protocol
+ * interfaces
+ * @handle: handle from which the protocol interfaces shall be removed
+ * @...: NULL terminated argument list with pairs of protocol GUIDS and
+ * interfaces
+ *
+ * This function implements the UninstallMultipleProtocolInterfaces service.
+ *
+ * This is the function for internal usage in U-Boot. For the API function
+ * implementing the UninstallMultipleProtocolInterfaces service see
+ * efi_uninstall_multiple_protocol_interfaces_ext()
+ *
+ * Return: status code
+ */
+efi_status_t EFIAPI
+efi_uninstall_multiple_protocol_interfaces(efi_handle_t handle, ...)
+{
+ efi_status_t ret;
+ efi_va_list argptr;
+
+ efi_va_start(argptr, handle);
+ ret = efi_uninstall_multiple_protocol_interfaces_int(handle, argptr);
efi_va_end(argptr);
+ return ret;
+}
- /* In case of an error always return EFI_INVALID_PARAMETER */
- return EFI_EXIT(EFI_INVALID_PARAMETER);
+/**
+ * efi_uninstall_multiple_protocol_interfaces_ext() - uninstall multiple protocol
+ * interfaces
+ * @handle: handle from which the protocol interfaces shall be removed
+ * @...: NULL terminated argument list with pairs of protocol GUIDS and
+ * interfaces
+ *
+ * This function implements the UninstallMultipleProtocolInterfaces service.
+ *
+ * See the Unified Extensible Firmware Interface (UEFI) specification for
+ * details.
+ *
+ * Return: status code
+ */
+static efi_status_t EFIAPI
+efi_uninstall_multiple_protocol_interfaces_ext(efi_handle_t handle, ...)
+{
+ EFI_ENTRY("%p", handle);
+ efi_status_t ret;
+ efi_va_list argptr;
+
+ efi_va_start(argptr, handle);
+ ret = efi_uninstall_multiple_protocol_interfaces_int(handle, argptr);
+ efi_va_end(argptr);
+ return EFI_EXIT(ret);
}
/**
@@ -3109,11 +3238,10 @@ close_next:
if (info->info.agent_handle !=
(efi_handle_t)image_obj)
continue;
- r = EFI_CALL(efi_close_protocol
- (efiobj, &protocol->guid,
- info->info.agent_handle,
- info->info.controller_handle
- ));
+ r = efi_close_protocol(
+ efiobj, &protocol->guid,
+ info->info.agent_handle,
+ info->info.controller_handle);
if (r != EFI_SUCCESS)
ret = r;
/*
@@ -3377,9 +3505,9 @@ static efi_status_t efi_bind_controller(
r = EFI_CALL(binding_protocol->start(binding_protocol,
controller_handle,
remain_device_path));
- EFI_CALL(efi_close_protocol(driver_image_handle,
- &efi_guid_driver_binding_protocol,
- driver_image_handle, NULL));
+ efi_close_protocol(driver_image_handle,
+ &efi_guid_driver_binding_protocol,
+ driver_image_handle, NULL);
return r;
}
@@ -3730,9 +3858,9 @@ static efi_status_t EFIAPI efi_disconnect_controller(
goto out;
}
}
- EFI_CALL(efi_close_protocol(driver_image_handle,
- &efi_guid_driver_binding_protocol,
- driver_image_handle, NULL));
+ efi_close_protocol(driver_image_handle,
+ &efi_guid_driver_binding_protocol,
+ driver_image_handle, NULL);
r = EFI_SUCCESS;
out:
if (!child_handle)
@@ -3779,15 +3907,15 @@ static struct efi_boot_services efi_boot_services = {
.connect_controller = efi_connect_controller,
.disconnect_controller = efi_disconnect_controller,
.open_protocol = efi_open_protocol,
- .close_protocol = efi_close_protocol,
+ .close_protocol = efi_close_protocol_ext,
.open_protocol_information = efi_open_protocol_information,
.protocols_per_handle = efi_protocols_per_handle,
.locate_handle_buffer = efi_locate_handle_buffer,
.locate_protocol = efi_locate_protocol,
.install_multiple_protocol_interfaces =
- efi_install_multiple_protocol_interfaces,
+ efi_install_multiple_protocol_interfaces_ext,
.uninstall_multiple_protocol_interfaces =
- efi_uninstall_multiple_protocol_interfaces,
+ efi_uninstall_multiple_protocol_interfaces_ext,
.calculate_crc32 = efi_calculate_crc32,
.copy_mem = efi_copy_mem,
.set_mem = efi_set_mem,
diff --git a/lib/efi_loader/efi_capsule.c b/lib/efi_loader/efi_capsule.c
index a6b98f066a0..397e393a188 100644
--- a/lib/efi_loader/efi_capsule.c
+++ b/lib/efi_loader/efi_capsule.c
@@ -159,12 +159,14 @@ efi_fmp_find(efi_guid_t *image_type, u8 image_index, u64 instance,
efi_status_t ret;
for (i = 0, handle = handles; i < no_handles; i++, handle++) {
- ret = EFI_CALL(efi_handle_protocol(
- *handle,
- &efi_guid_firmware_management_protocol,
- (void **)&fmp));
+ struct efi_handler *fmp_handler;
+
+ ret = efi_search_protocol(
+ *handle, &efi_guid_firmware_management_protocol,
+ &fmp_handler);
if (ret != EFI_SUCCESS)
continue;
+ fmp = fmp_handler->protocol_interface;
/* get device's image info */
info_size = 0;
@@ -215,10 +217,6 @@ efi_fmp_find(efi_guid_t *image_type, u8 image_index, u64 instance,
skip:
efi_free_pool(package_version_name);
free(image_info);
- EFI_CALL(efi_close_protocol(
- (efi_handle_t)fmp,
- &efi_guid_firmware_management_protocol,
- NULL, NULL));
if (found)
return fmp;
}
@@ -636,17 +634,18 @@ efi_status_t __weak efi_load_capsule_drivers(void)
if (IS_ENABLED(CONFIG_EFI_CAPSULE_FIRMWARE_FIT)) {
handle = NULL;
- ret = EFI_CALL(efi_install_multiple_protocol_interfaces(
- &handle, &efi_guid_firmware_management_protocol,
- &efi_fmp_fit, NULL));
+ ret = efi_install_multiple_protocol_interfaces(&handle,
+ &efi_guid_firmware_management_protocol,
+ &efi_fmp_fit,
+ NULL);
}
if (IS_ENABLED(CONFIG_EFI_CAPSULE_FIRMWARE_RAW)) {
handle = NULL;
- ret = EFI_CALL(efi_install_multiple_protocol_interfaces(
- &handle,
- &efi_guid_firmware_management_protocol,
- &efi_fmp_raw, NULL));
+ ret = efi_install_multiple_protocol_interfaces(&handle,
+ &efi_guid_firmware_management_protocol,
+ &efi_fmp_raw,
+ NULL);
}
return ret;
diff --git a/lib/efi_loader/efi_console.c b/lib/efi_loader/efi_console.c
index cf9fbd9cb54..3354b217a9a 100644
--- a/lib/efi_loader/efi_console.c
+++ b/lib/efi_loader/efi_console.c
@@ -1278,12 +1278,14 @@ efi_status_t efi_console_register(void)
struct efi_device_path *dp;
/* Install protocols on root node */
- r = EFI_CALL(efi_install_multiple_protocol_interfaces
- (&efi_root,
- &efi_guid_text_output_protocol, &efi_con_out,
- &efi_guid_text_input_protocol, &efi_con_in,
- &efi_guid_text_input_ex_protocol, &efi_con_in_ex,
- NULL));
+ r = efi_install_multiple_protocol_interfaces(&efi_root,
+ &efi_guid_text_output_protocol,
+ &efi_con_out,
+ &efi_guid_text_input_protocol,
+ &efi_con_in,
+ &efi_guid_text_input_ex_protocol,
+ &efi_con_in_ex,
+ NULL);
/* Create console node and install device path protocols */
if (CONFIG_IS_ENABLED(DM_SERIAL)) {
diff --git a/lib/efi_loader/efi_device_path.c b/lib/efi_loader/efi_device_path.c
index ebffb771228..acae007f26f 100644
--- a/lib/efi_loader/efi_device_path.c
+++ b/lib/efi_loader/efi_device_path.c
@@ -936,7 +936,8 @@ struct efi_device_path *efi_dp_part_node(struct blk_desc *desc, int part)
dpsize = sizeof(struct efi_device_path_hard_drive_path);
buf = dp_alloc(dpsize);
- dp_part_node(buf, desc, part);
+ if (buf)
+ dp_part_node(buf, desc, part);
return buf;
}
diff --git a/lib/efi_loader/efi_disk.c b/lib/efi_loader/efi_disk.c
index 39ea1a68a68..cef4e45124e 100644
--- a/lib/efi_loader/efi_disk.c
+++ b/lib/efi_loader/efi_disk.c
@@ -395,7 +395,7 @@ static efi_status_t efi_disk_add_dev(
{
struct efi_disk_obj *diskobj;
struct efi_object *handle;
- const efi_guid_t *guid = NULL;
+ const efi_guid_t *esp_guid = NULL;
efi_status_t ret;
/* Don't add empty devices */
@@ -415,6 +415,11 @@ static efi_status_t efi_disk_add_dev(
struct efi_handler *handler;
void *protocol_interface;
+ if (!node) {
+ ret = EFI_OUT_OF_RESOURCES;
+ goto error;
+ }
+
/* Parent must expose EFI_BLOCK_IO_PROTOCOL */
ret = efi_search_protocol(parent, &efi_block_io_guid, &handler);
if (ret != EFI_SUCCESS)
@@ -434,7 +439,7 @@ static efi_status_t efi_disk_add_dev(
efi_free_pool(node);
diskobj->media.last_block = part_info->size - 1;
if (part_info->bootable & PART_EFI_SYSTEM_PARTITION)
- guid = &efi_system_partition_guid;
+ esp_guid = &efi_system_partition_guid;
} else {
diskobj->dp = efi_dp_from_part(desc, part);
diskobj->media.last_block = desc->lba - 1;
@@ -449,10 +454,16 @@ static efi_status_t efi_disk_add_dev(
* in this case.
*/
handle = &diskobj->header;
- ret = EFI_CALL(efi_install_multiple_protocol_interfaces(
- &handle, &efi_guid_device_path, diskobj->dp,
- &efi_block_io_guid, &diskobj->ops,
- guid, NULL, NULL));
+ ret = efi_install_multiple_protocol_interfaces(
+ &handle,
+ &efi_guid_device_path, diskobj->dp,
+ &efi_block_io_guid, &diskobj->ops,
+ /*
+ * esp_guid must be last entry as it
+ * can be NULL. Its interface is NULL.
+ */
+ esp_guid, NULL,
+ NULL);
if (ret != EFI_SUCCESS)
goto error;
@@ -620,7 +631,7 @@ static int efi_disk_create_part(struct udevice *dev)
*
* @return 0 on success, -1 otherwise
*/
-static int efi_disk_probe(void *ctx, struct event *event)
+int efi_disk_probe(void *ctx, struct event *event)
{
struct udevice *dev;
enum uclass_id id;
@@ -724,7 +735,7 @@ static int efi_disk_delete_part(struct udevice *dev)
*
* @return 0 on success, -1 otherwise
*/
-static int efi_disk_remove(void *ctx, struct event *event)
+int efi_disk_remove(void *ctx, struct event *event)
{
enum uclass_id id;
struct udevice *dev;
@@ -740,27 +751,6 @@ static int efi_disk_remove(void *ctx, struct event *event)
return 0;
}
-efi_status_t efi_disk_init(void)
-{
- int ret;
-
- ret = event_register("efi_disk add", EVT_DM_POST_PROBE,
- efi_disk_probe, NULL);
- if (ret) {
- log_err("Event registration for efi_disk add failed\n");
- return EFI_OUT_OF_RESOURCES;
- }
-
- ret = event_register("efi_disk del", EVT_DM_PRE_REMOVE,
- efi_disk_remove, NULL);
- if (ret) {
- log_err("Event registration for efi_disk del failed\n");
- return EFI_OUT_OF_RESOURCES;
- }
-
- return EFI_SUCCESS;
-}
-
/**
* efi_disk_get_device_name() - get U-Boot device name associated with EFI handle
*
@@ -800,7 +790,8 @@ efi_status_t efi_disk_get_device_name(const efi_handle_t handle, char *buf, int
if (is_partition) {
part_data = dev_get_uclass_plat(dev);
part = part_data->partnum;
- count = snprintf(buf, size, "%s %d:%d", if_typename, diskid, part);
+ count = snprintf(buf, size, "%s %d:%u", if_typename, diskid,
+ part);
} else {
count = snprintf(buf, size, "%s %d", if_typename, diskid);
}
diff --git a/lib/efi_loader/efi_helper.c b/lib/efi_loader/efi_helper.c
index 8ed564e2619..c71e87d1180 100644
--- a/lib/efi_loader/efi_helper.c
+++ b/lib/efi_loader/efi_helper.c
@@ -171,3 +171,22 @@ int efi_link_dev(efi_handle_t handle, struct udevice *dev)
handle->dev = dev;
return dev_tag_set_ptr(dev, DM_TAG_EFI, handle);
}
+
+/**
+ * efi_unlink_dev() - unlink udevice and handle
+ *
+ * @handle: EFI handle to unlink
+ *
+ * Return: 0 on success, negative on failure
+ */
+int efi_unlink_dev(efi_handle_t handle)
+{
+ int ret;
+
+ ret = dev_tag_del(handle->dev, DM_TAG_EFI);
+ if (ret)
+ return ret;
+ handle->dev = NULL;
+
+ return 0;
+}
diff --git a/lib/efi_loader/efi_load_initrd.c b/lib/efi_loader/efi_load_initrd.c
index 3d6044f7604..87fde3f88c2 100644
--- a/lib/efi_loader/efi_load_initrd.c
+++ b/lib/efi_loader/efi_load_initrd.c
@@ -208,14 +208,13 @@ efi_status_t efi_initrd_register(void)
if (ret != EFI_SUCCESS)
return ret;
- ret = EFI_CALL(efi_install_multiple_protocol_interfaces
- (&efi_initrd_handle,
- /* initramfs */
- &efi_guid_device_path, &dp_lf2_handle,
- /* LOAD_FILE2 */
- &efi_guid_load_file2_protocol,
- (void *)&efi_lf2_protocol,
- NULL));
+ ret = efi_install_multiple_protocol_interfaces(&efi_initrd_handle,
+ /* initramfs */
+ &efi_guid_device_path, &dp_lf2_handle,
+ /* LOAD_FILE2 */
+ &efi_guid_load_file2_protocol,
+ (void *)&efi_lf2_protocol,
+ NULL);
return ret;
}
diff --git a/lib/efi_loader/efi_load_options.c b/lib/efi_loader/efi_load_options.c
index 71454f0fc66..3cfddee014e 100644
--- a/lib/efi_loader/efi_load_options.c
+++ b/lib/efi_loader/efi_load_options.c
@@ -27,23 +27,18 @@ efi_status_t efi_set_load_options(efi_handle_t handle,
void *load_options)
{
struct efi_loaded_image *loaded_image_info;
+ struct efi_handler *handler;
efi_status_t ret;
- ret = EFI_CALL(systab.boottime->open_protocol(
- handle,
- &efi_guid_loaded_image,
- (void **)&loaded_image_info,
- efi_root, NULL,
- EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL));
+ ret = efi_search_protocol(handle, &efi_guid_loaded_image, &handler);
+ loaded_image_info = handler->protocol_interface;
if (ret != EFI_SUCCESS)
return EFI_INVALID_PARAMETER;
loaded_image_info->load_options = load_options;
loaded_image_info->load_options_size = load_options_size;
- return EFI_CALL(systab.boottime->close_protocol(handle,
- &efi_guid_loaded_image,
- efi_root, NULL));
+ return EFI_SUCCESS;
}
/**
diff --git a/lib/efi_loader/efi_root_node.c b/lib/efi_loader/efi_root_node.c
index 739c6867f41..a4eb6f493dc 100644
--- a/lib/efi_loader/efi_root_node.c
+++ b/lib/efi_loader/efi_root_node.c
@@ -49,38 +49,38 @@ efi_status_t efi_root_node_register(void)
dp->end.length = sizeof(struct efi_device_path);
/* Create root node and install protocols */
- ret = EFI_CALL(efi_install_multiple_protocol_interfaces
- (&efi_root,
- /* Device path protocol */
- &efi_guid_device_path, dp,
+ ret = efi_install_multiple_protocol_interfaces
+ (&efi_root,
+ /* Device path protocol */
+ &efi_guid_device_path, dp,
#if CONFIG_IS_ENABLED(EFI_DEVICE_PATH_TO_TEXT)
- /* Device path to text protocol */
- &efi_guid_device_path_to_text_protocol,
- (void *)&efi_device_path_to_text,
+ /* Device path to text protocol */
+ &efi_guid_device_path_to_text_protocol,
+ &efi_device_path_to_text,
#endif
-#ifdef CONFIG_EFI_DEVICE_PATH_UTIL
- /* Device path utilities protocol */
- &efi_guid_device_path_utilities_protocol,
- (void *)&efi_device_path_utilities,
+#if CONFIG_IS_ENABLED(EFI_DEVICE_PATH_UTIL)
+ /* Device path utilities protocol */
+ &efi_guid_device_path_utilities_protocol,
+ &efi_device_path_utilities,
#endif
-#ifdef CONFIG_EFI_DT_FIXUP
- /* Device-tree fix-up protocol */
- &efi_guid_dt_fixup_protocol,
- (void *)&efi_dt_fixup_prot,
+#if CONFIG_IS_ENABLED(EFI_DT_FIXUP)
+ /* Device-tree fix-up protocol */
+ &efi_guid_dt_fixup_protocol,
+ &efi_dt_fixup_prot,
#endif
#if CONFIG_IS_ENABLED(EFI_UNICODE_COLLATION_PROTOCOL2)
- &efi_guid_unicode_collation_protocol2,
- (void *)&efi_unicode_collation_protocol2,
+ &efi_guid_unicode_collation_protocol2,
+ &efi_unicode_collation_protocol2,
#endif
#if CONFIG_IS_ENABLED(EFI_LOADER_HII)
- /* HII string protocol */
- &efi_guid_hii_string_protocol,
- (void *)&efi_hii_string,
- /* HII database protocol */
- &efi_guid_hii_database_protocol,
- (void *)&efi_hii_database,
+ /* HII string protocol */
+ &efi_guid_hii_string_protocol,
+ &efi_hii_string,
+ /* HII database protocol */
+ &efi_guid_hii_database_protocol,
+ &efi_hii_database,
#endif
- NULL));
+ NULL);
efi_root->type = EFI_OBJECT_TYPE_U_BOOT_FIRMWARE;
return ret;
}
diff --git a/lib/efi_loader/efi_setup.c b/lib/efi_loader/efi_setup.c
index c633fcd91e3..9d7189336dc 100644
--- a/lib/efi_loader/efi_setup.c
+++ b/lib/efi_loader/efi_setup.c
@@ -198,7 +198,8 @@ static efi_status_t __efi_init_early(void)
if (ret != EFI_SUCCESS)
goto out;
- ret = efi_disk_init();
+ /* Initialize EFI driver uclass */
+ ret = efi_driver_init();
out:
return ret;
}
@@ -319,11 +320,6 @@ efi_status_t efi_init_obj_list(void)
if (ret != EFI_SUCCESS)
goto out;
- /* Initialize EFI driver uclass */
- ret = efi_driver_init();
- if (ret != EFI_SUCCESS)
- goto out;
-
if (IS_ENABLED(CONFIG_EFI_HAVE_CAPSULE_SUPPORT)) {
ret = efi_load_capsule_drivers();
if (ret != EFI_SUCCESS)
diff --git a/lib/efi_loader/efi_string.c b/lib/efi_loader/efi_string.c
index 8bf1e493b89..e21e09c9461 100644
--- a/lib/efi_loader/efi_string.c
+++ b/lib/efi_loader/efi_string.c
@@ -8,6 +8,7 @@
#include <common.h>
#include <charset.h>
#include <efi_loader.h>
+#include <malloc.h>
/**
* efi_create_indexed_name - create a string name with an index
@@ -41,3 +42,26 @@ u16 *efi_create_indexed_name(u16 *buffer, size_t buffer_size, const char *name,
return p;
}
+
+/**
+ * efi_convert_string - Convert an ASCII or UTF-8 string to UTF-16
+ * @str: String to be converted
+ *
+ * Return: Converted string in UTF-16 format. The caller is responsible for
+ * freeing this string when it is no longer needed.
+ */
+efi_string_t efi_convert_string(const char *str)
+{
+ efi_string_t str_16, tmp;
+ size_t sz_16;
+
+ sz_16 = utf8_utf16_strlen(str);
+ str_16 = calloc(sz_16 + 1, sizeof(u16));
+ if (!str_16)
+ return NULL;
+
+ tmp = str_16;
+ utf8_utf16_strcpy(&tmp, str);
+
+ return str_16;
+}
diff --git a/lib/efi_loader/efi_tcg2.c b/lib/efi_loader/efi_tcg2.c
index 99ec3a54867..a525ebf75b5 100644
--- a/lib/efi_loader/efi_tcg2.c
+++ b/lib/efi_loader/efi_tcg2.c
@@ -2053,7 +2053,7 @@ tcg2_measure_gpt_data(struct udevice *dev,
{
efi_status_t ret;
efi_handle_t handle;
- struct efi_handler *dp_handler;
+ struct efi_handler *dp_handler, *io_handler;
struct efi_device_path *orig_device_path;
struct efi_device_path *device_path;
struct efi_device_path *dp;
@@ -2098,10 +2098,10 @@ tcg2_measure_gpt_data(struct udevice *dev,
if (ret != EFI_SUCCESS)
goto out1;
- ret = EFI_CALL(efi_handle_protocol(handle,
- &efi_block_io_guid, (void **)&block_io));
+ ret = efi_search_protocol(handle, &efi_block_io_guid, &io_handler);
if (ret != EFI_SUCCESS)
goto out1;
+ block_io = io_handler->protocol_interface;
gpt_h = memalign(block_io->media->io_align, block_io->media->block_size);
if (!gpt_h) {
@@ -2164,12 +2164,8 @@ tcg2_measure_gpt_data(struct udevice *dev,
}
ret = tcg2_measure_event(dev, 5, EV_EFI_GPT_EVENT, event_size, (u8 *)event);
- if (ret != EFI_SUCCESS)
- goto out2;
out2:
- EFI_CALL(efi_close_protocol((efi_handle_t)block_io, &efi_block_io_guid,
- NULL, NULL));
free(gpt_h);
free(entry);
free(event);
diff --git a/lib/efi_selftest/efi_selftest_events.c b/lib/efi_selftest/efi_selftest_events.c
index 90071536a27..743a6b9154f 100644
--- a/lib/efi_selftest/efi_selftest_events.c
+++ b/lib/efi_selftest/efi_selftest_events.c
@@ -11,7 +11,7 @@
#include <efi_selftest.h>
-static struct efi_event *event_notify;
+static struct efi_event *efi_st_event_notify;
static struct efi_event *event_wait;
static unsigned int timer_ticks;
static struct efi_boot_services *boottime;
@@ -50,7 +50,7 @@ static int setup(const efi_handle_t handle,
ret = boottime->create_event(EVT_TIMER | EVT_NOTIFY_SIGNAL,
TPL_CALLBACK, notify, (void *)&timer_ticks,
- &event_notify);
+ &efi_st_event_notify);
if (ret != EFI_SUCCESS) {
efi_st_error("could not create event\n");
return EFI_ST_FAILURE;
@@ -75,9 +75,9 @@ static int teardown(void)
{
efi_status_t ret;
- if (event_notify) {
- ret = boottime->close_event(event_notify);
- event_notify = NULL;
+ if (efi_st_event_notify) {
+ ret = boottime->close_event(efi_st_event_notify);
+ efi_st_event_notify = NULL;
if (ret != EFI_SUCCESS) {
efi_st_error("could not close event\n");
return EFI_ST_FAILURE;
@@ -112,7 +112,8 @@ static int execute(void)
/* Set 10 ms timer */
timer_ticks = 0;
- ret = boottime->set_timer(event_notify, EFI_TIMER_PERIODIC, 100000);
+ ret = boottime->set_timer(efi_st_event_notify, EFI_TIMER_PERIODIC,
+ 100000);
if (ret != EFI_SUCCESS) {
efi_st_error("Could not set timer\n");
return EFI_ST_FAILURE;
@@ -146,14 +147,15 @@ static int execute(void)
efi_st_error("Incorrect timing of events\n");
return EFI_ST_FAILURE;
}
- ret = boottime->set_timer(event_notify, EFI_TIMER_STOP, 0);
+ ret = boottime->set_timer(efi_st_event_notify, EFI_TIMER_STOP, 0);
if (ret != EFI_SUCCESS) {
efi_st_error("Could not cancel timer\n");
return EFI_ST_FAILURE;
}
/* Set 10 ms timer */
timer_ticks = 0;
- ret = boottime->set_timer(event_notify, EFI_TIMER_RELATIVE, 100000);
+ ret = boottime->set_timer(efi_st_event_notify, EFI_TIMER_RELATIVE,
+ 100000);
if (ret != EFI_SUCCESS) {
efi_st_error("Could not set timer\n");
return EFI_ST_FAILURE;
diff --git a/lib/efi_selftest/efi_selftest_exitbootservices.c b/lib/efi_selftest/efi_selftest_exitbootservices.c
index f5e0d9da89b..11b43fdd90b 100644
--- a/lib/efi_selftest/efi_selftest_exitbootservices.c
+++ b/lib/efi_selftest/efi_selftest_exitbootservices.c
@@ -26,7 +26,7 @@ struct notification_context {
};
static struct efi_boot_services *boottime;
-static struct efi_event *event_notify;
+static struct efi_event *efi_st_event_notify;
struct notification_record record;
struct notification_context context_before = {
@@ -75,7 +75,7 @@ static int setup(const efi_handle_t handle,
ret = boottime->create_event(EVT_SIGNAL_EXIT_BOOT_SERVICES,
TPL_CALLBACK, ebs_notify,
&context,
- &event_notify);
+ &efi_st_event_notify);
if (ret != EFI_SUCCESS) {
efi_st_error("could not create event\n");
return EFI_ST_FAILURE;
@@ -83,7 +83,7 @@ static int setup(const efi_handle_t handle,
ret = boottime->create_event_ex(0, TPL_CALLBACK, ebs_notify,
&context_before,
&guid_before_exit_boot_services,
- &event_notify);
+ &efi_st_event_notify);
if (ret != EFI_SUCCESS) {
efi_st_error("could not create event\n");
return EFI_ST_FAILURE;
diff --git a/lib/efi_selftest/efi_selftest_tpl.c b/lib/efi_selftest/efi_selftest_tpl.c
index f4e467267e5..909c78a1c23 100644
--- a/lib/efi_selftest/efi_selftest_tpl.c
+++ b/lib/efi_selftest/efi_selftest_tpl.c
@@ -10,8 +10,8 @@
#include <efi_selftest.h>
-static struct efi_event *event_notify;
-static struct efi_event *event_wait;
+static struct efi_event *efi_st_event_notify;
+static struct efi_event *efi_st_event_wait;
static unsigned int notification_count;
static struct efi_boot_services *boottime;
@@ -49,13 +49,14 @@ static int setup(const efi_handle_t handle,
ret = boottime->create_event(EVT_TIMER | EVT_NOTIFY_SIGNAL,
TPL_CALLBACK, notify,
(void *)&notification_count,
- &event_notify);
+ &efi_st_event_notify);
if (ret != EFI_SUCCESS) {
efi_st_error("could not create event\n");
return EFI_ST_FAILURE;
}
ret = boottime->create_event(EVT_TIMER | EVT_NOTIFY_WAIT,
- TPL_NOTIFY, notify, NULL, &event_wait);
+ TPL_NOTIFY, notify, NULL,
+ &efi_st_event_wait);
if (ret != EFI_SUCCESS) {
efi_st_error("could not create event\n");
return EFI_ST_FAILURE;
@@ -74,17 +75,17 @@ static int teardown(void)
{
efi_status_t ret;
- if (event_notify) {
- ret = boottime->close_event(event_notify);
- event_notify = NULL;
+ if (efi_st_event_notify) {
+ ret = boottime->close_event(efi_st_event_notify);
+ efi_st_event_notify = NULL;
if (ret != EFI_SUCCESS) {
efi_st_error("could not close event\n");
return EFI_ST_FAILURE;
}
}
- if (event_wait) {
- ret = boottime->close_event(event_wait);
- event_wait = NULL;
+ if (efi_st_event_wait) {
+ ret = boottime->close_event(efi_st_event_wait);
+ efi_st_event_wait = NULL;
if (ret != EFI_SUCCESS) {
efi_st_error("could not close event\n");
return EFI_ST_FAILURE;
@@ -116,24 +117,26 @@ static int execute(void)
/* Set 10 ms timer */
notification_count = 0;
- ret = boottime->set_timer(event_notify, EFI_TIMER_PERIODIC, 100000);
+ ret = boottime->set_timer(efi_st_event_notify, EFI_TIMER_PERIODIC,
+ 100000);
if (ret != EFI_SUCCESS) {
efi_st_error("Could not set timer\n");
return EFI_ST_FAILURE;
}
/* Set 100 ms timer */
- ret = boottime->set_timer(event_wait, EFI_TIMER_RELATIVE, 1000000);
+ ret = boottime->set_timer(efi_st_event_wait, EFI_TIMER_RELATIVE,
+ 1000000);
if (ret != EFI_SUCCESS) {
efi_st_error("Could not set timer\n");
return EFI_ST_FAILURE;
}
index = 5;
- ret = boottime->wait_for_event(1, &event_wait, &index);
+ ret = boottime->wait_for_event(1, &efi_st_event_wait, &index);
if (ret != EFI_SUCCESS) {
efi_st_error("Could not wait for event\n");
return EFI_ST_FAILURE;
}
- ret = boottime->check_event(event_wait);
+ ret = boottime->check_event(efi_st_event_wait);
if (ret != EFI_NOT_READY) {
efi_st_error("Signaled state was not cleared.\n");
efi_st_printf("ret = %u\n", (unsigned int)ret);
@@ -150,7 +153,7 @@ static int execute(void)
efi_st_error("Incorrect timing of events\n");
return EFI_ST_FAILURE;
}
- ret = boottime->set_timer(event_notify, EFI_TIMER_STOP, 0);
+ ret = boottime->set_timer(efi_st_event_notify, EFI_TIMER_STOP, 0);
if (ret != EFI_SUCCESS) {
efi_st_error("Could not cancel timer\n");
return EFI_ST_FAILURE;
@@ -163,19 +166,21 @@ static int execute(void)
}
/* Set 10 ms timer */
notification_count = 0;
- ret = boottime->set_timer(event_notify, EFI_TIMER_PERIODIC, 100000);
+ ret = boottime->set_timer(efi_st_event_notify, EFI_TIMER_PERIODIC,
+ 100000);
if (ret != EFI_SUCCESS) {
efi_st_error("Could not set timer\n");
return EFI_ST_FAILURE;
}
/* Set 100 ms timer */
- ret = boottime->set_timer(event_wait, EFI_TIMER_RELATIVE, 1000000);
+ ret = boottime->set_timer(efi_st_event_wait, EFI_TIMER_RELATIVE,
+ 1000000);
if (ret != EFI_SUCCESS) {
efi_st_error("Could not set timer\n");
return EFI_ST_FAILURE;
}
do {
- ret = boottime->check_event(event_wait);
+ ret = boottime->check_event(efi_st_event_wait);
} while (ret == EFI_NOT_READY);
if (ret != EFI_SUCCESS) {
efi_st_error("Could not check event\n");
@@ -189,14 +194,14 @@ static int execute(void)
return EFI_ST_FAILURE;
}
/* Set 1 ms timer */
- ret = boottime->set_timer(event_wait, EFI_TIMER_RELATIVE, 1000);
+ ret = boottime->set_timer(efi_st_event_wait, EFI_TIMER_RELATIVE, 1000);
if (ret != EFI_SUCCESS) {
efi_st_error("Could not set timer\n");
return EFI_ST_FAILURE;
}
/* Restore the old TPL level */
boottime->restore_tpl(TPL_APPLICATION);
- ret = boottime->wait_for_event(1, &event_wait, &index);
+ ret = boottime->wait_for_event(1, &efi_st_event_wait, &index);
if (ret != EFI_SUCCESS) {
efi_st_error("Could not wait for event\n");
return EFI_ST_FAILURE;
@@ -208,7 +213,7 @@ static int execute(void)
efi_st_error("Queued timer event did not fire\n");
return EFI_ST_FAILURE;
}
- ret = boottime->set_timer(event_wait, EFI_TIMER_STOP, 0);
+ ret = boottime->set_timer(efi_st_event_wait, EFI_TIMER_STOP, 0);
if (ret != EFI_SUCCESS) {
efi_st_error("Could not cancel timer\n");
return EFI_ST_FAILURE;
diff --git a/lib/efi_selftest/efi_selftest_watchdog.c b/lib/efi_selftest/efi_selftest_watchdog.c
index a352d4a5adf..4d7ed5a54bb 100644
--- a/lib/efi_selftest/efi_selftest_watchdog.c
+++ b/lib/efi_selftest/efi_selftest_watchdog.c
@@ -28,8 +28,8 @@ struct notify_context {
unsigned int timer_ticks;
};
-static struct efi_event *event_notify;
-static struct efi_event *event_wait;
+static struct efi_event *efi_st_event_notify;
+static struct efi_event *efi_st_event_wait;
static struct efi_boot_services *boottime;
static struct notify_context notification_context;
static bool watchdog_reset;
@@ -79,13 +79,14 @@ static int setup(const efi_handle_t handle,
ret = boottime->create_event(EVT_TIMER | EVT_NOTIFY_SIGNAL,
TPL_CALLBACK, notify,
(void *)&notification_context,
- &event_notify);
+ &efi_st_event_notify);
if (ret != EFI_SUCCESS) {
efi_st_error("could not create event\n");
return EFI_ST_FAILURE;
}
ret = boottime->create_event(EVT_TIMER | EVT_NOTIFY_WAIT,
- TPL_CALLBACK, notify, NULL, &event_wait);
+ TPL_CALLBACK, notify, NULL,
+ &efi_st_event_wait);
if (ret != EFI_SUCCESS) {
efi_st_error("could not create event\n");
return EFI_ST_FAILURE;
@@ -138,17 +139,17 @@ static int teardown(void)
efi_st_error("Setting watchdog timer failed\n");
return EFI_ST_FAILURE;
}
- if (event_notify) {
- ret = boottime->close_event(event_notify);
- event_notify = NULL;
+ if (efi_st_event_notify) {
+ ret = boottime->close_event(efi_st_event_notify);
+ efi_st_event_notify = NULL;
if (ret != EFI_SUCCESS) {
efi_st_error("Could not close event\n");
return EFI_ST_FAILURE;
}
}
- if (event_wait) {
- ret = boottime->close_event(event_wait);
- event_wait = NULL;
+ if (efi_st_event_wait) {
+ ret = boottime->close_event(efi_st_event_wait);
+ efi_st_event_wait = NULL;
if (ret != EFI_SUCCESS) {
efi_st_error("Could not close event\n");
return EFI_ST_FAILURE;
@@ -181,21 +182,22 @@ static int execute(void)
}
if (watchdog_reset) {
/* Set 600 ms timer */
- ret = boottime->set_timer(event_notify, EFI_TIMER_PERIODIC,
- 6000000);
+ ret = boottime->set_timer(efi_st_event_notify,
+ EFI_TIMER_PERIODIC, 6000000);
if (ret != EFI_SUCCESS) {
efi_st_error("Could not set timer\n");
return EFI_ST_FAILURE;
}
}
/* Set 1350 ms timer */
- ret = boottime->set_timer(event_wait, EFI_TIMER_RELATIVE, 13500000);
+ ret = boottime->set_timer(efi_st_event_wait, EFI_TIMER_RELATIVE,
+ 13500000);
if (ret != EFI_SUCCESS) {
efi_st_error("Could not set timer\n");
return EFI_ST_FAILURE;
}
- ret = boottime->wait_for_event(1, &event_wait, &index);
+ ret = boottime->wait_for_event(1, &efi_st_event_wait, &index);
if (ret != EFI_SUCCESS) {
efi_st_error("Could not wait for event\n");
return EFI_ST_FAILURE;
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-15 01:27:06 +0000