efi_driver: EFI block driver

This patch provides * a uclass for EFI drivers * a EFI driver for block devices For each EFI driver the uclass * creates a handle * adds the driver binding protocol The uclass provides the bind, start, and stop entry points for the driver binding protocol. In bind() and stop() it checks if the controller implements the protocol supported by the EFI driver. In the start() function it calls the bind() function of the EFI driver. In the stop() function it destroys the child controllers. The EFI block driver binds to controllers implementing the block io protocol. When the bind function of the EFI block driver is called it creates a new U-Boot block device. It installs child handles for all partitions and installs the simple file protocol on these. The read and write functions of the EFI block driver delegate calls to the controller that it is bound to. A usage example is as following: U-Boot loads the iPXE snp.efi executable. iPXE connects an iSCSI drive and exposes a handle with the block IO protocol. It calls ConnectController. Now the EFI block driver installs the partitions with the simple file protocol. iPXE uses the simple file protocol to load Grub or the Linux Kernel. Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de> [agraf: add comment on calloc len] Signed-off-by: Alexander Graf <agraf@suse.de>

efi_driver: EFI block driver
This patch provides * a uclass for EFI drivers * a EFI driver for block devices For each EFI driver the uclass * creates a handle * adds the driver binding protocol The uclass provides the bind, start, and stop entry points for the driver binding protocol. In bind() and stop() it checks if the controller implements the protocol supported by the EFI driver. In the start() function it calls the bind() function of the EFI driver. In the stop() function it destroys the child controllers. The EFI block driver binds to controllers implementing the block io protocol. When the bind function of the EFI block driver is called it creates a new U-Boot block device. It installs child handles for all partitions and installs the simple file protocol on these. The read and write functions of the EFI block driver delegate calls to the controller that it is bound to. A usage example is as following: U-Boot loads the iPXE snp.efi executable. iPXE connects an iSCSI drive and exposes a handle with the block IO protocol. It calls ConnectController. Now the EFI block driver installs the partitions with the simple file protocol. iPXE uses the simple file protocol to load Grub or the Linux Kernel. Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de> [agraf: add comment on calloc len] Signed-off-by: Alexander Graf <agraf@suse.de>
Heinrich Schuchardt · Alexander Graf
1 parent ba45c9e4e1
Showing 11 changed files with 595 additions and 1 deletions Side-by-side Diff
cmd/bootefi.c
drivers/block/blk-uclass.c
include/blk.h
include/config_fallbacks.h
include/dm/uclass-id.h
include/efi_driver.h
include/efi_loader.h
lib/Makefile
lib/efi_driver/Makefile
lib/efi_driver/efi_block_device.c
lib/efi_driver/efi_uclass.c
@@ -32,6 +32,9 @@
 {
 	efi_obj_list_initalized = 1;
  
+	/* Initialize EFI driver uclass */
+	efi_driver_init();
+
 	efi_console_register();
 #ifdef CONFIG_PARTITIONS
 	efi_disk_register();
@@ -24,6 +24,7 @@
 	[IF_TYPE_HOST]		= "host",
 	[IF_TYPE_SYSTEMACE]	= "ace",
 	[IF_TYPE_NVME]		= "nvme",
+	[IF_TYPE_EFI]		= "efi",
 };
  
 static enum uclass_id if_type_uclass_id[IF_TYPE_COUNT] = {
  
@@ -36,8 +37,9 @@
 	[IF_TYPE_SD]		= UCLASS_INVALID,
 	[IF_TYPE_SATA]		= UCLASS_AHCI,
 	[IF_TYPE_HOST]		= UCLASS_ROOT,
-	[IF_TYPE_NVME]		= UCLASS_NVME,
 	[IF_TYPE_SYSTEMACE]	= UCLASS_INVALID,
+	[IF_TYPE_NVME]		= UCLASS_NVME,
+	[IF_TYPE_EFI]		= UCLASS_EFI,
 };
  
 static enum if_type if_typename_to_iftype(const char *if_typename)
@@ -34,6 +34,7 @@
 	IF_TYPE_HOST,
 	IF_TYPE_SYSTEMACE,
 	IF_TYPE_NVME,
+	IF_TYPE_EFI,
  
 	IF_TYPE_COUNT,			/* Number of interface types */
 };
@@ -52,6 +52,7 @@
 	defined(CONFIG_MMC) || \
 	defined(CONFIG_NVME) || \
 	defined(CONFIG_SYSTEMACE) || \
+	(defined(CONFIG_EFI_LOADER) && !defined(CONFIG_SPL_BUILD)) || \
 	defined(CONFIG_SANDBOX)
 #define HAVE_BLOCK_DEVICE
 #endif
@@ -34,6 +34,7 @@
 	UCLASS_CROS_EC,		/* Chrome OS EC */
 	UCLASS_DISPLAY,		/* Display (e.g. DisplayPort, HDMI) */
 	UCLASS_DMA,		/* Direct Memory Access */
