Heinrich,
On Fri, Feb 08, 2019 at 06:47:12PM +0100, Heinrich Schuchardt wrote:
> On 2/8/19 9:15 AM, AKASHI Takahiro wrote:
> > 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 <[email protected]>
> > ---
> > 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);
>
> In the EFI world the device tree is defined by the device tree protocol.
device tree -> device path?
> Furthermore when a protocol is opened by a controller a relationship
> between device and controller is established.
>
> Binding a new handle to dm_root disregards the logic of UEFI.
>
> Think of an EFI application creating two handles via
> InstallProtocolInterface() with device paths /foo and /foo/bar. Next
> /foo/bar calls ConnectController() which causes /foo to open the
> protocol on /foo/bar as a controller.
Can you give me a concrete example of foo and baa here so that
I can understand you more precisely?
> With your code the handles would be siblings in the DM world while in
> the EFI world /foo is the parent of /foo/bar.
Then, DM tree would not be static. We will be able to relocate
/foo/bar under /foo to match such a device path with DM tree?
Thanks,
-Takahiro Akashi
> I suggest not to proceed into this direction.
>
> Best regards
>
> Heinrich
>
> > + 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),
> > +};
> >
>
_______________________________________________
U-Boot mailing list
[email protected]
https://lists.denx.de/listinfo/u-boot
