All efi objects are presented as DM devices, either existing device types or efi-specific, and efi_handle_t is an opaque pointer to "struct udevice."

We still maintain efi_obj_list as it is quite inefficient to traverse the DM hierarchy to find any efi objects, which are just part of it.

All efi protocols are also presented as DM devices, replacing "struct efi_handler" with "struct udevice." So searching for an efi protocol is nothing but traversing child nodes under a device.

Signed-off-by: AKASHI Takahiro takahiro.akashi@linaro.org --- include/dm/device.h | 3 + include/dm/uclass-id.h | 2 + include/efi.h | 4 +- include/efi_loader.h | 37 +-- lib/efi_loader/efi_boottime.c | 544 ++++++++++++++++++++++++---------- 5 files changed, 400 insertions(+), 190 deletions(-)

diff --git a/include/dm/device.h b/include/dm/device.h index 27a6d7b9fdb0..0d82402c8e70 100644 --- a/include/dm/device.h +++ b/include/dm/device.h @@ -146,6 +146,9 @@ struct udevice { #ifdef CONFIG_DEVRES struct list_head devres_head; #endif +#ifdef CONFIG_EFI_LOADER + void *efi_obj; +#endif };

/* Maximum sequence number supported */ diff --git a/include/dm/uclass-id.h b/include/dm/uclass-id.h index f3bafb3c6353..fb0ab40891c8 100644 --- a/include/dm/uclass-id.h +++ b/include/dm/uclass-id.h @@ -40,6 +40,8 @@ enum uclass_id { UCLASS_DISPLAY, /* Display (e.g. DisplayPort, HDMI) */ UCLASS_DMA, /* Direct Memory Access */ UCLASS_EFI, /* EFI managed devices */ + UCLASS_EFI_OBJECT, /* EFI managed objects */ + UCLASS_EFI_PROTOCOL, /* EFI managed protocols */ UCLASS_ETH, /* Ethernet device */ UCLASS_FIRMWARE, /* Firmware */ UCLASS_FS_FIRMWARE_LOADER, /* Generic loader */ diff --git a/include/efi.h b/include/efi.h index b5e2c64f38b5..58902299a9a0 100644 --- a/include/efi.h +++ b/include/efi.h @@ -96,7 +96,9 @@ typedef struct { typedef unsigned long efi_status_t; typedef u64 efi_physical_addr_t; typedef u64 efi_virtual_addr_t; -typedef struct efi_object *efi_handle_t; +/* Eventually this should be 'void *' */ +struct udevice; +typedef struct udevice *efi_handle_t;

#define EFI_GUID(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7) \ {{ (a) & 0xff, ((a) >> 8) & 0xff, ((a) >> 16) & 0xff, \ diff --git a/include/efi_loader.h b/include/efi_loader.h index 3077a1e9d58b..4d5e22564a72 100644 --- a/include/efi_loader.h +++ b/include/efi_loader.h @@ -167,38 +167,12 @@ struct efi_open_protocol_info_item { * protocol GUID to the respective protocol interface */ struct efi_handler { - /* Link to the list of protocols of a handle */ - struct list_head link; const efi_guid_t *guid; void *protocol_interface; /* Link to the list of open protocol info items */ struct list_head open_infos; };

-/** - * struct efi_object - dereferenced EFI handle - * - * @link: pointers to put the handle into a linked list - * @protocols: linked list with the protocol interfaces installed on this - * handle - * - * UEFI offers a flexible and expandable object model. The objects in the UEFI - * API are devices, drivers, and loaded images. struct efi_object is our storage - * structure for these objects. - * - * When including this structure into a larger structure always put it first so - * that when deleting a handle the whole encompassing structure can be freed. - * - * A pointer to this structure is referred to as a handle. Typedef efi_handle_t - * has been created for such pointers. - */ -struct efi_object { - /* Every UEFI object is part of a global object list */ - struct list_head link; - /* The list of protocols */ - struct list_head protocols; -}; - /** * struct efi_loaded_image_obj - handle of a loaded image * @@ -209,7 +183,6 @@ struct efi_object { * @entry: entry address of the relocated image */ struct efi_loaded_image_obj { - struct efi_object header; void *reloc_base; aligned_u64 reloc_size; efi_status_t exit_status; @@ -312,18 +285,18 @@ void efi_restore_gd(void); void efi_runtime_relocate(ulong offset, struct efi_mem_desc *map); /* Call this to set the current device name */ void efi_set_bootdev(const char *dev, const char *devnr, const char *path); +/* Go through all the efi objects and call func() for each */ +efi_status_t efi_foreach_dev(int (*func)(struct udevice *, void *), void *arg); /* Add a new object to the object list. */ -void efi_add_handle(efi_handle_t obj); +efi_status_t efi_add_handle(struct udevice *dev); /* Create handle */ -efi_status_t efi_create_handle(efi_handle_t *handle); +efi_status_t efi_create_handle(efi_handle_t *handle, char *name); /* Delete handle */ void efi_delete_handle(efi_handle_t obj); -/* Call this to validate a handle and find the EFI object for it */ -struct efi_object *efi_search_obj(const efi_handle_t handle); /* Find a protocol on a handle */ efi_status_t efi_search_protocol(const efi_handle_t handle, const efi_guid_t *protocol_guid, - struct efi_handler **handler); + struct udevice **protocol); /* Install new protocol on a handle */ efi_status_t efi_add_protocol(const efi_handle_t handle, const efi_guid_t *protocol, diff --git a/lib/efi_loader/efi_boottime.c b/lib/efi_loader/efi_boottime.c index 291bc1bd35f9..d23e4fbbdf23 100644 --- a/lib/efi_loader/efi_boottime.c +++ b/lib/efi_loader/efi_boottime.c @@ -7,6 +7,10 @@

#include <common.h> #include <div64.h> +#include <dm.h> +#include <dm/device-internal.h> +#include <dm/lists.h> +#include <dm/root.h> #include <efi_loader.h> #include <environment.h> #include <malloc.h> @@ -17,6 +21,13 @@

DECLARE_GLOBAL_DATA_PTR;

+struct efi_object { + /* Every UEFI object is part of a global object list */ + struct list_head link; + /* The backing uclass device */ + struct udevice *dev; +}; + /* Task priority level */ static efi_uintn_t efi_tpl = TPL_APPLICATION;

@@ -418,70 +429,125 @@ static efi_status_t EFIAPI efi_free_pool_ext(void *buffer) return EFI_EXIT(r); }

+static bool efi_is_valid(efi_handle_t handle) +{ + struct efi_object *efiobj; + + list_for_each_entry(efiobj, &efi_obj_list, link) { + if (efiobj->dev == handle) + return true; + } + + return false; +} + +/** + * efi_foreach_dev() + */ +efi_status_t efi_foreach_dev(int (*func)(struct udevice *, void *), void *arg) +{ + int ret; + struct efi_object *efiobj; + + list_for_each_entry(efiobj, &efi_obj_list, link) { + ret = (*func)(efiobj->dev, arg); + if (ret == 1) + return EFI_SUCCESS; + } + + return EFI_NOT_FOUND; +} + /** * efi_add_handle() - add a new object to the object list - * @obj: object to be added + * @handle: udevice to be added as object * * The protocols list is initialized. The object handle is set. */ -void efi_add_handle(efi_handle_t handle) +efi_status_t efi_add_handle(struct udevice *dev) { - if (!handle) - return; - INIT_LIST_HEAD(&handle->protocols); - list_add_tail(&handle->link, &efi_obj_list); + struct efi_object *efi_obj; + + if (!dev) + return EFI_INVALID_PARAMETER; + + efi_obj = calloc(1, sizeof(struct efi_object)); + if (!efi_obj) + return EFI_OUT_OF_RESOURCES; + + efi_obj->dev = dev; + dev->efi_obj = efi_obj; + list_add_tail(&efi_obj->link, &efi_obj_list); + + return EFI_SUCCESS; }

/** * efi_create_handle() - create handle * @handle: new handle + * @name: name * * Return: status code */ -efi_status_t efi_create_handle(efi_handle_t *handle) +efi_status_t efi_create_handle(efi_handle_t *handle, char *name) { - struct efi_object *obj; + struct udevice *dev; + efi_status_t ret; + + if (!handle) + return EFI_INVALID_PARAMETER;

- obj = calloc(1, sizeof(struct efi_object)); - if (!obj) + ret = device_bind_driver(dm_root(), "efi_dumb_object", name, &dev); + if (ret) return EFI_OUT_OF_RESOURCES;

- efi_add_handle(obj); - *handle = obj; + ret = efi_add_handle(dev); + if (ret) +#ifdef CONFIG_DM_DEVICE_REMOVE + device_unbind(dev); +#else + 0; +#endif + else + *handle = dev;

- return EFI_SUCCESS; + return ret; }

/** * efi_search_protocol() - find a protocol on a handle. * @handle: handle * @protocol_guid: GUID of the protocol - * @handler: reference to the protocol + * @protocol: reference to the protocol * * Return: status code */ efi_status_t efi_search_protocol(const efi_handle_t handle, const efi_guid_t *protocol_guid, - struct efi_handler **handler) + struct udevice **protocol) { - struct efi_object *efiobj; - struct list_head *lhandle; + struct udevice *dev, *child; + struct efi_handler *handler;

if (!handle || !protocol_guid) return EFI_INVALID_PARAMETER; - efiobj = efi_search_obj(handle); - if (!efiobj) + + if (!efi_is_valid(handle)) return EFI_INVALID_PARAMETER; - list_for_each(lhandle, &efiobj->protocols) { - struct efi_handler *protocol; + dev = handle; + + list_for_each_entry(child, &dev->child_head, sibling_node) { + if (child->driver->id != UCLASS_EFI_PROTOCOL) + continue;

- protocol = list_entry(lhandle, struct efi_handler, link); - if (!guidcmp(protocol->guid, protocol_guid)) { - if (handler) - *handler = protocol; + handler = child->uclass_platdata; + if (!guidcmp(handler->guid, protocol_guid)) { + if (protocol) + *protocol = child; return EFI_SUCCESS; } } + return EFI_NOT_FOUND; }

@@ -494,21 +560,33 @@ efi_status_t efi_search_protocol(const efi_handle_t handle, * Return: status code */ efi_status_t efi_remove_protocol(const efi_handle_t handle, - const efi_guid_t *protocol, + const efi_guid_t *protocol_guid, void *protocol_interface) { + struct udevice *protocol; struct efi_handler *handler; efi_status_t ret;

- ret = efi_search_protocol(handle, protocol, &handler); + ret = efi_search_protocol(handle, protocol_guid, &protocol); if (ret != EFI_SUCCESS) return ret; - if (guidcmp(handler->guid, protocol)) + + handler = protocol->uclass_platdata; + if (guidcmp(handler->guid, protocol_guid)) return EFI_INVALID_PARAMETER; + if (handler->protocol_interface != protocol_interface) return EFI_INVALID_PARAMETER; + +#if 1 /* FIXME */ + device_free(protocol); +#ifdef CONFIG_DM_DEVICE_REMOVE + device_unbind(protocol); +#endif +#else list_del(&handler->link); free(handler); +#endif return EFI_SUCCESS; }

@@ -520,24 +598,46 @@ efi_status_t efi_remove_protocol(const efi_handle_t handle, */ efi_status_t efi_remove_all_protocols(const efi_handle_t handle) { - struct efi_object *efiobj; - struct efi_handler *protocol; - struct efi_handler *pos; + struct udevice *dev, *child, *pos; + struct efi_handler *handler;

- efiobj = efi_search_obj(handle); - if (!efiobj) + if (!efi_is_valid(handle)) return EFI_INVALID_PARAMETER; - list_for_each_entry_safe(protocol, pos, &efiobj->protocols, link) { + dev = handle; + + list_for_each_entry_safe(child, pos, &dev->child_head, sibling_node) { efi_status_t ret;

- ret = efi_remove_protocol(handle, protocol->guid, - protocol->protocol_interface); + if (child->driver->id != UCLASS_EFI_PROTOCOL) + continue; + + handler = child->uclass_platdata; + ret = efi_remove_protocol(handle, handler->guid, + handler->protocol_interface); if (ret != EFI_SUCCESS) return ret; } return EFI_SUCCESS; }

+static void efi_remove_handle(efi_handle_t handle) +{ + struct udevice *dev = handle; + struct efi_object *efi_obj = dev->efi_obj; + + list_del(&efi_obj->link); + free(efi_obj); + + /* free only if internal object */ + if (dev->driver->id == UCLASS_EFI_OBJECT) { +#ifdef CONFIG_DM_DEVICE_REMOVE + device_unbind(dev); +#endif + } + + /* native device handle should be taken care of by caller */ +} + /** * efi_delete_handle() - delete handle * @@ -547,9 +647,9 @@ void efi_delete_handle(efi_handle_t handle) { if (!handle) return; + efi_remove_all_protocols(handle); - list_del(&handle->link); - free(handle); + efi_remove_handle(handle); }

/** @@ -923,24 +1023,6 @@ static efi_status_t EFIAPI efi_check_event(struct efi_event *event) return EFI_EXIT(EFI_NOT_READY); }

-/** - * efi_search_obj() - find the internal EFI object for a handle - * @handle: handle to find - * - * Return: EFI object - */ -struct efi_object *efi_search_obj(const efi_handle_t handle) -{ - struct efi_object *efiobj; - - list_for_each_entry(efiobj, &efi_obj_list, link) { - if (efiobj == handle) - return efiobj; - } - - return NULL; -} - /** * efi_open_protocol_info_entry() - create open protocol info entry and add it * to a protocol @@ -976,6 +1058,88 @@ static efi_status_t efi_delete_open_info( return EFI_SUCCESS; }

+/* FIXME */ +extern const efi_guid_t efi_guid_text_input_ex_protocol; +extern const efi_guid_t efi_guid_text_input_protocol; +extern const efi_guid_t efi_guid_text_output_protocol; +extern const efi_guid_t efi_gop_guid; +extern const efi_guid_t efi_net_guid; +extern const efi_guid_t efi_pxe_guid; + +/* TODO: add entries one by one */ +static struct { + const efi_guid_t *guid; + const char *drv_name; +} protocol_list[] = { + { + .guid = &efi_guid_text_input_ex_protocol, + .drv_name = "efi_simple_text_input_ex", + }, + { + .guid = &efi_guid_text_input_protocol, + .drv_name = "efi_simple_text_input", + }, + { + .guid = &efi_guid_text_output_protocol, + .drv_name = "efi_simple_text_output", + }, + { + .guid = &efi_guid_device_path, + .drv_name = "efi_device_path", + }, + { + .guid = &efi_guid_device_path_to_text_protocol, + .drv_name = "efi_device_path_to_text", + }, + { + .guid = &efi_guid_device_path_utilities_protocol, + .drv_name = "efi_device_path_utils", + }, +#if defined(CONFIG_LCD) || defined(CONFIG_DM_VIDEO) + { + .guid = &efi_gop_guid, + .drv_name = "efi_gop", + }, +#endif +#if defined(CONFIG_NET) + { + .guid = &efi_net_guid, + .drv_name = "efi_net", + }, + { + .guid = &efi_net_guid, + .drv_name = "efi_pxe", + }, +#endif + { + .guid = &efi_guid_unicode_collation_protocol, + .drv_name = "efi_unicode_collation", + }, + { + .guid = &efi_block_io_guid, + .drv_name = "efi_disk", + }, + { + .guid = &efi_simple_file_system_protocol_guid, + .drv_name = "efi_simple_file_system", + }, + { + .guid = &efi_guid_driver_binding_protocol, + .drv_name = "efi_driver_binding", + }, +}; + +static const char *get_protocol_drv_name(const efi_guid_t *guid) +{ + int i; + + for (i = 0; i < ARRAY_SIZE(protocol_list); i++) + if (!guidcmp(protocol_list[i].guid, guid)) + return protocol_list[i].drv_name; + + return "efi_protocol"; +} + /** * efi_add_protocol() - install new protocol on a handle * @handle: handle on which the protocol shall be installed @@ -985,28 +1149,36 @@ static efi_status_t efi_delete_open_info( * Return: status code */ efi_status_t efi_add_protocol(const efi_handle_t handle, - const efi_guid_t *protocol, + const efi_guid_t *protocol_guid, void *protocol_interface) { - struct efi_object *efiobj; + struct udevice *dev, *protocol; struct efi_handler *handler; efi_status_t ret;

- efiobj = efi_search_obj(handle); - if (!efiobj) + if (!efi_is_valid(handle)) return EFI_INVALID_PARAMETER; - ret = efi_search_protocol(handle, protocol, NULL); + dev = handle; + + ret = efi_search_protocol(handle, protocol_guid, NULL); if (ret != EFI_NOT_FOUND) return EFI_INVALID_PARAMETER; - handler = calloc(1, sizeof(struct efi_handler)); - if (!handler) + + ret = device_bind_driver(dev, get_protocol_drv_name(protocol_guid), + "(PROTO)", &protocol); + if (ret) return EFI_OUT_OF_RESOURCES; - handler->guid = protocol; + + handler = protocol->uclass_platdata; + handler->guid = protocol_guid; handler->protocol_interface = protocol_interface; INIT_LIST_HEAD(&handler->open_infos); - list_add_tail(&handler->link, &efiobj->protocols); - if (!guidcmp(&efi_guid_device_path, protocol)) + + device_probe(protocol); + + if (!guidcmp(&efi_guid_device_path, protocol_guid)) EFI_PRINT("installed device path '%pD'\n", protocol_interface); + return EFI_SUCCESS; }

@@ -1042,7 +1214,7 @@ static efi_status_t EFIAPI efi_install_protocol_interface(

/* Create new handle if requested. */ if (!*handle) { - r = efi_create_handle(handle); + r = efi_create_handle(handle, "(NO NAME)"); if (r != EFI_SUCCESS) goto out; debug("%sEFI: new handle %p\n", indent_string(nesting_level), @@ -1073,13 +1245,20 @@ static efi_status_t efi_get_drivers(efi_handle_t handle, efi_uintn_t *number_of_drivers, efi_handle_t **driver_handle_buffer) { + struct udevice *dev, *child; struct efi_handler *handler; struct efi_open_protocol_info_item *item; efi_uintn_t count = 0, i; bool duplicate;

+ dev = handle; + /* Count all driver associations */ - list_for_each_entry(handler, &handle->protocols, link) { + list_for_each_entry(child, &dev->child_head, sibling_node) { + if (child->driver->id != UCLASS_EFI_PROTOCOL) + continue; + + handler = child->uclass_platdata; if (protocol && guidcmp(handler->guid, protocol)) continue; list_for_each_entry(item, &handler->open_infos, link) { @@ -1097,7 +1276,11 @@ static efi_status_t efi_get_drivers(efi_handle_t handle, if (!*driver_handle_buffer) return EFI_OUT_OF_RESOURCES; /* Collect unique driver handles */ - list_for_each_entry(handler, &handle->protocols, link) { + list_for_each_entry(child, &dev->child_head, sibling_node) { + if (child->driver->id != UCLASS_EFI_PROTOCOL) + continue; + + handler = child->uclass_platdata; if (protocol && guidcmp(handler->guid, protocol)) continue; list_for_each_entry(item, &handler->open_infos, link) { @@ -1173,28 +1356,27 @@ static efi_status_t efi_disconnect_all_drivers * * Return: status code */ -static efi_status_t efi_uninstall_protocol - (efi_handle_t handle, const efi_guid_t *protocol, - void *protocol_interface) +static efi_status_t efi_uninstall_protocol(efi_handle_t handle, + const efi_guid_t *protocol_guid, + void *protocol_interface) { - struct efi_object *efiobj; + struct udevice *protocol; struct efi_handler *handler; struct efi_open_protocol_info_item *item; struct efi_open_protocol_info_item *pos; efi_status_t r;

- /* Check handle */ - efiobj = efi_search_obj(handle); - if (!efiobj) { - r = EFI_INVALID_PARAMETER; - goto out; - } + if (!efi_is_valid(handle)) + return EFI_INVALID_PARAMETER; + /* Find the protocol on the handle */ - r = efi_search_protocol(handle, protocol, &handler); + r = efi_search_protocol(handle, protocol_guid, &protocol); if (r != EFI_SUCCESS) goto out; + handler = protocol->uclass_platdata; + /* Disconnect controllers */ - efi_disconnect_all_drivers(efiobj, protocol, NULL); + efi_disconnect_all_drivers(handle, protocol_guid, NULL); if (!list_empty(&handler->open_infos)) { r = EFI_ACCESS_DENIED; goto out; @@ -1211,7 +1393,7 @@ static efi_status_t efi_uninstall_protocol r = EFI_ACCESS_DENIED; goto out; } - r = efi_remove_protocol(handle, protocol, protocol_interface); + r = efi_remove_protocol(handle, protocol_guid, protocol_interface); out: return r; } @@ -1242,10 +1424,9 @@ static efi_status_t EFIAPI efi_uninstall_protocol_interface goto out;

/* If the last protocol has been removed, delete the handle. */ - if (list_empty(&handle->protocols)) { - list_del(&handle->link); - free(handle); - } + if (device_find_first_child_by_uclass(handle, UCLASS_EFI_PROTOCOL, + NULL)) + efi_remove_handle(handle); out: return EFI_EXIT(ret); } @@ -1352,7 +1533,7 @@ static efi_status_t efi_locate_handle(

/* Count how much space we need */ list_for_each_entry(efiobj, &efi_obj_list, link) { - if (!efi_search(search_type, protocol, search_key, efiobj)) + if (!efi_search(search_type, protocol, search_key, efiobj->dev)) size += sizeof(void *); }

@@ -1367,8 +1548,8 @@ static efi_status_t efi_locate_handle(

/* Then fill the array */ list_for_each_entry(efiobj, &efi_obj_list, link) { - if (!efi_search(search_type, protocol, search_key, efiobj)) - *buffer++ = efiobj; + if (!efi_search(search_type, protocol, search_key, efiobj->dev)) + *buffer++ = efiobj->dev; }

return EFI_SUCCESS; @@ -2012,25 +2193,27 @@ static efi_status_t EFIAPI efi_set_watchdog_timer(unsigned long timeout, * Return: status code */ static efi_status_t EFIAPI efi_close_protocol(efi_handle_t handle, - const efi_guid_t *protocol, + const efi_guid_t *protocol_guid, efi_handle_t agent_handle, efi_handle_t controller_handle) { + struct udevice *protocol; 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, %pUl, %p, %p", handle, protocol, agent_handle, + EFI_ENTRY("%p, %pUl, %p, %p", handle, protocol_guid, agent_handle, controller_handle);

if (!agent_handle) { r = EFI_INVALID_PARAMETER; goto out; } - r = efi_search_protocol(handle, protocol, &handler); + r = efi_search_protocol(handle, protocol_guid, &protocol); if (r != EFI_SUCCESS) goto out; + handler = protocol->uclass_platdata;

r = EFI_NOT_FOUND; list_for_each_entry_safe(item, pos, &handler->open_infos, link) { @@ -2061,17 +2244,18 @@ out: * Return: status code */ static efi_status_t EFIAPI efi_open_protocol_information( - efi_handle_t handle, const efi_guid_t *protocol, + efi_handle_t handle, const efi_guid_t *protocol_guid, struct efi_open_protocol_info_entry **entry_buffer, efi_uintn_t *entry_count) { unsigned long buffer_size; unsigned long count; + struct udevice *protocol; struct efi_handler *handler; struct efi_open_protocol_info_item *item; efi_status_t r;

- EFI_ENTRY("%p, %pUl, %p, %p", handle, protocol, entry_buffer, + EFI_ENTRY("%p, %pUl, %p, %p", handle, protocol_guid, entry_buffer, entry_count);

/* Check parameters */ @@ -2079,9 +2263,10 @@ static efi_status_t EFIAPI efi_open_protocol_information( r = EFI_INVALID_PARAMETER; goto out; } - r = efi_search_protocol(handle, protocol, &handler); + r = efi_search_protocol(handle, protocol_guid, &protocol); if (r != EFI_SUCCESS) goto out; + handler = protocol->uclass_platdata;

/* Count entries */ count = 0; @@ -2127,9 +2312,8 @@ static efi_status_t EFIAPI efi_protocols_per_handle( efi_handle_t handle, efi_guid_t ***protocol_buffer, efi_uintn_t *protocol_buffer_count) { + struct udevice *dev, *child; unsigned long buffer_size; - struct efi_object *efiobj; - struct list_head *protocol_handle; efi_status_t r;

EFI_ENTRY("%p, %p, %p", handle, protocol_buffer, @@ -2141,12 +2325,15 @@ static efi_status_t EFIAPI efi_protocols_per_handle( *protocol_buffer = NULL; *protocol_buffer_count = 0;

- efiobj = efi_search_obj(handle); - if (!efiobj) - return EFI_EXIT(EFI_INVALID_PARAMETER); + if (!efi_is_valid(handle)) + return EFI_INVALID_PARAMETER; + dev = handle;

/* Count protocols */ - list_for_each(protocol_handle, &efiobj->protocols) { + list_for_each_entry(child, &dev->child_head, sibling_node) { + if (child->driver->id != UCLASS_EFI_PROTOCOL) + continue; + ++*protocol_buffer_count; }

@@ -2159,12 +2346,15 @@ static efi_status_t EFIAPI efi_protocols_per_handle( (void **)protocol_buffer); if (r != EFI_SUCCESS) return EFI_EXIT(r); - list_for_each(protocol_handle, &efiobj->protocols) { - struct efi_handler *protocol;

- protocol = list_entry(protocol_handle, - struct efi_handler, link); - (*protocol_buffer)[j] = (void *)protocol->guid; + list_for_each_entry(child, &dev->child_head, sibling_node) { + struct efi_handler *handler; + + if (child->driver->id != UCLASS_EFI_PROTOCOL) + continue; + + handler = child->uclass_platdata; + (*protocol_buffer)[j] = (void *)handler->guid; ++j; } } @@ -2233,26 +2423,27 @@ out: * * Return: status code */ -static efi_status_t EFIAPI efi_locate_protocol(const efi_guid_t *protocol, +static efi_status_t EFIAPI efi_locate_protocol(const efi_guid_t *protocol_guid, void *registration, void **protocol_interface) { - struct list_head *lhandle; + struct efi_object *efiobj; efi_status_t ret;

- EFI_ENTRY("%pUl, %p, %p", protocol, registration, protocol_interface); + EFI_ENTRY("%pUl, %p, %p", protocol_guid, registration, + protocol_interface);

- if (!protocol || !protocol_interface) + if (!protocol_guid || !protocol_interface) return EFI_EXIT(EFI_INVALID_PARAMETER);

- list_for_each(lhandle, &efi_obj_list) { - struct efi_object *efiobj; + list_for_each_entry(efiobj, &efi_obj_list, link) { struct efi_handler *handler; + struct udevice *protocol;

- efiobj = list_entry(lhandle, struct efi_object, link); - - ret = efi_search_protocol(efiobj, protocol, &handler); + ret = efi_search_protocol(efiobj->dev, protocol_guid, + &protocol); if (ret == EFI_SUCCESS) { + handler = protocol->uclass_platdata; *protocol_interface = handler->protocol_interface; return EFI_EXIT(EFI_SUCCESS); } @@ -2277,12 +2468,13 @@ static efi_status_t EFIAPI efi_locate_protocol(const efi_guid_t *protocol, * Return: status code */ static efi_status_t EFIAPI efi_locate_device_path( - const efi_guid_t *protocol, + const efi_guid_t *protocol_guid, struct efi_device_path **device_path, efi_handle_t *device) { struct efi_device_path *dp; size_t i; + struct udevice *protocol; struct efi_handler *handler; efi_handle_t *handles; size_t len, len_dp; @@ -2291,9 +2483,9 @@ static efi_status_t EFIAPI efi_locate_device_path( u8 *remainder; efi_status_t ret;

- EFI_ENTRY("%pUl, %p, %p", protocol, device_path, device); + EFI_ENTRY("%pUl, %p, %p", protocol_guid, device_path, device);

- if (!protocol || !device_path || !*device_path || !device) { + if (!protocol_guid || !device_path || !*device_path || !device) { ret = EFI_INVALID_PARAMETER; goto out; } @@ -2302,17 +2494,19 @@ static efi_status_t EFIAPI efi_locate_device_path( len = efi_dp_instance_size(*device_path);

/* Get all handles implementing the protocol */ - ret = EFI_CALL(efi_locate_handle_buffer(BY_PROTOCOL, protocol, NULL, - &no_handles, &handles)); + ret = EFI_CALL(efi_locate_handle_buffer(BY_PROTOCOL, protocol_guid, + NULL, &no_handles, &handles)); if (ret != EFI_SUCCESS) goto out;

for (i = 0; i < no_handles; ++i) { /* Find the device path protocol */ ret = efi_search_protocol(handles[i], &efi_guid_device_path, - &handler); + &protocol); if (ret != EFI_SUCCESS) continue; + + handler = protocol->uclass_platdata; dp = (struct efi_device_path *)handler->protocol_interface; len_dp = efi_dp_instance_size(dp); /* @@ -2442,10 +2636,11 @@ static efi_status_t EFIAPI efi_uninstall_multiple_protocol_interfaces( efi_va_end(argptr); if (r == EFI_SUCCESS) { /* If the last protocol has been removed, delete the handle. */ - if (list_empty(&handle->protocols)) { - list_del(&handle->link); - free(handle); - } + if (device_find_first_child_by_uclass(handle, + UCLASS_EFI_PROTOCOL, + NULL)) + efi_remove_handle(handle); + return EFI_EXIT(r); }

@@ -2635,18 +2830,19 @@ out: * Return: status code */ static efi_status_t EFIAPI efi_open_protocol - (efi_handle_t handle, const efi_guid_t *protocol, + (efi_handle_t handle, const efi_guid_t *protocol_guid, void **protocol_interface, efi_handle_t agent_handle, efi_handle_t controller_handle, uint32_t attributes) { + struct udevice *protocol; struct efi_handler *handler; efi_status_t r = EFI_INVALID_PARAMETER;

- EFI_ENTRY("%p, %pUl, %p, %p, %p, 0x%x", handle, protocol, + EFI_ENTRY("%p, %pUl, %p, %p, %p, 0x%x", handle, protocol_guid, protocol_interface, agent_handle, controller_handle, attributes);

- if (!handle || !protocol || + if (!handle || !protocol_guid || (!protocol_interface && attributes != EFI_OPEN_PROTOCOL_TEST_PROTOCOL)) { goto out; @@ -2663,23 +2859,26 @@ static efi_status_t EFIAPI efi_open_protocol /* fall-through */ case EFI_OPEN_PROTOCOL_BY_DRIVER: case EFI_OPEN_PROTOCOL_BY_DRIVER | EFI_OPEN_PROTOCOL_EXCLUSIVE: - /* Check that the controller handle is valid */ - if (!efi_search_obj(controller_handle)) + if (!efi_is_valid(controller_handle)) { + r = EFI_INVALID_PARAMETER; goto out; + } /* fall-through */ case EFI_OPEN_PROTOCOL_EXCLUSIVE: - /* Check that the agent handle is valid */ - if (!efi_search_obj(agent_handle)) + if (!efi_is_valid(agent_handle)) { + r = EFI_INVALID_PARAMETER; goto out; + } break; default: goto out; }

- r = efi_search_protocol(handle, protocol, &handler); + r = efi_search_protocol(handle, protocol_guid, &protocol); if (r != EFI_SUCCESS) goto out;

+ handler = protocol->uclass_platdata; r = efi_protocol_open(handler, protocol_interface, agent_handle, controller_handle, attributes); out: @@ -2839,18 +3038,16 @@ static efi_status_t EFIAPI efi_connect_controller( struct efi_device_path *remain_device_path, bool recursive) { + struct udevice *dev, *child; efi_status_t r; efi_status_t ret = EFI_NOT_FOUND; - struct efi_object *efiobj;

EFI_ENTRY("%p, %p, %p, %d", controller_handle, driver_image_handle, remain_device_path, recursive);

- efiobj = efi_search_obj(controller_handle); - if (!efiobj) { - ret = EFI_INVALID_PARAMETER; - goto out; - } + if (!efi_is_valid(controller_handle)) + return EFI_INVALID_PARAMETER; + dev = controller_handle;

r = efi_connect_single_controller(controller_handle, driver_image_handle, @@ -2861,7 +3058,11 @@ static efi_status_t EFIAPI efi_connect_controller( struct efi_handler *handler; struct efi_open_protocol_info_item *item;

- list_for_each_entry(handler, &efiobj->protocols, link) { + list_for_each_entry(child, &dev->child_head, sibling_node) { + if (child->driver->id != UCLASS_EFI_PROTOCOL) + continue; + + handler = child->uclass_platdata; list_for_each_entry(item, &handler->open_infos, link) { if (item->info.attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) { @@ -2880,7 +3081,7 @@ static efi_status_t EFIAPI efi_connect_controller( if (ret != EFI_SUCCESS && remain_device_path && remain_device_path->type == DEVICE_PATH_TYPE_END) ret = EFI_SUCCESS; -out: + return EFI_EXIT(ret); }

@@ -2945,18 +3146,23 @@ out: * Return: status code */ static efi_status_t efi_get_child_controllers( - struct efi_object *efiobj, + struct udevice *dev, efi_handle_t driver_handle, efi_uintn_t *number_of_children, efi_handle_t **child_handle_buffer) { + struct udevice *child; struct efi_handler *handler; struct efi_open_protocol_info_item *item; efi_uintn_t count = 0, i; bool duplicate;

/* Count all child controller associations */ - list_for_each_entry(handler, &efiobj->protocols, link) { + list_for_each_entry(child, &dev->child_head, sibling_node) { + if (child->driver->id != UCLASS_EFI_PROTOCOL) + continue; + + handler = child->uclass_platdata; list_for_each_entry(item, &handler->open_infos, link) { if (item->info.agent_handle == driver_handle && item->info.attributes & @@ -2973,7 +3179,11 @@ static efi_status_t efi_get_child_controllers( if (!*child_handle_buffer) return EFI_OUT_OF_RESOURCES; /* Copy unique child handles */ - list_for_each_entry(handler, &efiobj->protocols, link) { + list_for_each_entry(child, &dev->child_head, sibling_node) { + if (child->driver->id != UCLASS_EFI_PROTOCOL) + continue; + + handler = child->uclass_platdata; list_for_each_entry(item, &handler->open_infos, link) { if (item->info.agent_handle == driver_handle && item->info.attributes & @@ -3015,30 +3225,23 @@ static efi_status_t EFIAPI efi_disconnect_controller( efi_handle_t driver_image_handle, efi_handle_t child_handle) { + struct udevice *dev; struct efi_driver_binding_protocol *binding_protocol; efi_handle_t *child_handle_buffer = NULL; size_t number_of_children = 0; efi_status_t r; size_t stop_count = 0; - struct efi_object *efiobj;

EFI_ENTRY("%p, %p, %p", controller_handle, driver_image_handle, child_handle);

- efiobj = efi_search_obj(controller_handle); - if (!efiobj) { - r = EFI_INVALID_PARAMETER; - goto out; - } - - if (child_handle && !efi_search_obj(child_handle)) { - r = EFI_INVALID_PARAMETER; - goto out; - } + if (!efi_is_valid(controller_handle)) + return EFI_INVALID_PARAMETER; + dev = controller_handle;

/* If no driver handle is supplied, disconnect all drivers */ if (!driver_image_handle) { - r = efi_disconnect_all_drivers(efiobj, NULL, child_handle); + r = efi_disconnect_all_drivers(dev, NULL, child_handle); goto out; }

@@ -3047,7 +3250,7 @@ static efi_status_t EFIAPI efi_disconnect_controller( number_of_children = 1; child_handle_buffer = &child_handle; } else { - efi_get_child_controllers(efiobj, + efi_get_child_controllers(dev, driver_image_handle, &number_of_children, &child_handle_buffer); @@ -3186,3 +3389,30 @@ efi_status_t efi_initialize_system_table(void)

return ret; } + +/* + * UEFI object -- any device with no corresponding u-boot device + */ +U_BOOT_DRIVER(efi_dumb_obj) = { + .name = "efi_dumb_object", + .id = UCLASS_EFI_OBJECT, +}; + +UCLASS_DRIVER(efi_obj) = { + .name = "efi_object", + .id = UCLASS_EFI_OBJECT, +}; + +/* + * UEFI protocol + */ +U_BOOT_DRIVER(efi_protocol) = { + .name = "efi_protocol", + .id = UCLASS_EFI_PROTOCOL, +}; + +UCLASS_DRIVER(efi_protocol) = { + .name = "efi_protocol", + .id = UCLASS_EFI_PROTOCOL, + .per_device_platdata_auto_alloc_size = sizeof(struct efi_handler), +};

Signed-off-by: AKASHI Takahiro takahiro.akashi@linaro.org --- cmd/bootefi.c | 61 ++++++++++++++----------------- include/efi_loader.h | 4 +- lib/efi_loader/efi_image_loader.c | 61 +++++++++++++++++++------------ 3 files changed, 67 insertions(+), 59 deletions(-)

diff --git a/cmd/bootefi.c b/cmd/bootefi.c index ebe149dffa1f..d2130d5ac323 100644 --- a/cmd/bootefi.c +++ b/cmd/bootefi.c @@ -249,12 +249,12 @@ static efi_status_t efi_install_fdt(ulong fdt_addr) static efi_status_t bootefi_run_prepare(const char *load_options_path, struct efi_device_path *device_path, struct efi_device_path *image_path, - struct efi_loaded_image_obj **image_objp, + efi_handle_t *handlep, struct efi_loaded_image **loaded_image_infop) { efi_status_t ret;

- ret = efi_setup_loaded_image(device_path, image_path, image_objp, + ret = efi_setup_loaded_image(device_path, image_path, handlep, loaded_image_infop); if (ret != EFI_SUCCESS) return ret; @@ -268,15 +268,15 @@ static efi_status_t bootefi_run_prepare(const char *load_options_path, /** * bootefi_run_finish() - finish up after running an EFI test * + * @handle: Handle to the loaded image object * @loaded_image_info: Pointer to a struct which holds the loaded image info - * @image_objj: Pointer to a struct which holds the loaded image object */ -static void bootefi_run_finish(struct efi_loaded_image_obj *image_obj, +static void bootefi_run_finish(efi_handle_t handle, struct efi_loaded_image *loaded_image_info) { efi_restore_gd(); free(loaded_image_info->load_options); - efi_delete_handle(&image_obj->header); + efi_delete_handle(handle); }

static int efi_handle_fdt(char *fdt_opt) @@ -319,10 +319,10 @@ static efi_status_t do_bootefi_exec(void *efi, struct efi_device_path *device_path, struct efi_device_path *image_path) { - efi_handle_t mem_handle = NULL; struct efi_device_path *memdp = NULL; + efi_handle_t handle; efi_status_t ret; - struct efi_loaded_image_obj *image_obj = NULL; + struct efi_loaded_image_obj *image_obj; struct efi_loaded_image *loaded_image_info = NULL;

EFIAPI efi_status_t (*entry)(efi_handle_t image_handle, @@ -342,28 +342,27 @@ static efi_status_t do_bootefi_exec(void *efi, * Grub expects that the device path of the loaded image is * installed on a handle. */ - ret = efi_create_handle(&mem_handle); - if (ret != EFI_SUCCESS) - return ret; /* TODO: leaks device_path */ - ret = efi_add_protocol(mem_handle, &efi_guid_device_path, - device_path); - if (ret != EFI_SUCCESS) - goto err_add_protocol; + /* + * CHECK: device path protocol will be added to handle + * in efi_setup_loaded_image() anyway. + */ } else { assert(device_path && image_path); }

ret = bootefi_run_prepare("bootargs", device_path, image_path, - &image_obj, &loaded_image_info); + &handle, &loaded_image_info); if (ret) goto err_prepare;

/* Load the EFI payload */ - entry = efi_load_pe(image_obj, efi, loaded_image_info); - if (!entry) { + image_obj = handle->platdata; + ret = efi_load_pe(image_obj, efi, loaded_image_info); + if (ret) { ret = EFI_LOAD_ERROR; goto err_prepare; } + entry = image_obj->entry;

if (memdp) { struct efi_device_path_memory *mdp = (void *)memdp; @@ -393,7 +392,7 @@ static efi_status_t do_bootefi_exec(void *efi,

/* Move into EL2 and keep running there */ armv8_switch_to_el2((ulong)entry, - (ulong)&image_obj->header, + 0, (ulong)&systab, 0, (ulong)efi_run_in_el2, ES_TO_AARCH64);

@@ -410,7 +409,7 @@ static efi_status_t do_bootefi_exec(void *efi, secure_ram_addr(_do_nonsec_entry)( efi_run_in_hyp, (uintptr_t)entry, - (uintptr_t)&image_obj->header, + 0, (uintptr_t)&systab);

/* Should never reach here, efi exits with longjmp */ @@ -418,15 +417,11 @@ static efi_status_t do_bootefi_exec(void *efi, } #endif

- ret = efi_do_enter(&image_obj->header, &systab, entry); + ret = efi_do_enter(handle, &systab, entry);

err_prepare: /* image has returned, loaded-image obj goes *poof*: */ - bootefi_run_finish(image_obj, loaded_image_info); - -err_add_protocol: - if (mem_handle) - efi_delete_handle(mem_handle); + bootefi_run_finish(handle, loaded_image_info);

return ret; } @@ -438,9 +433,7 @@ err_add_protocol: * This sets things up so we can call EFI functions. This involves preparing * the 'gd' pointer and setting up the load ed image data structures. * - * @image_objp: loaded_image_infop: Pointer to a struct which will hold the - * loaded image object. This struct will be inited by this function before - * use. + * @handlep: Pointer to a handle of the loaded image object * @loaded_image_infop: Pointer to a struct which will hold the loaded image * info. This struct will be inited by this function before use. * @path: File path to the test being run (often just the test name with a @@ -450,7 +443,7 @@ err_add_protocol: * @return 0 if OK, -ve on error */ static efi_status_t bootefi_test_prepare - (struct efi_loaded_image_obj **image_objp, + (efi_handle_t *handlep, struct efi_loaded_image **loaded_image_infop, const char *path, ulong test_func, const char *load_options_path) { @@ -465,7 +458,7 @@ static efi_status_t bootefi_test_prepare return EFI_OUT_OF_RESOURCES;

return bootefi_run_prepare(load_options_path, bootefi_device_path, - bootefi_image_path, image_objp, + bootefi_image_path, handlep, loaded_image_infop); }

@@ -558,20 +551,20 @@ static int do_bootefi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) #endif #ifdef CONFIG_CMD_BOOTEFI_SELFTEST if (!strcmp(argv[1], "selftest")) { - struct efi_loaded_image_obj *image_obj; + efi_handle_t handle; struct efi_loaded_image *loaded_image_info;

if (efi_handle_fdt(argc > 2 ? argv[2] : NULL)) return CMD_RET_FAILURE;

- if (bootefi_test_prepare(&image_obj, &loaded_image_info, + if (bootefi_test_prepare(&handle, &loaded_image_info, "\selftest", (uintptr_t)&efi_selftest, "efi_selftest")) return CMD_RET_FAILURE;

/* Execute the test */ - r = efi_selftest(&image_obj->header, &systab); - bootefi_run_finish(image_obj, loaded_image_info); + r = efi_selftest(handle, &systab); + bootefi_run_finish(handle, loaded_image_info); return r != EFI_SUCCESS; } else #endif diff --git a/include/efi_loader.h b/include/efi_loader.h index 5882cd7dd3b0..86cf91a6feca 100644 --- a/include/efi_loader.h +++ b/include/efi_loader.h @@ -274,8 +274,8 @@ efi_status_t efi_set_watchdog(unsigned long timeout); /* Called from places to check whether a timer expired */ void efi_timer_check(void); /* PE loader implementation */ -void *efi_load_pe(struct efi_loaded_image_obj *handle, void *efi, - struct efi_loaded_image *loaded_image_info); +efi_status_t efi_load_pe(struct efi_loaded_image_obj *obj, void *efi, + struct efi_loaded_image *loaded_image_info); /* Called once to store the pristine gd pointer */ void efi_save_gd(void); /* Special case handler for error/abort that just tries to dtrt to get diff --git a/lib/efi_loader/efi_image_loader.c b/lib/efi_loader/efi_image_loader.c index a18ce0a5705e..332dd5db199c 100644 --- a/lib/efi_loader/efi_image_loader.c +++ b/lib/efi_loader/efi_image_loader.c @@ -8,6 +8,7 @@ */

#include <common.h> +#include <dm.h> #include <efi_loader.h> #include <pe.h>

@@ -66,6 +67,7 @@ static efi_status_t efi_print_image_info(struct efi_loaded_image_obj *obj, if (image->file_path) printf(" '%pD'", image->file_path); printf("\n"); + return EFI_SUCCESS; }

@@ -76,17 +78,27 @@ static efi_status_t efi_print_image_info(struct efi_loaded_image_obj *obj, */ void efi_print_image_infos(void *pc) { - struct efi_object *efiobj; + struct uclass *uc; + struct udevice *dev, *protocol; + struct efi_loaded_image_obj *obj; struct efi_handler *handler; + efi_status_t ret;

- list_for_each_entry(efiobj, &efi_obj_list, link) { - list_for_each_entry(handler, &efiobj->protocols, link) { - if (!guidcmp(handler->guid, &efi_guid_loaded_image)) { - efi_print_image_info( - (struct efi_loaded_image_obj *)efiobj, - handler->protocol_interface, pc); - } - } + if (uclass_get(UCLASS_EFI_OBJECT, &uc)) + return; + + uclass_foreach_dev(dev, uc) { + if (strcmp(dev->driver->name, "efi_loaded_image")) + continue; + + ret = efi_search_protocol(dev, &efi_guid_loaded_image, + &protocol); + if (ret != EFI_SUCCESS) + continue; + + obj = dev->platdata; + handler = protocol->uclass_platdata; + efi_print_image_info(obj, handler->protocol_interface, pc); } }

@@ -198,8 +210,8 @@ static void efi_set_code_and_data_type( * piece of memory. On successful load it then returns the entry point for * the binary. Otherwise NULL. */ -void *efi_load_pe(struct efi_loaded_image_obj *handle, void *efi, - struct efi_loaded_image *loaded_image_info) +efi_status_t efi_load_pe(struct efi_loaded_image_obj *obj, void *efi, + struct efi_loaded_image *loaded_image_info) { IMAGE_NT_HEADERS32 *nt; IMAGE_DOS_HEADER *dos; @@ -215,17 +227,18 @@ void *efi_load_pe(struct efi_loaded_image_obj *handle, void *efi, uint64_t image_size; unsigned long virt_size = 0; int supported = 0; + efi_status_t ret;

dos = efi; if (dos->e_magic != IMAGE_DOS_SIGNATURE) { printf("%s: Invalid DOS Signature\n", __func__); - return NULL; + return EFI_INVALID_PARAMETER; }

nt = (void *) ((char *)efi + dos->e_lfanew); if (nt->Signature != IMAGE_NT_SIGNATURE) { printf("%s: Invalid NT Signature\n", __func__); - return NULL; + return EFI_INVALID_PARAMETER; }

for (i = 0; machines[i]; i++) @@ -237,7 +250,7 @@ void *efi_load_pe(struct efi_loaded_image_obj *handle, void *efi, if (!supported) { printf("%s: Machine type 0x%04x is not supported\n", __func__, nt->FileHeader.Machine); - return NULL; + return EFI_UNSUPPORTED; }

/* Calculate upper virtual address boundary */ @@ -263,7 +276,7 @@ void *efi_load_pe(struct efi_loaded_image_obj *handle, void *efi, if (!efi_reloc) { printf("%s: Could not allocate %lu bytes\n", __func__, virt_size); - return NULL; + return EFI_OUT_OF_RESOURCES; } entry = efi_reloc + opt->AddressOfEntryPoint; rel_size = opt->DataDirectory[rel_idx].Size; @@ -279,7 +292,7 @@ void *efi_load_pe(struct efi_loaded_image_obj *handle, void *efi, if (!efi_reloc) { printf("%s: Could not allocate %lu bytes\n", __func__, virt_size); - return NULL; + return EFI_OUT_OF_RESOURCES; } entry = efi_reloc + opt->AddressOfEntryPoint; rel_size = opt->DataDirectory[rel_idx].Size; @@ -288,7 +301,7 @@ void *efi_load_pe(struct efi_loaded_image_obj *handle, void *efi, } else { printf("%s: Invalid optional header magic %x\n", __func__, nt->OptionalHeader.Magic); - return NULL; + return EFI_INVALID_PARAMETER; }

/* Load sections into RAM */ @@ -302,11 +315,12 @@ void *efi_load_pe(struct efi_loaded_image_obj *handle, void *efi, }

/* Run through relocations */ - if (efi_loader_relocate(rel, rel_size, efi_reloc, - (unsigned long)image_base) != EFI_SUCCESS) { + ret = efi_loader_relocate(rel, rel_size, efi_reloc, + (unsigned long)image_base); + if (ret != EFI_SUCCESS) { efi_free_pages((uintptr_t) efi_reloc, (virt_size + EFI_PAGE_MASK) >> EFI_PAGE_SHIFT); - return NULL; + return ret; }

/* Flush cache */ @@ -317,8 +331,9 @@ void *efi_load_pe(struct efi_loaded_image_obj *handle, void *efi, /* Populate the loaded image interface bits */ loaded_image_info->image_base = efi; loaded_image_info->image_size = image_size; - handle->reloc_base = efi_reloc; - handle->reloc_size = virt_size; + obj->reloc_base = efi_reloc; + obj->reloc_size = virt_size; + obj->entry = entry;

- return entry; + return EFI_SUCCESS; }

All the efi-specific objects, except for existing devices, will show up under "efi root node" device.

Signed-off-by: AKASHI Takahiro takahiro.akashi@linaro.org --- include/efi_loader.h | 3 +++ lib/efi_loader/efi_root_node.c | 14 +++++----- lib/efi_loader/efi_setup.c | 49 +++++++++++++++++++++++++++++++++- 3 files changed, 59 insertions(+), 7 deletions(-)

diff --git a/include/efi_loader.h b/include/efi_loader.h index 86cf91a6feca..4df965455c21 100644 --- a/include/efi_loader.h +++ b/include/efi_loader.h @@ -225,6 +225,9 @@ extern struct list_head efi_obj_list; /* List of all events */ extern struct list_head efi_events;

+/* Root device */ +extern efi_handle_t efi_root; + /* Initialize efi execution environment */ efi_status_t efi_init_obj_list(void); /* Called by bootefi to initialize root node */ diff --git a/lib/efi_loader/efi_root_node.c b/lib/efi_loader/efi_root_node.c index b056ba3ee880..4b2d1457576a 100644 --- a/lib/efi_loader/efi_root_node.c +++ b/lib/efi_loader/efi_root_node.c @@ -16,6 +16,8 @@ struct efi_root_dp { struct efi_device_path end; } __packed;

+efi_handle_t efi_root; + /** * efi_root_node_register() - create root node * @@ -26,12 +28,11 @@ struct efi_root_dp { */ efi_status_t efi_root_node_register(void) { - efi_handle_t root; efi_status_t ret; struct efi_root_dp *dp;

/* Create handle */ - ret = efi_create_handle(&root); + ret = efi_add_handle(efi_root); if (ret != EFI_SUCCESS) return ret;

@@ -52,24 +53,25 @@ efi_status_t efi_root_node_register(void) dp->end.length = sizeof(struct efi_device_path);

/* Install device path protocol */ - ret = efi_add_protocol(root, &efi_guid_device_path, dp); + ret = efi_add_protocol(efi_root, &efi_guid_device_path, dp); if (ret != EFI_SUCCESS) goto failure;

/* Install device path to text protocol */ - ret = efi_add_protocol(root, &efi_guid_device_path_to_text_protocol, + ret = efi_add_protocol(efi_root, &efi_guid_device_path_to_text_protocol, (void *)&efi_device_path_to_text); if (ret != EFI_SUCCESS) goto failure;

/* Install device path utilities protocol */ - ret = efi_add_protocol(root, &efi_guid_device_path_utilities_protocol, + ret = efi_add_protocol(efi_root, + &efi_guid_device_path_utilities_protocol, (void *)&efi_device_path_utilities); if (ret != EFI_SUCCESS) goto failure;

/* Install Unicode collation protocol */ - ret = efi_add_protocol(root, &efi_guid_unicode_collation_protocol, + ret = efi_add_protocol(efi_root, &efi_guid_unicode_collation_protocol, (void *)&efi_unicode_collation_protocol); if (ret != EFI_SUCCESS) goto failure; diff --git a/lib/efi_loader/efi_setup.c b/lib/efi_loader/efi_setup.c index 38569af1f2c8..83f1b842e6be 100644 --- a/lib/efi_loader/efi_setup.c +++ b/lib/efi_loader/efi_setup.c @@ -7,6 +7,10 @@ */

#include <common.h> +#include <dm.h> +#include <dm/device-internal.h> +#include <dm/lists.h> +#include <dm/root.h> #include <efi_loader.h>

DECLARE_GLOBAL_DATA_PTR; @@ -16,7 +20,7 @@ DECLARE_GLOBAL_DATA_PTR; static efi_status_t efi_obj_list_initialized = OBJ_LIST_NOT_INITIALIZED;

/* Initialize and populate EFI object list */ -efi_status_t efi_init_obj_list(void) +static efi_status_t efi_system_init(void) { efi_status_t ret = EFI_SUCCESS;

@@ -87,3 +91,46 @@ out: efi_obj_list_initialized = ret; return ret; } + +/* For backward compatibility */ +efi_status_t efi_init_obj_list(void) +{ + int ret; + extern struct udevice *efi_root; + + if (efi_root) + return EFI_SUCCESS; + + ret = device_bind_driver(dm_root(), "efi_root", "UEFI sub system", + &efi_root); + if (ret) + return EFI_OUT_OF_RESOURCES; + + ret = device_probe(efi_root); + if (ret) + return EFI_OUT_OF_RESOURCES; + + return EFI_SUCCESS; +} + +static int efi_system_probe(struct udevice *dev) +{ + efi_status_t ret; + + ret = efi_system_init(); + if (ret != EFI_SUCCESS) + return -1; + + return 0; +} + +U_BOOT_DRIVER(efi_root) = { + .name = "efi_root", + .id = UCLASS_EFI, + .probe = efi_system_probe, +}; + +UCLASS_DRIVER(efi) = { + .name = "efi", + .id = UCLASS_EFI, +};

Signed-off-by: AKASHI Takahiro takahiro.akashi@linaro.org --- lib/efi_loader/efi_unicode_collation.c | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+)

diff --git a/lib/efi_loader/efi_unicode_collation.c b/lib/efi_loader/efi_unicode_collation.c index 7f3ea3c77e4e..9b47693d3ee5 100644 --- a/lib/efi_loader/efi_unicode_collation.c +++ b/lib/efi_loader/efi_unicode_collation.c @@ -9,6 +9,7 @@ #include <charset.h> #include <cp1250.h> #include <cp437.h> +#include <dm.h> #include <efi_loader.h>

/* Characters that may not be used in file names */ @@ -327,3 +328,21 @@ const struct efi_unicode_collation_protocol efi_unicode_collation_protocol = { .str_to_fat = efi_str_to_fat, .supported_languages = "en", }; + +static int efi_unicode_collation_probe(struct udevice *dev) +{ + struct efi_handler *handler; + struct efi_unicode_collation_protocol *col; + + handler = dev->uclass_platdata; + col = handler->protocol_interface; + device_set_name(dev, col->supported_languages); + + return 0; +} + +U_BOOT_DRIVER(efi_unicode_collation) = { + .name = "efi_unicode_collation", + .id = UCLASS_EFI_PROTOCOL, + .probe = efi_unicode_collation_probe, +};

Signed-off-by: AKASHI Takahiro takahiro.akashi@linaro.org --- lib/efi_loader/efi_net.c | 50 +++++++++++++++++++++++++++++++------- lib/efi_loader/efi_setup.c | 5 ---- net/eth-uclass.c | 5 ++++ 3 files changed, 46 insertions(+), 14 deletions(-)

diff --git a/lib/efi_loader/efi_net.c b/lib/efi_loader/efi_net.c index c7d9da8521af..6c9b40293633 100644 --- a/lib/efi_loader/efi_net.c +++ b/lib/efi_loader/efi_net.c @@ -6,11 +6,12 @@ */

#include <common.h> +#include <dm.h> #include <efi_loader.h> #include <malloc.h>

-static const efi_guid_t efi_net_guid = EFI_SIMPLE_NETWORK_GUID; -static const efi_guid_t efi_pxe_guid = EFI_PXE_GUID; +const efi_guid_t efi_net_guid = EFI_SIMPLE_NETWORK_GUID; +const efi_guid_t efi_pxe_guid = EFI_PXE_GUID; static struct efi_pxe_packet *dhcp_ack; static bool new_rx_packet; static void *new_tx_packet; @@ -26,17 +27,16 @@ static struct efi_event *network_timer_event; */ static struct efi_event *wait_for_packet;

+/* FIXME: move this to somewhere else, like struct eth_device? */ /** * struct efi_net_obj - EFI object representing a network interface * - * @header: EFI object header * @net: simple network protocol interface * @net_mode: status of the network interface * @pxe: PXE base code protocol interface * @pxe_mode: status of the PXE base code protocol */ struct efi_net_obj { - struct efi_object header; struct efi_simple_network net; struct efi_simple_network_mode net_mode; struct efi_pxe pxe; @@ -588,10 +588,12 @@ out: */ efi_status_t efi_net_register(void) { + struct udevice *dev; struct efi_net_obj *netobj = NULL; efi_status_t r;

- if (!eth_get_dev()) { + dev = eth_get_dev(); + if (!dev) { /* No network device active, don't expose any */ return EFI_SUCCESS; } @@ -608,18 +610,22 @@ efi_status_t efi_net_register(void) transmit_buffer = (void *)ALIGN((uintptr_t)transmit_buffer, PKTALIGN);

/* Hook net up to the device list */ - efi_add_handle(&netobj->header); + r = efi_add_handle(dev); + if (r != EFI_SUCCESS) { + printf("ERROR: Failure adding net handle\n"); + return r; + }

/* Fill in object data */ - r = efi_add_protocol(&netobj->header, &efi_net_guid, + r = efi_add_protocol(dev, &efi_net_guid, &netobj->net); if (r != EFI_SUCCESS) goto failure_to_add_protocol; - r = efi_add_protocol(&netobj->header, &efi_guid_device_path, + r = efi_add_protocol(dev, &efi_guid_device_path, efi_dp_from_eth()); if (r != EFI_SUCCESS) goto failure_to_add_protocol; - r = efi_add_protocol(&netobj->header, &efi_pxe_guid, + r = efi_add_protocol(dev, &efi_pxe_guid, &netobj->pxe); if (r != EFI_SUCCESS) goto failure_to_add_protocol; @@ -691,3 +697,29 @@ out_of_resources: printf("ERROR: Out of memory\n"); return EFI_OUT_OF_RESOURCES; } + +static int efi_net_probe(struct udevice *dev) +{ + device_set_name(dev, "SIMPLE_NETWORK"); + + return 0; +} + +U_BOOT_DRIVER(efi_net) = { + .name = "efi_net", + .id = UCLASS_EFI_PROTOCOL, + .probe = efi_net_probe, +}; + +static int efi_pex_probe(struct udevice *dev) +{ + device_set_name(dev, "PXE"); + + return 0; +} + +U_BOOT_DRIVER(efi_pex) = { + .name = "efi_pex", + .id = UCLASS_EFI_PROTOCOL, + .probe = efi_pex_probe, +}; diff --git a/lib/efi_loader/efi_setup.c b/lib/efi_loader/efi_setup.c index a0f80948c99c..ea65dec6c066 100644 --- a/lib/efi_loader/efi_setup.c +++ b/lib/efi_loader/efi_setup.c @@ -60,11 +60,6 @@ static efi_status_t efi_system_init(void) if (ret != EFI_SUCCESS) goto out; #endif -#ifdef CONFIG_NET - ret = efi_net_register(); - if (ret != EFI_SUCCESS) - goto out; -#endif #ifdef CONFIG_GENERATE_ACPI_TABLE ret = efi_acpi_register(); if (ret != EFI_SUCCESS) diff --git a/net/eth-uclass.c b/net/eth-uclass.c index 91d861be4136..85830a23de32 100644 --- a/net/eth-uclass.c +++ b/net/eth-uclass.c @@ -87,6 +87,11 @@ void eth_set_dev(struct udevice *dev) }

eth_get_uclass_priv()->current = dev; +#if CONFIG_IS_ENABLED(EFI_LOADER) + extern int efi_net_register(void); + + efi_net_register(); +#endif }

/*

UCLASS_PARTITION device will be created as a child node of UCLASS_BLK device.

Signed-off-by: AKASHI Takahiro takahiro.akashi@linaro.org --- drivers/block/blk-uclass.c | 52 ++++++++++++++++++++++++++++++++++++++ include/dm/uclass-id.h | 1 + 2 files changed, 53 insertions(+)

diff --git a/drivers/block/blk-uclass.c b/drivers/block/blk-uclass.c index baaf431e5e0c..d4ca30f23fc1 100644 --- a/drivers/block/blk-uclass.c +++ b/drivers/block/blk-uclass.c @@ -10,6 +10,8 @@ #include <dm/device-internal.h> #include <dm/lists.h> #include <dm/uclass-internal.h> +#include <part.h> +#include <string.h>

static const char *if_typename_str[IF_TYPE_COUNT] = { [IF_TYPE_IDE] = "ide", @@ -654,3 +656,53 @@ UCLASS_DRIVER(blk) = { .post_probe = blk_post_probe, .per_device_platdata_auto_alloc_size = sizeof(struct blk_desc), }; + +U_BOOT_DRIVER(blk_partition) = { + .name = "blk_partition", + .id = UCLASS_PARTITION, + .platdata_auto_alloc_size = sizeof(struct disk_part), +}; + +UCLASS_DRIVER(partition) = { + .id = UCLASS_PARTITION, + .name = "partition", +}; + +#if defined(CONFIG_PARTITIONS) && defined(CONFIG_HAVE_BLOCK_DEVICE) +int blk_create_partitions(struct udevice *parent) +{ + int part; + struct blk_desc *desc = dev_get_uclass_platdata(parent); + disk_partition_t info; + struct disk_part *part_data; + char devname[32]; + struct udevice *dev; + int disks = 0, ret; + + /* Add devices for each partition */ + for (part = 1; part <= MAX_SEARCH_PARTITIONS; part++) { + if (part_get_info(desc, part, &info)) + continue; + snprintf(devname, sizeof(devname), "%s:%d", parent->name, + part); + + ret = device_bind_driver(parent, "blk_partition", + strdup(devname), &dev); + if (ret) + return ret; + + part_data = dev_get_uclass_platdata(dev); + part_data->partnum = part; + part_data->gpt_part_info = info; + + disks++; + } + + return disks; +} +#else +int blk_create_partitions(struct udevice *dev) +{ + return 0; +} +#endif diff --git a/include/dm/uclass-id.h b/include/dm/uclass-id.h index b4fca51a8192..fce11e6d7e73 100644 --- a/include/dm/uclass-id.h +++ b/include/dm/uclass-id.h @@ -68,6 +68,7 @@ enum uclass_id { UCLASS_NVME, /* NVM Express device */ UCLASS_PANEL, /* Display panel, such as an LCD */ UCLASS_PANEL_BACKLIGHT, /* Backlight controller for panel */ + UCLASS_PARTITION, /* Logical disk partition device */ UCLASS_PCH, /* x86 platform controller hub */ UCLASS_PCI, /* PCI bus */ UCLASS_PCI_GENERIC, /* Generic PCI bus device */

Efi_disk_create() should be hook up at every creation of block device at each driver. Associated blk_desc must be properly set up before calling this function.

Signed-off-by: AKASHI Takahiro takahiro.akashi@linaro.org --- common/usb_storage.c | 27 +++++++++++++++++++++++++-- drivers/scsi/scsi.c | 22 ++++++++++++++++++++++ lib/efi_driver/efi_block_device.c | 30 +++++++++--------------------- 3 files changed, 56 insertions(+), 23 deletions(-)

diff --git a/common/usb_storage.c b/common/usb_storage.c index 8c889bb1a648..ff895c0e4557 100644 --- a/common/usb_storage.c +++ b/common/usb_storage.c @@ -46,6 +46,10 @@ #include <part.h> #include <usb.h>

+/* FIXME */ +extern int efi_disk_create(struct udevice *dev); +extern int blk_create_partitions(struct udevice *parent); + #undef BBB_COMDAT_TRACE #undef BBB_XPORT_TRACE

@@ -227,8 +231,27 @@ static int usb_stor_probe_device(struct usb_device *udev)

ret = usb_stor_get_info(udev, data, blkdev); if (ret == 1) { - usb_max_devs++; - debug("%s: Found device %p\n", __func__, udev); + ret = efi_disk_create(dev); + if (ret) { + debug("Cannot create efi_disk device\n"); + ret = device_unbind(dev); + if (ret) + return ret; + } else { + usb_max_devs++; + ret = blk_create_partitions(dev); + if (ret < 0) { + debug("Cannot create disk partition device\n"); + /* TODO: undo create */ + + ret = device_unbind(dev); + if (ret) + return ret; + } + usb_max_devs += ret; + debug("%s: Found device %p, partitions:%d\n", + __func__, udev, ret); + } } else { debug("usb_stor_get_info: Invalid device\n"); ret = device_unbind(dev); diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c index df47e2fc78bd..f0f8cbc0bf26 100644 --- a/drivers/scsi/scsi.c +++ b/drivers/scsi/scsi.c @@ -11,6 +11,10 @@ #include <dm/device-internal.h> #include <dm/uclass-internal.h>

+/* FIXME */ +int efi_disk_create(struct udevice *dev); +int blk_create_partitions(struct udevice *parent); + #if !defined(CONFIG_DM_SCSI) # ifdef CONFIG_SCSI_DEV_LIST # define SCSI_DEV_LIST CONFIG_SCSI_DEV_LIST @@ -593,9 +597,27 @@ static int do_scsi_scan_one(struct udevice *dev, int id, int lun, bool verbose) memcpy(&bdesc->product, &bd.product, sizeof(bd.product)); memcpy(&bdesc->revision, &bd.revision, sizeof(bd.revision));

+ ret = efi_disk_create(bdev); + if (ret) { + debug("Can't create efi_disk device\n"); + ret = device_unbind(bdev); + + return ret; + } + ret = blk_create_partitions(bdev); + if (ret < 0) { + debug("Can't create efi_disk partitions\n"); + /* TODO: undo create */ + + ret = device_unbind(bdev); + + return ret; + } + if (verbose) { printf(" Device %d: ", 0); dev_print(bdesc); + debug("Found %d partitions\n", ret); } return 0; } diff --git a/lib/efi_driver/efi_block_device.c b/lib/efi_driver/efi_block_device.c index e0d50c866f00..acef1b20867e 100644 --- a/lib/efi_driver/efi_block_device.c +++ b/lib/efi_driver/efi_block_device.c @@ -32,6 +32,10 @@ #include <dm/device-internal.h> #include <dm/root.h>

+/* FIXME */ +extern int efi_disk_create(struct udevice *dev); +extern int blk_create_partitions(struct udevice *parent); + /* * EFI attributes of the udevice handled by this driver. * @@ -102,24 +106,6 @@ static ulong efi_bl_write(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt, return blkcnt; }

-/* - * Create partions for the block device. - * - * @handle EFI handle of the block device - * @dev udevice of the block device - */ -static int efi_bl_bind_partitions(efi_handle_t handle, struct udevice *dev) -{ - struct blk_desc *desc; - const char *if_typename; - - desc = dev_get_uclass_platdata(dev); - if_typename = blk_get_if_type_name(desc->if_type); - - return efi_disk_create_partitions(handle, desc, if_typename, - desc->devnum, dev->name); -} - /* * Create a block device for a handle * @@ -168,15 +154,17 @@ static int efi_bl_bind(efi_handle_t handle, void *interface) platdata->handle = handle; platdata->io = interface;

+ ret = efi_disk_create(bdev); + if (ret) + return ret; + ret = device_probe(bdev); if (ret) return ret; EFI_PRINT("%s: block device '%s' created\n", __func__, bdev->name); - /* Create handles for the partions of the block device */ - disks = efi_bl_bind_partitions(handle, bdev); + disks = blk_create_partitions(bdev); EFI_PRINT("Found %d partitions\n", disks); - return 0; }

Signed-off-by: AKASHI Takahiro takahiro.akashi@linaro.org --- cmd/efidebug.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/cmd/efidebug.c b/cmd/efidebug.c index 39398669e18f..e1c3628f72fb 100644 --- a/cmd/efidebug.c +++ b/cmd/efidebug.c @@ -8,6 +8,7 @@ #include <charset.h> #include <common.h> #include <command.h> +#include <dm.h> #include <efi_loader.h> #include <environment.h> #include <exports.h> @@ -114,6 +115,7 @@ static int do_efi_show_devices(cmd_tbl_t *cmdtp, int flag, static int efi_get_driver_handle_info(efi_handle_t handle, u16 **driver_name, u16 **image_path) { + struct udevice *protocol; struct efi_handler *handler; struct efi_loaded_image *image; efi_status_t ret; @@ -125,12 +127,13 @@ static int efi_get_driver_handle_info(efi_handle_t handle, u16 **driver_name, *driver_name = NULL;

/* image name */ - ret = efi_search_protocol(handle, &efi_guid_loaded_image, &handler); + ret = efi_search_protocol(handle, &efi_guid_loaded_image, &protocol); if (ret != EFI_SUCCESS) { *image_path = NULL; return 0; }

+ handler = protocol->uclass_platdata; image = handler->protocol_interface; *image_path = efi_dp_str(image->file_path);