+	UCLASS_EFI,		/* EFI managed devices */
 	UCLASS_ETH,		/* Ethernet device */
 	UCLASS_GPIO,		/* Bank of general-purpose I/O pins */
 	UCLASS_FIRMWARE,	/* Firmware */
+/*
+ *  EFI application loader
+ *
+ *  Copyright (c) 2017 Heinrich Schuchardt
+ *
+ *  SPDX-License-Identifier:     GPL-2.0+
+ */
+
+#ifndef _EFI_DRIVER_H
+#define _EFI_DRIVER_H 1
+
+#include <common.h>
+#include <dm.h>
+#include <efi_loader.h>
+
+struct efi_driver_ops {
+	const efi_guid_t *protocol;
+	const efi_guid_t *child_protocol;
+	int (*bind)(efi_handle_t handle, void *interface);
+};
+
+/*
+ * This structure adds internal fields to the driver binding protocol.
+ */
+struct efi_driver_binding_extended_protocol {
+	struct efi_driver_binding_protocol bp;
+	const struct efi_driver_ops *ops;
+};
+
+#endif /* _EFI_DRIVER_H */
@@ -271,6 +271,8 @@
 /* Adds a range into the EFI memory map */
 uint64_t efi_add_memory_map(uint64_t start, uint64_t pages, int memory_type,
 			    bool overlap_only_ram);
+/* Called by board init to initialize the EFI drivers */
+int efi_driver_init(void);
 /* Called by board init to initialize the EFI memory map */
 int efi_memory_init(void);
 /* Adds new or overrides configuration table entry to the system table */
@@ -8,6 +8,7 @@
 ifndef CONFIG_SPL_BUILD
  
 obj-$(CONFIG_EFI) += efi/
+obj-$(CONFIG_EFI_LOADER) += efi_driver/
 obj-$(CONFIG_EFI_LOADER) += efi_loader/
 obj-$(CONFIG_EFI_LOADER) += efi_selftest/
 obj-$(CONFIG_LZMA) += lzma/
+#
+# (C) Copyright 2017 Heinrich Schuchardt
+#
+#  SPDX-License-Identifier:     GPL-2.0+
+#
+
+# This file only gets included with CONFIG_EFI_LOADER set, so all
+# object inclusion implicitly depends on it
+
+obj-y += efi_uclass.o
+ifeq ($(CONFIG_BLK)$(CONFIG_PARTITIONS),yy)
+obj-y += efi_block_device.o
+endif
+/*
+ *  EFI block driver
+ *
+ *  Copyright (c) 2017 Heinrich Schuchardt
+ *
+ *  SPDX-License-Identifier:     GPL-2.0+
+ *
+ * The EFI uclass creates a handle for this driver and installs the
+ * driver binding protocol on it.
+ *
+ * The EFI block driver binds to controllers implementing the block io
+ * protocol.
+ *
+ * When the bind function of the EFI block driver is called it creates a
+ * new U-Boot block device. It installs child handles for all partitions and
+ * installs the simple file protocol on these.
+ *
+ * The read and write functions of the EFI block driver delegate calls to the
+ * controller that it is bound to.
+ *
+ * A usage example is as following:
+ *
+ * U-Boot loads the iPXE snp.efi executable. iPXE connects an iSCSI drive and
+ * exposes a handle with the block IO protocol. It calls ConnectController.
+ *
+ * Now the EFI block driver installs the partitions with the simple file
+ * protocol.
+ *
+ * iPXE uses the simple file protocol to load Grub or the Linux Kernel.
+ */
+
+#include <efi_driver.h>
+#include <dm/device-internal.h>
+#include <dm/root.h>
+
+/*
+ * EFI attributes of the udevice handled by this driver.
+ *
+ * handle	handle of the controller on which this driver is installed
+ * io		block io protocol proxied by this driver
+ */
+struct efi_blk_priv {
+	efi_handle_t		handle;
+	struct efi_block_io	*io;
+};
+
+/*
+ * Read from block device
+ *
+ * @dev		device
+ * @blknr	first block to be read
+ * @blkcnt	number of blocks to read
+ * @buffer	output buffer
+ * @return	number of blocks transferred
+ */
+static ulong efi_bl_read(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt,
+			 void *buffer)
+{
+	struct efi_blk_priv *priv = dev->priv;
+	struct efi_block_io *io = priv->io;
+	efi_status_t ret;
+
+	EFI_PRINT("%s: read '%s', from block " LBAFU ", " LBAFU " blocks\n",
+		  __func__, dev->name, blknr, blkcnt);
+	ret = EFI_CALL(io->read_blocks(
+				io, io->media->media_id, (u64)blknr,
+				(efi_uintn_t)blkcnt *
+				(efi_uintn_t)io->media->block_size, buffer));
+	EFI_PRINT("%s: r = %u\n", __func__,
+		  (unsigned int)(ret & ~EFI_ERROR_MASK));
+	if (ret != EFI_SUCCESS)
+		return 0;
+	return blkcnt;
+}
+
+/*
+ * Write to block device
+ *
+ * @dev		device
+ * @blknr	first block to be write
+ * @blkcnt	number of blocks to write
+ * @buffer	input buffer
+ * @return	number of blocks transferred
+ */
+static ulong efi_bl_write(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt,
+			  const void *buffer)
+{
+	struct efi_blk_priv *priv = dev->priv;
+	struct efi_block_io *io = priv->io;
+	efi_status_t ret;
+
+	EFI_PRINT("%s: write '%s', from block " LBAFU ", " LBAFU " blocks\n",
+		  __func__, dev->name, blknr, blkcnt);
+	ret = EFI_CALL(io->write_blocks(
+				io, io->media->media_id, (u64)blknr,
+				(efi_uintn_t)blkcnt *
+				(efi_uintn_t)io->media->block_size,
+				(void *)buffer));
+	EFI_PRINT("%s: r = %u\n", __func__,
+		  (unsigned int)(ret & ~EFI_ERROR_MASK));
+	if (ret != EFI_SUCCESS)
+		return 0;
+	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
+ *
+ * @handle	handle
+ * @interface	block io protocol
+ * @return	0 = success
+ */
+static int efi_bl_bind(efi_handle_t handle, void *interface)
+{
+	struct udevice *bdev, *parent = dm_root();
+	int ret, devnum;
+	char *name;
+	struct efi_object *obj = efi_search_obj(handle);
+	struct efi_block_io *io = interface;
+	int disks;
+	struct efi_blk_priv *priv;
+
+	EFI_PRINT("%s: handle %p, interface %p\n", __func__, handle, io);
+
+	if (!obj)
+		return -ENOENT;
+
+	devnum = blk_find_max_devnum(IF_TYPE_EFI);
+	if (devnum == -ENODEV)
+		devnum = 0;
+	else if (devnum < 0)
+		return devnum;
+
+	name = calloc(1, 18); /* strlen("efiblk#2147483648") + 1 */
+	if (!name)
+		return -ENOMEM;
+	sprintf(name, "efiblk#%d", devnum);
+
+	/* Create driver model udevice for the EFI block io device */
+	ret = blk_create_device(parent, "efi_blk", name, IF_TYPE_EFI, devnum,
+				io->media->block_size,
+				(lbaint_t)io->media->last_block, &bdev);
+	if (ret)
+		return ret;
+	if (!bdev)
+		return -ENOENT;
+	/* Allocate priv */
+	ret = device_probe(bdev);
+	if (ret)
+		return ret;
+	EFI_PRINT("%s: block device '%s' created\n", __func__, bdev->name);
+
+	priv = bdev->priv;
+	priv->handle = handle;
+	priv->io = interface;
+
+	ret = blk_prepare_device(bdev);
+
+	/* Create handles for the partions of the block device */
+	disks = efi_bl_bind_partitions(handle, bdev);
+	EFI_PRINT("Found %d partitions\n", disks);
+
+	return 0;
+}
+
+/* Block device driver operators */
+static const struct blk_ops efi_blk_ops = {
+	.read	= efi_bl_read,
+	.write	= efi_bl_write,
+};
+
+/* Identify as block device driver */
+U_BOOT_DRIVER(efi_blk) = {
+	.name			= "efi_blk",
+	.id			= UCLASS_BLK,
+	.ops			= &efi_blk_ops,
+	.priv_auto_alloc_size	= sizeof(struct efi_blk_priv),
+};
+
+/* EFI driver operators */
+static const struct efi_driver_ops driver_ops = {
+	.protocol	= &efi_block_io_guid,
+	.child_protocol = &efi_block_io_guid,
+	.bind		= efi_bl_bind,
+};
+
+/* Identify as EFI driver */
+U_BOOT_DRIVER(efi_block) = {
+	.name		= "EFI block driver",
+	.id		= UCLASS_EFI,
+	.ops		= &driver_ops,
+};
+/*
+ *  Uclass for EFI drivers
+ *
+ *  Copyright (c) 2017 Heinrich Schuchardt
+ *
+ *  SPDX-License-Identifier:     GPL-2.0+
+ *
+ * For each EFI driver the uclass
+ * - creates a handle
+ * - installs the driver binding protocol
+ *
+ * The uclass provides the bind, start, and stop entry points for the driver
+ * binding protocol.
+ *
+ * In bind() and stop() it checks if the controller implements the protocol
+ * supported by the EFI driver. In the start() function it calls the bind()
+ * function of the EFI driver. In the stop() function it destroys the child
+ * controllers.
+ */
+
+#include <efi_driver.h>
+
+/*
+ * Check node type. We do not support partitions as controller handles.
+ *
+ * @handle	handle to be checked
+ * @return	status code
+ */
+static efi_status_t check_node_type(efi_handle_t handle)
+{
+	efi_status_t r, ret = EFI_SUCCESS;
+	const struct efi_device_path *dp;
+
+	/* Open the device path protocol */
+	r = EFI_CALL(systab.boottime->open_protocol(
+			handle, &efi_guid_device_path, (void **)&dp,
+			NULL, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL));
+	if (r == EFI_SUCCESS && dp) {
+		/* Get the last node */
+		const struct efi_device_path *node = efi_dp_last_node(dp);
+		/* We do not support partitions as controller */
+		if (!node || node->type == DEVICE_PATH_TYPE_MEDIA_DEVICE)
+			ret = EFI_UNSUPPORTED;
+	}
+	return ret;
+}
+
+/*
+ * Check if the driver supports the controller.
+ *
+ * @this			driver binding protocol
+ * @controller_handle		handle of the controller
+ * @remaining_device_path	path specifying the child controller
+ * @return			status code
+ */
+static efi_status_t EFIAPI efi_uc_supported(
+		struct efi_driver_binding_protocol *this,
+		efi_handle_t controller_handle,
+		struct efi_device_path *remaining_device_path)
+{
+	efi_status_t r, ret;
+	void *interface;
+	struct efi_driver_binding_extended_protocol *bp =
+			(struct efi_driver_binding_extended_protocol *)this;
+
+	EFI_ENTRY("%p, %p, %ls", this, controller_handle,
+		  efi_dp_str(remaining_device_path));
+
+	ret = EFI_CALL(systab.boottime->open_protocol(
+			controller_handle, bp->ops->protocol,
+			&interface, this->driver_binding_handle,
+			controller_handle, EFI_OPEN_PROTOCOL_BY_DRIVER));
+	switch (ret) {
+	case EFI_ACCESS_DENIED:
+	case EFI_ALREADY_STARTED:
+		goto out;
+	case EFI_SUCCESS:
+		break;
+	default:
+		ret = EFI_UNSUPPORTED;
+		goto out;
+	}
+
+	ret = check_node_type(controller_handle);
+
+	r = EFI_CALL(systab.boottime->close_protocol(
+				controller_handle, bp->ops->protocol,
+				this->driver_binding_handle,
+				controller_handle));
+	if (r != EFI_SUCCESS)
+		ret = EFI_UNSUPPORTED;
+out:
+	return EFI_EXIT(ret);
+}
+
+/*
+ * Create child controllers and attach driver.
+ *
+ * @this			driver binding protocol
+ * @controller_handle		handle of the controller
+ * @remaining_device_path	path specifying the child controller
+ * @return			status code
+ */
+static efi_status_t EFIAPI efi_uc_start(
+		struct efi_driver_binding_protocol *this,
+		efi_handle_t controller_handle,
+		struct efi_device_path *remaining_device_path)
+{
+	efi_status_t r, ret;
+	void *interface = NULL;
+	struct efi_driver_binding_extended_protocol *bp =
+			(struct efi_driver_binding_extended_protocol *)this;
+
+	EFI_ENTRY("%p, %pUl, %ls", this, controller_handle,
+		  efi_dp_str(remaining_device_path));
+
+	/* Attach driver to controller */
+	ret = EFI_CALL(systab.boottime->open_protocol(
+			controller_handle, bp->ops->protocol,
+			&interface, this->driver_binding_handle,
+			controller_handle, EFI_OPEN_PROTOCOL_BY_DRIVER));
+	switch (ret) {
+	case EFI_ACCESS_DENIED:
+	case EFI_ALREADY_STARTED:
+		goto out;
+	case EFI_SUCCESS:
+		break;
+	default:
+		ret =  EFI_UNSUPPORTED;
+		goto out;
+	}
+	ret = check_node_type(controller_handle);
+	if (ret != EFI_SUCCESS) {
+		r = EFI_CALL(systab.boottime->close_protocol(
+				controller_handle, bp->ops->protocol,
+				this->driver_binding_handle,
+				controller_handle));
+		if (r != EFI_SUCCESS)
+			EFI_PRINT("Failure to close handle\n");
+		goto out;
+	}
+
+	/* TODO: driver specific stuff */
+	bp->ops->bind(controller_handle, interface);
+
+out:
+	return EFI_EXIT(ret);
+}
+
+/*
+ * Remove a single child controller from the parent controller.
+ *
+ * @controller_handle	parent controller
+ * @child_handle	child controller
+ * @return		status code
+ */
+static efi_status_t disconnect_child(efi_handle_t controller_handle,
+				     efi_handle_t child_handle)
+{
+	efi_status_t ret;
+	efi_guid_t *guid_controller = NULL;
+	efi_guid_t *guid_child_controller = NULL;
+
+	ret = EFI_CALL(systab.boottime->close_protocol(
+				controller_handle, guid_controller,
+				child_handle, child_handle));
+	if (ret != EFI_SUCCESS) {
+		EFI_PRINT("Cannot close protocol\n");
+		return ret;
+	}
+	ret = EFI_CALL(systab.boottime->uninstall_protocol_interface(
+				child_handle, guid_child_controller, NULL));
+	if (ret != EFI_SUCCESS) {
+		EFI_PRINT("Cannot uninstall protocol interface\n");
+		return ret;
+	}
+	return ret;
+}
+
+/*
+ * Remove child controllers and disconnect the controller.
+ *
+ * @this			driver binding protocol
+ * @controller_handle		handle of the controller
+ * @number_of_children		number of child controllers to remove
+ * @child_handle_buffer		handles of the child controllers to remove
+ * @return			status code
+ */
+static efi_status_t EFIAPI efi_uc_stop(
+		struct efi_driver_binding_protocol *this,
+		efi_handle_t controller_handle,
+		size_t number_of_children,
+		efi_handle_t *child_handle_buffer)
+{
+	efi_status_t ret;
+	efi_uintn_t count;
+	struct efi_open_protocol_info_entry *entry_buffer;
+	efi_guid_t *guid_controller = NULL;
+
+	EFI_ENTRY("%p, %pUl, %zu, %p", this, controller_handle,
+		  number_of_children, child_handle_buffer);
+
+	/* Destroy provided child controllers */
+	if (number_of_children) {
+		efi_uintn_t i;
+
+		for (i = 0; i < number_of_children; ++i) {
+			ret = disconnect_child(controller_handle,
+					       child_handle_buffer[i]);
+			if (ret != EFI_SUCCESS)
+				return ret;
+		}
+		return EFI_SUCCESS;
+	}
+
+	/* Destroy all children */
+	ret = EFI_CALL(systab.boottime->open_protocol_information(
+					controller_handle, guid_controller,
+					&entry_buffer, &count));
+	if (ret != EFI_SUCCESS)
+		goto out;
+	while (count) {
+		if (entry_buffer[--count].attributes &
+		    EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) {
+			ret = disconnect_child(
+					controller_handle,
+					entry_buffer[count].agent_handle);
+			if (ret != EFI_SUCCESS)
+				goto out;
+		}
+	}
+	ret = EFI_CALL(systab.boottime->free_pool(entry_buffer));
+	if (ret != EFI_SUCCESS)
+		printf("%s(%u) %s: ERROR: Cannot free pool\n",
+		       __FILE__, __LINE__, __func__);
+
+	/* Detach driver from controller */
+	ret = EFI_CALL(systab.boottime->close_protocol(
+			controller_handle, guid_controller,
+			this->driver_binding_handle, controller_handle));
+out:
+	return EFI_EXIT(ret);
+}
+
+static efi_status_t efi_add_driver(struct driver *drv)
+{
+	efi_status_t ret;
+	const struct efi_driver_ops *ops = drv->ops;
+	struct efi_driver_binding_extended_protocol *bp;
+
+	debug("EFI: Adding driver '%s'\n", drv->name);
+	if (!ops->protocol) {
+		printf("EFI: ERROR: protocol GUID missing for driver '%s'\n",
+		       drv->name);
+		return EFI_INVALID_PARAMETER;
+	}
+	bp = calloc(1, sizeof(struct efi_driver_binding_extended_protocol));
+	if (!bp)
+		return EFI_OUT_OF_RESOURCES;
+
+	bp->bp.supported = efi_uc_supported;
+	bp->bp.start = efi_uc_start;
+	bp->bp.stop = efi_uc_stop;
+	bp->bp.version = 0xffffffff;
+	bp->ops = drv->ops;
+
+	ret = efi_create_handle(&bp->bp.driver_binding_handle);
+	if (ret != EFI_SUCCESS) {
+		free(bp);
+		goto out;
+	}
+	bp->bp.image_handle = bp->bp.driver_binding_handle;
+	ret = efi_add_protocol(bp->bp.driver_binding_handle,
+			       &efi_guid_driver_binding_protocol, bp);
+	if (ret != EFI_SUCCESS) {
+		efi_delete_handle(bp->bp.driver_binding_handle);
+		free(bp);
+		goto out;
+	}
+out:
+	return ret;
+}
+
+/*
+ * Initialize the EFI drivers.
+ * Called by board_init_r().
+ *
+ * @return	0 = success, any other value will stop further execution
+ */
+int efi_driver_init(void)
+{
+	struct driver *drv;
+	int ret = 0;
+
+	/* Save 'gd' pointer */
+	efi_save_gd();
+
+	debug("EFI: Initializing EFI driver framework\n");
+	for (drv = ll_entry_start(struct driver, driver);
+	     drv < ll_entry_end(struct driver, driver); ++drv) {
+		if (drv->id == UCLASS_EFI) {
+			ret = efi_add_driver(drv);
+			if (ret) {
+				printf("EFI: ERROR: failed to add driver %s\n",
+				       drv->name);
+				break;
+			}
+		}
+	}
+	return ret;
+}
+
+static int efi_uc_init(struct uclass *class)
+{
+	printf("EFI: Initializing UCLASS_EFI\n");
+	return 0;
+}
+
+static int efi_uc_destroy(struct uclass *class)
+{
+	printf("Destroying  UCLASS_EFI\n");
+	return 0;
+}
+
+UCLASS_DRIVER(efi) = {
+	.name		= "efi",
+	.id		= UCLASS_EFI,
+	.init		= efi_uc_init,
+	.destroy	= efi_uc_destroy,
+};
...	...	@@ -32,6 +32,9 @@
32	32	{
33	33	efi_obj_list_initalized = 1;
34	34
	35	+ /* Initialize EFI driver uclass */
	36	+ efi_driver_init();
	37	+
35	38	efi_console_register();
36	39	#ifdef CONFIG_PARTITIONS
37	40	efi_disk_register();
...	...	@@ -24,6 +24,7 @@
24	24	[IF_TYPE_HOST] = "host",
25	25	[IF_TYPE_SYSTEMACE] = "ace",
26	26	[IF_TYPE_NVME] = "nvme",
	27	+ [IF_TYPE_EFI] = "efi",
27	28	};
28	29
29	30	static enum uclass_id if_type_uclass_id[IF_TYPE_COUNT] = {
30	31
...	...	@@ -36,8 +37,9 @@
36	37	[IF_TYPE_SD] = UCLASS_INVALID,
37	38	[IF_TYPE_SATA] = UCLASS_AHCI,
38	39	[IF_TYPE_HOST] = UCLASS_ROOT,
39		- [IF_TYPE_NVME] = UCLASS_NVME,
40	40	[IF_TYPE_SYSTEMACE] = UCLASS_INVALID,
	41	+ [IF_TYPE_NVME] = UCLASS_NVME,
	42	+ [IF_TYPE_EFI] = UCLASS_EFI,
41	43	};
42	44
43	45	static enum if_type if_typename_to_iftype(const char *if_typename)
...	...	@@ -34,6 +34,7 @@
34	34	IF_TYPE_HOST,
35	35	IF_TYPE_SYSTEMACE,
36	36	IF_TYPE_NVME,
	37	+ IF_TYPE_EFI,
37	38
38	39	IF_TYPE_COUNT, /* Number of interface types */
39	40	};
...	...	@@ -52,6 +52,7 @@
52	52	defined(CONFIG_MMC) \|\| \
53	53	defined(CONFIG_NVME) \|\| \
54	54	defined(CONFIG_SYSTEMACE) \|\| \
	55	+ (defined(CONFIG_EFI_LOADER) && !defined(CONFIG_SPL_BUILD)) \|\| \
55	56	defined(CONFIG_SANDBOX)
56	57	#define HAVE_BLOCK_DEVICE
57	58	#endif
...	...	@@ -34,6 +34,7 @@
34	34	UCLASS_CROS_EC, /* Chrome OS EC */
35	35	UCLASS_DISPLAY, /* Display (e.g. DisplayPort, HDMI) */
36	36	UCLASS_DMA, /* Direct Memory Access */
	37	+ UCLASS_EFI, /* EFI managed devices */
37	38	UCLASS_ETH, /* Ethernet device */
38	39	UCLASS_GPIO, /* Bank of general-purpose I/O pins */
39	40	UCLASS_FIRMWARE, /* Firmware */
	1	+/*
	2	+ * EFI application loader
	3	+ *
	4	+ * Copyright (c) 2017 Heinrich Schuchardt
	5	+ *
	6	+ * SPDX-License-Identifier: GPL-2.0+
	7	+ */
	8	+
	9	+#ifndef _EFI_DRIVER_H
	10	+#define _EFI_DRIVER_H 1
	11	+
	12	+#include <common.h>
	13	+#include <dm.h>
	14	+#include <efi_loader.h>
	15	+
	16	+struct efi_driver_ops {
	17	+ const efi_guid_t *protocol;
	18	+ const efi_guid_t *child_protocol;
	19	+ int (bind)(efi_handle_t handle, void interface);
	20	+};
	21	+
	22	+/*
	23	+ * This structure adds internal fields to the driver binding protocol.
	24	+ */
	25	+struct efi_driver_binding_extended_protocol {
	26	+ struct efi_driver_binding_protocol bp;
	27	+ const struct efi_driver_ops *ops;
	28	+};
	29	+
	30	+#endif /* _EFI_DRIVER_H */
...	...	@@ -271,6 +271,8 @@
271	271	/* Adds a range into the EFI memory map */
272	272	uint64_t efi_add_memory_map(uint64_t start, uint64_t pages, int memory_type,
273	273	bool overlap_only_ram);
	274	+/* Called by board init to initialize the EFI drivers */
	275	+int efi_driver_init(void);
274	276	/* Called by board init to initialize the EFI memory map */
275	277	int efi_memory_init(void);
276	278	/* Adds new or overrides configuration table entry to the system table */
...	...	@@ -8,6 +8,7 @@
8	8	ifndef CONFIG_SPL_BUILD
9	9
10	10	obj-$(CONFIG_EFI) += efi/
	11	+obj-$(CONFIG_EFI_LOADER) += efi_driver/
11	12	obj-$(CONFIG_EFI_LOADER) += efi_loader/
12	13	obj-$(CONFIG_EFI_LOADER) += efi_selftest/
13	14	obj-$(CONFIG_LZMA) += lzma/
	1	+#
	2	+# (C) Copyright 2017 Heinrich Schuchardt
	3	+#
	4	+# SPDX-License-Identifier: GPL-2.0+
	5	+#
	6	+
	7	+# This file only gets included with CONFIG_EFI_LOADER set, so all
	8	+# object inclusion implicitly depends on it
	9	+
	10	+obj-y += efi_uclass.o
	11	+ifeq ($(CONFIG_BLK)$(CONFIG_PARTITIONS),yy)
	12	+obj-y += efi_block_device.o
	13	+endif
	1	+/*
	2	+ * EFI block driver
	3	+ *
	4	+ * Copyright (c) 2017 Heinrich Schuchardt
	5	+ *
	6	+ * SPDX-License-Identifier: GPL-2.0+
	7	+ *
	8	+ * The EFI uclass creates a handle for this driver and installs the
	9	+ * driver binding protocol on it.
	10	+ *
	11	+ * The EFI block driver binds to controllers implementing the block io
	12	+ * protocol.
	13	+ *
	14	+ * When the bind function of the EFI block driver is called it creates a
	15	+ * new U-Boot block device. It installs child handles for all partitions and
	16	+ * installs the simple file protocol on these.
	17	+ *
	18	+ * The read and write functions of the EFI block driver delegate calls to the
	19	+ * controller that it is bound to.
	20	+ *
	21	+ * A usage example is as following:
	22	+ *
	23	+ * U-Boot loads the iPXE snp.efi executable. iPXE connects an iSCSI drive and
	24	+ * exposes a handle with the block IO protocol. It calls ConnectController.
	25	+ *
	26	+ * Now the EFI block driver installs the partitions with the simple file
	27	+ * protocol.
	28	+ *
	29	+ * iPXE uses the simple file protocol to load Grub or the Linux Kernel.
	30	+ */
	31	+
	32	+#include <efi_driver.h>
	33	+#include <dm/device-internal.h>
	34	+#include <dm/root.h>
	35	+
	36	+/*
	37	+ * EFI attributes of the udevice handled by this driver.
	38	+ *
	39	+ * handle handle of the controller on which this driver is installed
	40	+ * io block io protocol proxied by this driver
	41	+ */
	42	+struct efi_blk_priv {
	43	+ efi_handle_t handle;
	44	+ struct efi_block_io *io;
	45	+};
	46	+
	47	+/*
	48	+ * Read from block device
	49	+ *
	50	+ * @dev device
	51	+ * @blknr first block to be read
	52	+ * @blkcnt number of blocks to read
	53	+ * @buffer output buffer
	54	+ * @return number of blocks transferred
	55	+ */
	56	+static ulong efi_bl_read(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt,
	57	+ void *buffer)
	58	+{
	59	+ struct efi_blk_priv *priv = dev->priv;
	60	+ struct efi_block_io *io = priv->io;
	61	+ efi_status_t ret;
	62	+
	63	+ EFI_PRINT("%s: read '%s', from block " LBAFU ", " LBAFU " blocks\n",
	64	+ __func__, dev->name, blknr, blkcnt);
	65	+ ret = EFI_CALL(io->read_blocks(
	66	+ io, io->media->media_id, (u64)blknr,
	67	+ (efi_uintn_t)blkcnt *
	68	+ (efi_uintn_t)io->media->block_size, buffer));
	69	+ EFI_PRINT("%s: r = %u\n", __func__,
	70	+ (unsigned int)(ret & ~EFI_ERROR_MASK));
	71	+ if (ret != EFI_SUCCESS)
	72	+ return 0;
	73	+ return blkcnt;
	74	+}
	75	+
	76	+/*
	77	+ * Write to block device
	78	+ *
	79	+ * @dev device
	80	+ * @blknr first block to be write
	81	+ * @blkcnt number of blocks to write
	82	+ * @buffer input buffer
	83	+ * @return number of blocks transferred
	84	+ */
	85	+static ulong efi_bl_write(struct udevice *dev, lbaint_t blknr, lbaint_t blkcnt,
	86	+ const void *buffer)
	87	+{
	88	+ struct efi_blk_priv *priv = dev->priv;
	89	+ struct efi_block_io *io = priv->io;
	90	+ efi_status_t ret;
	91	+
	92	+ EFI_PRINT("%s: write '%s', from block " LBAFU ", " LBAFU " blocks\n",
	93	+ __func__, dev->name, blknr, blkcnt);
	94	+ ret = EFI_CALL(io->write_blocks(
	95	+ io, io->media->media_id, (u64)blknr,
	96	+ (efi_uintn_t)blkcnt *
	97	+ (efi_uintn_t)io->media->block_size,
	98	+ (void *)buffer));
	99	+ EFI_PRINT("%s: r = %u\n", __func__,
	100	+ (unsigned int)(ret & ~EFI_ERROR_MASK));
	101	+ if (ret != EFI_SUCCESS)
	102	+ return 0;
	103	+ return blkcnt;
	104	+}
	105	+
	106	+/*
	107	+ * Create partions for the block device.
	108	+ *
	109	+ * @handle EFI handle of the block device
	110	+ * @dev udevice of the block device
	111	+ */
	112	+static int efi_bl_bind_partitions(efi_handle_t handle, struct udevice *dev)
	113	+{
	114	+ struct blk_desc *desc;
	115	+ const char *if_typename;
	116	+
	117	+ desc = dev_get_uclass_platdata(dev);
	118	+ if_typename = blk_get_if_type_name(desc->if_type);
	119	+
	120	+ return efi_disk_create_partitions(handle, desc, if_typename,
	121	+ desc->devnum, dev->name);
	122	+}
	123	+
	124	+/*
	125	+ * Create a block device for a handle
	126	+ *
	127	+ * @handle handle
	128	+ * @interface block io protocol
	129	+ * @return 0 = success
	130	+ */
	131	+static int efi_bl_bind(efi_handle_t handle, void *interface)
	132	+{
	133	+ struct udevice bdev, parent = dm_root();
	134	+ int ret, devnum;
	135	+ char *name;
	136	+ struct efi_object *obj = efi_search_obj(handle);
	137	+ struct efi_block_io *io = interface;
	138	+ int disks;
	139	+ struct efi_blk_priv *priv;
	140	+
	141	+ EFI_PRINT("%s: handle %p, interface %p\n", __func__, handle, io);
	142	+
	143	+ if (!obj)
	144	+ return -ENOENT;
	145	+
	146	+ devnum = blk_find_max_devnum(IF_TYPE_EFI);
	147	+ if (devnum == -ENODEV)
	148	+ devnum = 0;
	149	+ else if (devnum < 0)
	150	+ return devnum;
	151	+
	152	+ name = calloc(1, 18); /* strlen("efiblk#2147483648") + 1 */
	153	+ if (!name)
	154	+ return -ENOMEM;
	155	+ sprintf(name, "efiblk#%d", devnum);
	156	+
	157	+ /* Create driver model udevice for the EFI block io device */
	158	+ ret = blk_create_device(parent, "efi_blk", name, IF_TYPE_EFI, devnum,
	159	+ io->media->block_size,
	160	+ (lbaint_t)io->media->last_block, &bdev);
	161	+ if (ret)
	162	+ return ret;
	163	+ if (!bdev)
	164	+ return -ENOENT;
	165	+ /* Allocate priv */
	166	+ ret = device_probe(bdev);
	167	+ if (ret)
	168	+ return ret;
	169	+ EFI_PRINT("%s: block device '%s' created\n", __func__, bdev->name);
	170	+
	171	+ priv = bdev->priv;
	172	+ priv->handle = handle;
	173	+ priv->io = interface;
	174	+
	175	+ ret = blk_prepare_device(bdev);
	176	+
	177	+ /* Create handles for the partions of the block device */
	178	+ disks = efi_bl_bind_partitions(handle, bdev);
	179	+ EFI_PRINT("Found %d partitions\n", disks);
	180	+
	181	+ return 0;
	182	+}
	183	+
	184	+/* Block device driver operators */
	185	+static const struct blk_ops efi_blk_ops = {
	186	+ .read = efi_bl_read,
	187	+ .write = efi_bl_write,
	188	+};
	189	+
	190	+/* Identify as block device driver */
	191	+U_BOOT_DRIVER(efi_blk) = {
	192	+ .name = "efi_blk",
	193	+ .id = UCLASS_BLK,
	194	+ .ops = &efi_blk_ops,
	195	+ .priv_auto_alloc_size = sizeof(struct efi_blk_priv),
	196	+};
	197	+
	198	+/* EFI driver operators */
	199	+static const struct efi_driver_ops driver_ops = {
	200	+ .protocol = &efi_block_io_guid,
	201	+ .child_protocol = &efi_block_io_guid,
	202	+ .bind = efi_bl_bind,
	203	+};
	204	+
	205	+/* Identify as EFI driver */
	206	+U_BOOT_DRIVER(efi_block) = {
	207	+ .name = "EFI block driver",
	208	+ .id = UCLASS_EFI,
	209	+ .ops = &driver_ops,
	210	+};