[U-Boot] [PATCH v2 00/18] efi_loader: enable EFI driver provided block device

[U-Boot] [PATCH v2 00/18] efi_loader: enable EFI driver provided block device

[Heinrich Schuchardt]

With this patch series an EFI application or driver can supply
a block device which in turn can be used to download an image.

E.g. we can load iPXE, connect iSCSI drives, download grub from the
SAN and afterwards with grub download and run an EFI application.
Booting Linux from an iSCSI drive was successful on arm64.

v2:
	Add an additional patch to fix ExitBootServices.
	Provide comments for EFI block driver.
	Avoid printing when not in debug mode
	Add product tools/file2include to .gitignore.
	Put the patch with the test for block io after the patch for the
	driver.

Heinrich Schuchardt (18):
  efi_loader: return NULL from device path functions
  efi_loader: address of the simple file system protocol
  efi_loader: correct find simple file system protocol
  efi_loader: print device path when entering efi_load_image
  efi_loader: allocate correct memory type for EFI image
  efi_loader: check tables in helloworld.efi
  efi_loader: fix StartImage bootservice
  efi_loader: efi_disk_register: correctly determine if_type_name
  efi_loader: make efi_block_io_guid a global symbol
  efi_loader: provide a function to create a partition node
  efi_loader: make efi_disk_create_partitions a global symbol
  efi_loader: correct EFI_BLOCK_IO_PROTOCOL definitions
  efi_loader: provide function to get last node of a device path
  efi_loader: provide links between devices EFI handles
  tools: provide a tool to convert a binary file to an include
  efi_driver: EFI block driver
  efi_selftest: provide a test for block io
  efi_loader: fix ExitBootServices

 MAINTAINERS                                  |   1 +
 common/board_r.c                             |   3 +
 drivers/block/blk-uclass.c                   |   4 +-
 include/blk.h                                |   1 +
 include/config_fallbacks.h                   |   1 +
 include/dm/device.h                          |   4 +
 include/dm/uclass-id.h                       |   1 +
 include/efi_api.h                            |  16 +-
 include/efi_driver.h                         |  30 ++
 include/efi_loader.h                         |  21 +-
 lib/Makefile                                 |   1 +
 lib/efi_driver/Makefile                      |  13 +
 lib/efi_driver/efi_block_device.c            | 175 ++++++++++++
 lib/efi_driver/efi_uclass.c                  | 330 ++++++++++++++++++++++
 lib/efi_loader/efi_boottime.c                |  42 ++-
 lib/efi_loader/efi_device_path.c             | 168 +++++++++---
 lib/efi_loader/efi_disk.c                    | 137 +++++++---
 lib/efi_loader/efi_image_loader.c            |  64 +++--
 lib/efi_loader/helloworld.c                  |  26 ++
 lib/efi_selftest/Makefile                    |   4 +
 lib/efi_selftest/efi_selftest_block_device.c | 395 +++++++++++++++++++++++++++
 lib/efi_selftest/efi_selftest_disk_image.h   |  69 +++++
 tools/.gitignore                             |   1 +
 tools/Makefile                               |   3 +
 tools/file2include.c                         | 106 +++++++
 25 files changed, 1493 insertions(+), 123 deletions(-)
 create mode 100644 include/efi_driver.h
 create mode 100644 lib/efi_driver/Makefile
 create mode 100644 lib/efi_driver/efi_block_device.c
 create mode 100644 lib/efi_driver/efi_uclass.c
 create mode 100644 lib/efi_selftest/efi_selftest_block_device.c
 create mode 100644 lib/efi_selftest/efi_selftest_disk_image.h
 create mode 100644 tools/file2include.c

-- 
2.14.2

[U-Boot] [PATCH v2 01/18] efi_loader: return NULL from device path functions

[Heinrich Schuchardt]

For the construction of device paths we need to call the
AllocatePool service. We should not ignore if it fails due to an
out of memory situation.

This patch changes the device path functions to return NULL if
the memory allocation fails.

Additional patches will be needed to fix the callers.

Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
---
v2
	No change
---
 include/efi_loader.h             |  6 +++---
 lib/efi_loader/efi_device_path.c | 42 ++++++++++++++++++++++++++++++++++------
 2 files changed, 39 insertions(+), 9 deletions(-)

diff --git a/include/efi_loader.h b/include/efi_loader.h
index 37389c33cc..6b623d8327 100644
--- a/include/efi_loader.h
+++ b/include/efi_loader.h
@@ -304,9 +304,9 @@ struct efi_device_path *efi_dp_from_eth(void);
 struct efi_device_path *efi_dp_from_mem(uint32_t mem_type,
 					uint64_t start_address,
 					uint64_t end_address);
-void efi_dp_split_file_path(struct efi_device_path *full_path,
-			    struct efi_device_path **device_path,
-			    struct efi_device_path **file_path);
+efi_status_t efi_dp_split_file_path(struct efi_device_path *full_path,
+				    struct efi_device_path **device_path,
+				    struct efi_device_path **file_path);
 
 #define EFI_DP_TYPE(_dp, _type, _subtype) \
 	(((_dp)->type == DEVICE_PATH_TYPE_##_type) && \
diff --git a/lib/efi_loader/efi_device_path.c b/lib/efi_loader/efi_device_path.c
index 2a8efea6e7..c1ba54e6bd 100644
--- a/lib/efi_loader/efi_device_path.c
+++ b/lib/efi_loader/efi_device_path.c
@@ -58,8 +58,11 @@ static void *dp_alloc(size_t sz)
 {
 	void *buf;
 
-	if (efi_allocate_pool(EFI_ALLOCATE_ANY_PAGES, sz, &buf) != EFI_SUCCESS)
+	if (efi_allocate_pool(EFI_ALLOCATE_ANY_PAGES, sz, &buf) !=
+	    EFI_SUCCESS) {
+		debug("EFI: ERROR: out of memory in %s\n", __func__);
 		return NULL;
+	}
 
 	return buf;
 }
@@ -227,6 +230,8 @@ struct efi_device_path *efi_dp_dup(const struct efi_device_path *dp)
 		return NULL;
 
 	ndp = dp_alloc(sz);
+	if (!ndp)
+		return NULL;
 	memcpy(ndp, dp, sz);
 
 	return ndp;
@@ -246,6 +251,8 @@ struct efi_device_path *efi_dp_append(const struct efi_device_path *dp1,
 		unsigned sz1 = efi_dp_size(dp1);
 		unsigned sz2 = efi_dp_size(dp2);
 		void *p = dp_alloc(sz1 + sz2 + sizeof(END));
+		if (!p)
+			return NULL;
 		memcpy(p, dp1, sz1);
 		memcpy(p + sz1, dp2, sz2);
 		memcpy(p + sz1 + sz2, &END, sizeof(END));
@@ -267,6 +274,8 @@ struct efi_device_path *efi_dp_append_node(const struct efi_device_path *dp,
 	} else if (!dp) {
 		unsigned sz = node->length;
 		void *p = dp_alloc(sz + sizeof(END));
+		if (!p)
+			return NULL;
 		memcpy(p, node, sz);
 		memcpy(p + sz, &END, sizeof(END));
 		ret = p;
@@ -274,6 +283,8 @@ struct efi_device_path *efi_dp_append_node(const struct efi_device_path *dp,
 		/* both dp and node are non-null */
 		unsigned sz = efi_dp_size(dp);
 		void *p = dp_alloc(sz + node->length + sizeof(END));
+		if (!p)
+			return NULL;
 		memcpy(p, dp, sz);
 		memcpy(p + sz, node, node->length);
 		memcpy(p + sz + node->length, &END, sizeof(END));
@@ -435,6 +446,8 @@ struct efi_device_path *efi_dp_from_dev(struct udevice *dev)
 	void *buf, *start;
 
 	start = buf = dp_alloc(dp_size(dev) + sizeof(END));
+	if (!buf)
+		return NULL;
 	buf = dp_fill(buf, dev);
 	*((struct efi_device_path *)buf) = END;
 
@@ -576,6 +589,8 @@ struct efi_device_path *efi_dp_from_part(struct blk_desc *desc, int part)
 	void *buf, *start;
 
 	start = buf = dp_alloc(dp_part_size(desc, part) + sizeof(END));
+	if (!buf)
+		return NULL;
 
 	buf = dp_part_fill(buf, desc, part);
 
@@ -614,6 +629,8 @@ struct efi_device_path *efi_dp_from_file(struct blk_desc *desc, int part,
 	dpsize += fpsize;
 
 	start = buf = dp_alloc(dpsize + sizeof(END));
+	if (!buf)
+		return NULL;
 
 	if (desc)
 		buf = dp_part_fill(buf, desc, part);
@@ -648,6 +665,8 @@ struct efi_device_path *efi_dp_from_eth(void)
 	dpsize += sizeof(*ndp);
 
 	start = buf = dp_alloc(dpsize + sizeof(END));
+	if (!buf)
+		return NULL;
 
 #ifdef CONFIG_DM_ETH
 	buf = dp_fill(buf, eth_get_dev());
@@ -678,6 +697,8 @@ struct efi_device_path *efi_dp_from_mem(uint32_t memory_type,
 	void *buf, *start;
 
 	start = buf = dp_alloc(sizeof(*mdp) + sizeof(END));
+	if (!buf)
+		return NULL;
 
 	mdp = buf;
 	mdp->dp.type = DEVICE_PATH_TYPE_HARDWARE_DEVICE;
@@ -697,22 +718,31 @@ struct efi_device_path *efi_dp_from_mem(uint32_t memory_type,
  * Helper to split a full device path (containing both device and file
  * parts) into it's constituent parts.
  */
-void efi_dp_split_file_path(struct efi_device_path *full_path,
-			    struct efi_device_path **device_path,
-			    struct efi_device_path **file_path)
+efi_status_t efi_dp_split_file_path(struct efi_device_path *full_path,
+				    struct efi_device_path **device_path,
+				    struct efi_device_path **file_path)
 {
 	struct efi_device_path *p, *dp, *fp;
 
+	*device_path = NULL;
+	*file_path = NULL;
 	dp = efi_dp_dup(full_path);
+	if (!dp)
+		return EFI_OUT_OF_RESOURCES;
 	p = dp;
-	while (!EFI_DP_TYPE(p, MEDIA_DEVICE, FILE_PATH))
+	while (!EFI_DP_TYPE(p, MEDIA_DEVICE, FILE_PATH)) {
 		p = efi_dp_next(p);
+		if (!p)
+			return EFI_OUT_OF_RESOURCES;
+	}
 	fp = efi_dp_dup(p);
-
+	if (!fp)
+		return EFI_OUT_OF_RESOURCES;
 	p->type = DEVICE_PATH_TYPE_END;
 	p->sub_type = DEVICE_PATH_SUB_TYPE_END;
 	p->length = sizeof(*p);
 
 	*device_path = dp;
 	*file_path = fp;
+	return EFI_SUCCESS;
 }
-- 
2.14.2

[U-Boot] [PATCH v2 02/18] efi_loader: address of the simple file system protocol

[Heinrich Schuchardt]

When installing the the simple file system protocol we have to path
the address of the structure and not the address of a pointer ot the
structure.

Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
---
v2
	no change
---
 lib/efi_loader/efi_disk.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/efi_loader/efi_disk.c b/lib/efi_loader/efi_disk.c
index d299fc8dea..85b4a147e2 100644
--- a/lib/efi_loader/efi_disk.c
+++ b/lib/efi_loader/efi_disk.c
@@ -242,7 +242,7 @@ static void efi_disk_add_dev(const char *name,
 							 diskobj->dp);
 		ret = efi_add_protocol(diskobj->parent.handle,
 				       &efi_simple_file_system_protocol_guid,
-				       &diskobj->volume);
+				       diskobj->volume);
 		if (ret != EFI_SUCCESS)
 			goto out_of_memory;
 	}
-- 
2.14.2

[U-Boot] [PATCH v2 03/18] efi_loader: correct find simple file system protocol

[Heinrich Schuchardt]

In contrast to the description the code did not split the device
path into device part and file part.

The code should use the installed protocol and not refer to the
internal structure of the the disk object.

Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
---
v2
	no change
---
 lib/efi_loader/efi_disk.c | 39 +++++++++++++++++++++++++++++----------
 1 file changed, 29 insertions(+), 10 deletions(-)

diff --git a/lib/efi_loader/efi_disk.c b/lib/efi_loader/efi_disk.c
index 85b4a147e2..8771e880f6 100644
--- a/lib/efi_loader/efi_disk.c
+++ b/lib/efi_loader/efi_disk.c
@@ -175,25 +175,44 @@ static const struct efi_block_io block_io_disk_template = {
 };
 
 /*
- * Find filesystem from a device-path.  The passed in path 'p' probably
- * contains one or more /File(name) nodes, so the comparison stops at
- * the first /File() node, and returns the pointer to that via 'rp'.
- * This is mostly intended to be a helper to map a device-path to an
- * efi_file_handle object.
+ * Get the simple file system protocol for a file device path.
+ *
+ * The full path provided is split into device part and into a file
+ * part. The device part is used to find the handle on which the
+ * simple file system protocol is installed.
+ *
+ * @full_path	device path including device and file
+ * @return	simple file system protocol
  */
 struct efi_simple_file_system_protocol *
-efi_fs_from_path(struct efi_device_path *fp)
+efi_fs_from_path(struct efi_device_path *full_path)
 {
 	struct efi_object *efiobj;
-	struct efi_disk_obj *diskobj;
+	struct efi_handler *handler;
+	struct efi_device_path *device_path;
+	struct efi_device_path *file_path;
+	efi_status_t ret;
 
-	efiobj = efi_dp_find_obj(fp, NULL);
+	/* Split the path into a device part and a file part */
+	ret = efi_dp_split_file_path(full_path, &device_path, &file_path);
+	if (ret != EFI_SUCCESS)
+		return NULL;
+	efi_free_pool(file_path);
+
+	/* Get the EFI object for the partition */
+	efiobj = efi_dp_find_obj(device_path, NULL);
+	efi_free_pool(device_path);
 	if (!efiobj)
 		return NULL;
 
-	diskobj = container_of(efiobj, struct efi_disk_obj, parent);
+	/* Find the simple file system protocol */
+	ret = efi_search_protocol(efiobj, &efi_simple_file_system_protocol_guid,
+				  &handler);
+	if (ret != EFI_SUCCESS)
+		return NULL;
 
-	return diskobj->volume;
+	/* Return the simple file system protocol for the partition */
+	return handler->protocol_interface;
 }
 
 /*
-- 
2.14.2

[U-Boot] [PATCH v2 04/18] efi_loader: print device path when entering efi_load_image

[Heinrich Schuchardt]

Use %pD to print the device path instead of its address when
entering efi_load_image.

Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
---
v2
	no change
---
 lib/efi_loader/efi_boottime.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/efi_loader/efi_boottime.c b/lib/efi_loader/efi_boottime.c
index 42cf197af9..e046a7be9d 100644
--- a/lib/efi_loader/efi_boottime.c
+++ b/lib/efi_loader/efi_boottime.c
@@ -1474,7 +1474,7 @@ static efi_status_t EFIAPI efi_load_image(bool boot_policy,
 	struct efi_object *obj;
 	efi_status_t ret;
 
-	EFI_ENTRY("%d, %p, %p, %p, %ld, %p", boot_policy, parent_image,
+	EFI_ENTRY("%d, %p, %pD, %p, %ld, %p", boot_policy, parent_image,
 		  file_path, source_buffer, source_size, image_handle);
 
 	info = calloc(1, sizeof(*info));
-- 
2.14.2

[U-Boot] [PATCH v2 05/18] efi_loader: allocate correct memory type for EFI image

[Heinrich Schuchardt]

The category of memory allocated for an EFI image should depend on
its type (application, bootime service driver, runtime service driver).

Our helloworld.efi built on arm64 has an illegal image type. Treat it
like an EFI application.

Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
---
v2
	no change
---
 lib/efi_loader/efi_image_loader.c | 64 ++++++++++++++++++++++++---------------
 1 file changed, 40 insertions(+), 24 deletions(-)

diff --git a/lib/efi_loader/efi_image_loader.c b/lib/efi_loader/efi_image_loader.c
index 849d7ce377..9d2214b481 100644
--- a/lib/efi_loader/efi_image_loader.c
+++ b/lib/efi_loader/efi_image_loader.c
@@ -73,6 +73,40 @@ void __weak invalidate_icache_all(void)
 	/* If the system doesn't support icache_all flush, cross our fingers */
 }
 
+/*
+ * Determine the memory types to be used for code and data.
+ *
+ * @loaded_image_info	image descriptor
+ * @image_type		field Subsystem of the optional header for
+ *			Windows specific field
+ */
+static void efi_set_code_and_data_type(
+			struct efi_loaded_image *loaded_image_info,
+			uint16_t image_type)
+{
+	switch (image_type) {
+	case IMAGE_SUBSYSTEM_EFI_APPLICATION:
+		loaded_image_info->image_code_type = EFI_LOADER_CODE;
+		loaded_image_info->image_data_type = EFI_LOADER_DATA;
+		break;
+	case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
+		loaded_image_info->image_code_type = EFI_BOOT_SERVICES_CODE;
+		loaded_image_info->image_data_type = EFI_BOOT_SERVICES_DATA;
+		break;
+	case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
+	case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER:
+		loaded_image_info->image_code_type = EFI_RUNTIME_SERVICES_CODE;
+		loaded_image_info->image_data_type = EFI_RUNTIME_SERVICES_DATA;
+		break;
+	default:
+		printf("%s: invalid image type: %u\n", __func__, image_type);
+		/* Let's assume it is an application */
+		loaded_image_info->image_code_type = EFI_LOADER_CODE;
+		loaded_image_info->image_data_type = EFI_LOADER_DATA;
+		break;
+	}
+}
+
 /*
  * This function loads all sections from a PE binary into a newly reserved
  * piece of memory. On successful load it then returns the entry point for
@@ -94,7 +128,6 @@ void *efi_load_pe(void *efi, struct efi_loaded_image *loaded_image_info)
 	unsigned long virt_size = 0;
 	bool can_run_nt64 = true;
 	bool can_run_nt32 = true;
-	uint16_t image_type;
 
 #if defined(CONFIG_ARM64)
 	can_run_nt32 = false;
@@ -131,7 +164,9 @@ void *efi_load_pe(void *efi, struct efi_loaded_image *loaded_image_info)
 		IMAGE_NT_HEADERS64 *nt64 = (void *)nt;
 		IMAGE_OPTIONAL_HEADER64 *opt = &nt64->OptionalHeader;
 		image_size = opt->SizeOfImage;
-		efi_reloc = efi_alloc(virt_size, EFI_LOADER_DATA);
+		efi_set_code_and_data_type(loaded_image_info, opt->Subsystem);
+		efi_reloc = efi_alloc(virt_size,
+				      loaded_image_info->image_code_type);
 		if (!efi_reloc) {
 			printf("%s: Could not allocate %lu bytes\n",
 			       __func__, virt_size);
@@ -140,12 +175,13 @@ void *efi_load_pe(void *efi, struct efi_loaded_image *loaded_image_info)
 		entry = efi_reloc + opt->AddressOfEntryPoint;
 		rel_size = opt->DataDirectory[rel_idx].Size;
 		rel = efi_reloc + opt->DataDirectory[rel_idx].VirtualAddress;
-		image_type = opt->Subsystem;
 	} else if (can_run_nt32 &&
 		   (nt->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC)) {
 		IMAGE_OPTIONAL_HEADER32 *opt = &nt->OptionalHeader;
 		image_size = opt->SizeOfImage;
-		efi_reloc = efi_alloc(virt_size, EFI_LOADER_DATA);
+		efi_set_code_and_data_type(loaded_image_info, opt->Subsystem);
+		efi_reloc = efi_alloc(virt_size,
+				      loaded_image_info->image_code_type);
 		if (!efi_reloc) {
 			printf("%s: Could not allocate %lu bytes\n",
 			       __func__, virt_size);
@@ -154,32 +190,12 @@ void *efi_load_pe(void *efi, struct efi_loaded_image *loaded_image_info)
 		entry = efi_reloc + opt->AddressOfEntryPoint;
 		rel_size = opt->DataDirectory[rel_idx].Size;
 		rel = efi_reloc + opt->DataDirectory[rel_idx].VirtualAddress;
-		image_type = opt->Subsystem;
 	} else {
 		printf("%s: Invalid optional header magic %x\n", __func__,
 		       nt->OptionalHeader.Magic);
 		return NULL;
 	}
 
-	switch (image_type) {
-	case IMAGE_SUBSYSTEM_EFI_APPLICATION:
-		loaded_image_info->image_code_type = EFI_LOADER_CODE;
-		loaded_image_info->image_data_type = EFI_LOADER_DATA;
-		break;
-	case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
-		loaded_image_info->image_code_type = EFI_BOOT_SERVICES_CODE;
-		loaded_image_info->image_data_type = EFI_BOOT_SERVICES_DATA;
-		break;
-	case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
-	case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER:
-		loaded_image_info->image_code_type = EFI_RUNTIME_SERVICES_CODE;
-		loaded_image_info->image_data_type = EFI_RUNTIME_SERVICES_DATA;
-		break;
-	default:
-		printf("%s: invalid image type: %u\n", __func__, image_type);
-		break;
-	}
-
 	/* Load sections into RAM */
 	for (i = num_sections - 1; i >= 0; i--) {
 		IMAGE_SECTION_HEADER *sec = &sections[i];
-- 
2.14.2

[U-Boot] [PATCH v2 06/18] efi_loader: check tables in helloworld.efi

[Heinrich Schuchardt]

Check if the device tree and the SMBIOS table are available.

Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
---
v2
	no change
---
 lib/efi_loader/helloworld.c | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/lib/efi_loader/helloworld.c b/lib/efi_loader/helloworld.c
index b8c147d7f2..1ec0179226 100644
--- a/lib/efi_loader/helloworld.c
+++ b/lib/efi_loader/helloworld.c
@@ -14,6 +14,22 @@
 #include <efi_api.h>
 
 static const efi_guid_t loaded_image_guid = LOADED_IMAGE_GUID;
+static const efi_guid_t fdt_guid = EFI_FDT_GUID;
+static const efi_guid_t smbios_guid = SMBIOS_TABLE_GUID;
+
+static int hw_memcmp(const void *buf1, const void *buf2, size_t length)
+{
+	const u8 *pos1 = buf1;
+	const u8 *pos2 = buf2;
+
+	for (; length; --length) {
+		if (*pos1 != *pos2)
+			return *pos1 - *pos2;
+		++pos1;
+		++pos2;
+	}
+	return 0;
+}
 
 /*
  * Entry point of the EFI application.
@@ -29,6 +45,7 @@ efi_status_t EFIAPI efi_main(efi_handle_t handle,
 	struct efi_boot_services *boottime = systable->boottime;
 	struct efi_loaded_image *loaded_image;
 	efi_status_t ret;
+	efi_uintn_t i;
 
 	con_out->output_string(con_out, L"Hello, world!\n");
 
@@ -40,6 +57,15 @@ efi_status_t EFIAPI efi_main(efi_handle_t handle,
 				       L"Cannot open loaded image protocol\n");
 		goto out;
 	}
+	/* Find configuration tables */
+	for (i = 0; i < systable->nr_tables; ++i) {
+		if (!hw_memcmp(&systable->tables[i].guid, &fdt_guid,
+			       sizeof(efi_guid_t)))
+			con_out->output_string(con_out, L"Have device tree\n");
+		if (!hw_memcmp(&systable->tables[i].guid, &smbios_guid,
+			       sizeof(efi_guid_t)))
+			con_out->output_string(con_out, L"Have SMBIOS table\n");
+	}
 	/* Output the load options */
 	con_out->output_string(con_out, L"Load options: ");
 	if (loaded_image->load_options_size && loaded_image->load_options)
-- 
2.14.2

[U-Boot] [PATCH v2 07/18] efi_loader: fix StartImage bootservice

[Heinrich Schuchardt]

The calling convention for the entry point of an EFI image
is always 'asmlinkage'.

Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
---
v2
	no change
---
 lib/efi_loader/efi_boottime.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/lib/efi_loader/efi_boottime.c b/lib/efi_loader/efi_boottime.c
index e046a7be9d..5a3349ecb2 100644
--- a/lib/efi_loader/efi_boottime.c
+++ b/lib/efi_loader/efi_boottime.c
@@ -1533,7 +1533,8 @@ static efi_status_t EFIAPI efi_start_image(efi_handle_t image_handle,
 					   unsigned long *exit_data_size,
 					   s16 **exit_data)
 {
-	ulong (*entry)(efi_handle_t image_handle, struct efi_system_table *st);
+	asmlinkage ulong (*entry)(efi_handle_t image_handle,
+				  struct efi_system_table *st);
 	struct efi_loaded_image *info = image_handle;
 
 	EFI_ENTRY("%p, %p, %p", image_handle, exit_data_size, exit_data);
-- 
2.14.2

[U-Boot] [PATCH v2 08/18] efi_loader: efi_disk_register: correctly determine if_type_name

[Heinrich Schuchardt]

The interface type name can be used to look up the interface type.
Don't confound it with the driver name which may be different.

Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
---
v2
	no change
---
 lib/efi_loader/efi_disk.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/efi_loader/efi_disk.c b/lib/efi_loader/efi_disk.c
index 8771e880f6..da92729779 100644
--- a/lib/efi_loader/efi_disk.c
+++ b/lib/efi_loader/efi_disk.c
@@ -330,7 +330,7 @@ int efi_disk_register(void)
 	     dev;
 	     uclass_next_device_check(&dev)) {
 		struct blk_desc *desc = dev_get_uclass_platdata(dev);
-		const char *if_typename = dev->driver->name;
+		const char *if_typename = blk_get_if_type_name(desc->if_type);
 
 		printf("Scanning disk %s...\n", dev->name);
 
-- 
2.14.2

[U-Boot] [PATCH v2 09/18] efi_loader: make efi_block_io_guid a global symbol

[Heinrich Schuchardt]

The GUID of the EFI_BLOCK_IO_PROTOCOL is needed in different code
parts. To avoid duplication make efi_block_io_guid a global symbol.

Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
---
v2
	no change
---
 include/efi_loader.h      | 2 ++
 lib/efi_loader/efi_disk.c | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/include/efi_loader.h b/include/efi_loader.h
index 6b623d8327..6d04feb0a7 100644
--- a/include/efi_loader.h
+++ b/include/efi_loader.h
@@ -86,6 +86,8 @@ extern const struct efi_device_path_to_text_protocol efi_device_path_to_text;
 
 uint16_t *efi_dp_str(struct efi_device_path *dp);
 
+/* GUID of the EFI_BLOCK_IO_PROTOCOL */
+extern const efi_guid_t efi_block_io_guid;
 extern const efi_guid_t efi_global_variable_guid;
 extern const efi_guid_t efi_guid_console_control;
 extern const efi_guid_t efi_guid_device_path;
diff --git a/lib/efi_loader/efi_disk.c b/lib/efi_loader/efi_disk.c
index da92729779..cccfc6dac5 100644
--- a/lib/efi_loader/efi_disk.c
+++ b/lib/efi_loader/efi_disk.c
@@ -14,7 +14,7 @@
 #include <part.h>
 #include <malloc.h>
 
-static const efi_guid_t efi_block_io_guid = BLOCK_IO_GUID;
+const efi_guid_t efi_block_io_guid = BLOCK_IO_GUID;
 
 struct efi_disk_obj {
 	/* Generic EFI object parent class data */
-- 
2.14.2

[U-Boot] [PATCH v2 10/18] efi_loader: provide a function to create a partition node

[Heinrich Schuchardt]

Provide new function efi_dp_part_node() to create a device
node for a partition.

Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
---
v2
	no change
---
 include/efi_loader.h             |   2 +
 lib/efi_loader/efi_device_path.c | 106 ++++++++++++++++++++++++++-------------
 2 files changed, 72 insertions(+), 36 deletions(-)

diff --git a/include/efi_loader.h b/include/efi_loader.h
index 6d04feb0a7..456763e83a 100644
--- a/include/efi_loader.h
+++ b/include/efi_loader.h
@@ -300,6 +300,8 @@ struct efi_device_path *efi_dp_append_node(const struct efi_device_path *dp,
 
 struct efi_device_path *efi_dp_from_dev(struct udevice *dev);
 struct efi_device_path *efi_dp_from_part(struct blk_desc *desc, int part);
+/* Create a device node for a block device partition. */
+struct efi_device_path *efi_dp_part_node(struct blk_desc *desc, int part);
 struct efi_device_path *efi_dp_from_file(struct blk_desc *desc, int part,
 					 const char *path);
 struct efi_device_path *efi_dp_from_eth(void);
diff --git a/lib/efi_loader/efi_device_path.c b/lib/efi_loader/efi_device_path.c
index c1ba54e6bd..f00a0ce645 100644
--- a/lib/efi_loader/efi_device_path.c
+++ b/lib/efi_loader/efi_device_path.c
@@ -484,50 +484,16 @@ static unsigned dp_part_size(struct blk_desc *desc, int part)
 }
 
 /*
- * Create a device path for a block device or one of its partitions.
+ * Create a device node for a block device partition.
  *
  * @buf		buffer to which the device path is wirtten
  * @desc	block device descriptor
  * @part	partition number, 0 identifies a block device
  */
-static void *dp_part_fill(void *buf, struct blk_desc *desc, int part)
+static void *dp_part_node(void *buf, struct blk_desc *desc, int part)
 {
 	disk_partition_t info;
 
-#ifdef CONFIG_BLK
-	{
-		struct udevice *dev;
-		int ret = blk_find_device(desc->if_type, desc->devnum, &dev);
-
-		if (ret)
-			dev = desc->bdev->parent;
-		buf = dp_fill(buf, dev);
-	}
-#else
-	/*
-	 * We *could* make a more accurate path, by looking at if_type
-	 * and handling all the different cases like we do for non-
-	 * legacy (ie CONFIG_BLK=y) case.  But most important thing
-	 * is just to have a unique device-path for if_type+devnum.
-	 * So map things to a fictitious USB device.
-	 */
-	struct efi_device_path_usb *udp;
-
-	memcpy(buf, &ROOT, sizeof(ROOT));
-	buf += sizeof(ROOT);
-
-	udp = buf;
-	udp->dp.type = DEVICE_PATH_TYPE_MESSAGING_DEVICE;
-	udp->dp.sub_type = DEVICE_PATH_SUB_TYPE_MSG_USB;
-	udp->dp.length = sizeof(*udp);
-	udp->parent_port_number = desc->if_type;
-	udp->usb_interface = desc->devnum;
-	buf = &udp[1];
-#endif
-
-	if (part == 0) /* the actual disk, not a partition */
-		return buf;
-
 	part_get_info(desc, part, &info);
 
 	if (desc->part_type == PART_TYPE_ISO) {
@@ -582,6 +548,51 @@ static void *dp_part_fill(void *buf, struct blk_desc *desc, int part)
 	return buf;
 }
 
+/*
+ * Create a device path for a block device or one of its partitions.
+ *
+ * @buf		buffer to which the device path is wirtten
+ * @desc	block device descriptor
+ * @part	partition number, 0 identifies a block device
+ */
+static void *dp_part_fill(void *buf, struct blk_desc *desc, int part)
+{
+#ifdef CONFIG_BLK
+	{
+		struct udevice *dev;
+		int ret = blk_find_device(desc->if_type, desc->devnum, &dev);
+
+		if (ret)
+			dev = desc->bdev->parent;
+		buf = dp_fill(buf, dev);
+	}
+#else
+	/*
+	 * We *could* make a more accurate path, by looking at if_type
+	 * and handling all the different cases like we do for non-
+	 * legacy (ie CONFIG_BLK=y) case.  But most important thing
+	 * is just to have a unique device-path for if_type+devnum.
+	 * So map things to a fictitious USB device.
+	 */
+	struct efi_device_path_usb *udp;
+
+	memcpy(buf, &ROOT, sizeof(ROOT));
+	buf += sizeof(ROOT);
+
+	udp = buf;
+	udp->dp.type = DEVICE_PATH_TYPE_MESSAGING_DEVICE;
+	udp->dp.sub_type = DEVICE_PATH_SUB_TYPE_MSG_USB;
+	udp->dp.length = sizeof(*udp);
+	udp->parent_port_number = desc->if_type;
+	udp->usb_interface = desc->devnum;
+	buf = &udp[1];
+#endif
+
+	if (part == 0) /* the actual disk, not a partition */
+		return buf;
+
+	return dp_part_node(buf, desc, part);
+}
 
 /* Construct a device-path from a partition on a blk device: */
 struct efi_device_path *efi_dp_from_part(struct blk_desc *desc, int part)
@@ -599,6 +610,29 @@ struct efi_device_path *efi_dp_from_part(struct blk_desc *desc, int part)
 	return start;
 }
 
+/*
+ * Create a device node for a block device partition.
+ *
+ * @buf		buffer to which the device path is wirtten
+ * @desc	block device descriptor
+ * @part	partition number, 0 identifies a block device
+ */
+struct efi_device_path *efi_dp_part_node(struct blk_desc *desc, int part)
+{
+	efi_uintn_t dpsize;
+	void *buf;
+
+	if (desc->part_type == PART_TYPE_ISO)
+		dpsize = sizeof(struct efi_device_path_cdrom_path);
+	else
+		dpsize = sizeof(struct efi_device_path_hard_drive_path);
+	buf = dp_alloc(dpsize);
+
+	dp_part_node(buf, desc, part);
+
+	return buf;
+}
+
 /* convert path to an UEFI style path (ie. DOS style backslashes and utf16) */
 static void path_to_uefi(u16 *uefi, const char *path)
 {
-- 
2.14.2

[U-Boot] [PATCH v2 11/18] efi_loader: make efi_disk_create_partitions a global symbol

[Heinrich Schuchardt]

Up to now we have been using efi_disk_create_partitions() to create
partions for block device that existed before starting an EFI
application.

We need to to call it for for block devices created by EFI
applications at run time. The EFI application will define the
handle for the block device and install a device path protocol
on it. We have to use this device path as stem for the partition
device paths.

Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
---
v2
	no change
---
 include/efi_loader.h      |  4 +++
 lib/efi_loader/efi_disk.c | 84 +++++++++++++++++++++++++++++++++--------------
 2 files changed, 64 insertions(+), 24 deletions(-)

diff --git a/include/efi_loader.h b/include/efi_loader.h
index 456763e83a..0ba7badb15 100644
--- a/include/efi_loader.h
+++ b/include/efi_loader.h
@@ -174,6 +174,10 @@ extern struct list_head efi_obj_list;
 int efi_console_register(void);
 /* Called by bootefi to make all disk storage accessible as EFI objects */
 int efi_disk_register(void);
+/* Create handles and protocols for the partions of a block device */
+int efi_disk_create_partitions(efi_handle_t parent, struct blk_desc *desc,
+			       const char *if_typename, int diskid,
+			       const char *pdevname);
 /* Called by bootefi to make GOP (graphical) interface available */
 int efi_gop_register(void);
 /* Called by bootefi to make the network interface available */
diff --git a/lib/efi_loader/efi_disk.c b/lib/efi_loader/efi_disk.c
index cccfc6dac5..92c3f45ca5 100644
--- a/lib/efi_loader/efi_disk.c
+++ b/lib/efi_loader/efi_disk.c
@@ -216,27 +216,31 @@ efi_fs_from_path(struct efi_device_path *full_path)
 }
 
 /*
- * Create a device for a disk
+ * Create a handle for a partition or disk
  *
- * @name	not used
+ * @parent	parent handle
+ * @dp_parent	parent device path
  * @if_typename interface name for block device
  * @desc	internal block device
  * @dev_index   device index for block device
  * @offset	offset into disk for simple partitions
+ * @return	disk object
  */
-static void efi_disk_add_dev(const char *name,
-			     const char *if_typename,
-			     struct blk_desc *desc,
-			     int dev_index,
-			     lbaint_t offset,
-			     unsigned int part)
+static struct efi_disk_obj *efi_disk_add_dev(
+				efi_handle_t parent,
+				struct efi_device_path *dp_parent,
+				const char *if_typename,
+				struct blk_desc *desc,
+				int dev_index,
+				lbaint_t offset,
+				unsigned int part)
 {
 	struct efi_disk_obj *diskobj;
 	efi_status_t ret;
 
 	/* Don't add empty devices */
 	if (!desc->lba)
-		return;
+		return NULL;
 
 	diskobj = calloc(1, sizeof(*diskobj));
 	if (!diskobj)
@@ -246,7 +250,14 @@ static void efi_disk_add_dev(const char *name,
 	efi_add_handle(&diskobj->parent);
 
 	/* Fill in object data */
-	diskobj->dp = efi_dp_from_part(desc, part);
+	if (part) {
+		struct efi_device_path *node = efi_dp_part_node(desc, part);
+
+		diskobj->dp = efi_dp_append_node(dp_parent, node);
+		efi_free_pool(node);
+	} else {
+		diskobj->dp = efi_dp_from_part(desc, part);
+	}
 	diskobj->part = part;
 	ret = efi_add_protocol(diskobj->parent.handle, &efi_block_io_guid,
 			       &diskobj->ops);
@@ -280,20 +291,38 @@ static void efi_disk_add_dev(const char *name,
 	if (part != 0)
 		diskobj->media.logical_partition = 1;
 	diskobj->ops.media = &diskobj->media;
-	return;
+	return diskobj;
 out_of_memory:
 	printf("ERROR: Out of memory\n");
+	return NULL;
 }
 
-static int efi_disk_create_partitions(struct blk_desc *desc,
-				      const char *if_typename,
-				      int diskid,
-				      const char *pdevname)
+/*
+ * Create handles and protocols for the partions of a block device
+ *
+ * @parent		handle of the parent disk
+ * @blk_desc		block device
+ * @if_typename		interface type
+ * @diskid		device number
+ * @pdevname		device name
+ * @return		number of partions created
+ */
+int efi_disk_create_partitions(efi_handle_t parent, struct blk_desc *desc,
+			       const char *if_typename, int diskid,
+			       const char *pdevname)
 {
 	int disks = 0;
 	char devname[32] = { 0 }; /* dp->str is u16[32] long */
 	disk_partition_t info;
 	int part;
+	struct efi_device_path *dp = NULL;
+	efi_status_t ret;
+	struct efi_handler *handler;
+
+	/* Get the device path of the parent */
+	ret = efi_search_protocol(parent, &efi_guid_device_path, &handler);
+	if (ret == EFI_SUCCESS)
+		dp = handler->protocol_interface;
 
 	/* Add devices for each partition */
 	for (part = 1; part <= MAX_SEARCH_PARTITIONS; part++) {
@@ -301,7 +330,7 @@ static int efi_disk_create_partitions(struct blk_desc *desc,
 			continue;
 		snprintf(devname, sizeof(devname), "%s:%d", pdevname,
 			 part);
-		efi_disk_add_dev(devname, if_typename, desc, diskid,
+		efi_disk_add_dev(parent, dp, if_typename, desc, diskid,
 				 info.start, part);
 		disks++;
 	}
@@ -322,6 +351,7 @@ static int efi_disk_create_partitions(struct blk_desc *desc,
  */
 int efi_disk_register(void)
 {
+	struct efi_disk_obj *disk;
 	int disks = 0;
 #ifdef CONFIG_BLK
 	struct udevice *dev;
@@ -335,14 +365,16 @@ int efi_disk_register(void)
 		printf("Scanning disk %s...\n", dev->name);
 
 		/* Add block device for the full device */
-		efi_disk_add_dev(dev->name, if_typename, desc,
-				 desc->devnum, 0, 0);
-
+		disk = efi_disk_add_dev(NULL, NULL, if_typename,
+					desc, desc->devnum, 0, 0);
+		if (!disk)
+			return -ENOMEM;
 		disks++;
 
 		/* Partitions show up as block devices in EFI */
-		disks += efi_disk_create_partitions(desc, if_typename,
-						    desc->devnum, dev->name);
+		disks += efi_disk_create_partitions(
+					disk->parent.handle, desc, if_typename,
+					desc->devnum, dev->name);
 	}
 #else
 	int i, if_type;
@@ -372,12 +404,16 @@ int efi_disk_register(void)
 				 if_typename, i);
 
 			/* Add block device for the full device */
-			efi_disk_add_dev(devname, if_typename, desc, i, 0, 0);
+			disk = efi_disk_add_dev(NULL, NULL, if_typename, desc,
+						i, 0, 0);
+			if (!disk)
+				return -ENOMEM;
 			disks++;
 
 			/* Partitions show up as block devices in EFI */
-			disks += efi_disk_create_partitions(desc, if_typename,
-							    i, devname);
+			disks += efi_disk_create_partitions(
+						disk->parent.handle, desc,
+						if_typename, i, devname);
 		}
 	}
 #endif
-- 
2.14.2

[U-Boot] [PATCH v2 12/18] efi_loader: correct EFI_BLOCK_IO_PROTOCOL definitions

[Heinrich Schuchardt]

Add the revision constants.
Depending on the revision additional fields are needed in the
media descriptor.
Use efi_uintn_t for number of bytes to read or write.

Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
---
v2
	no change
---
 include/efi_api.h         | 10 ++++++++--
 lib/efi_loader/efi_disk.c |  8 ++++----
 2 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/include/efi_api.h b/include/efi_api.h
index 502fffed20..0bc244444d 100644
--- a/include/efi_api.h
+++ b/include/efi_api.h
@@ -424,18 +424,24 @@ struct efi_block_io_media
 	u32 io_align;
 	u8 pad2[4];
 	u64 last_block;
+	u64 lowest_aligned_lba;
+	u32 logical_blocks_per_physical_block;
+	u32 optimal_transfer_length_granualarity;
 };
 
+#define EFI_BLOCK_IO_PROTOCOL_REVISION2	0x00020001
+#define EFI_BLOCK_IO_PROTOCOL_REVISION3	0x0002001f
+
 struct efi_block_io {
 	u64 revision;
 	struct efi_block_io_media *media;
 	efi_status_t (EFIAPI *reset)(struct efi_block_io *this,
 			char extended_verification);
 	efi_status_t (EFIAPI *read_blocks)(struct efi_block_io *this,
-			u32 media_id, u64 lba, unsigned long buffer_size,
+			u32 media_id, u64 lba, efi_uintn_t buffer_size,
 			void *buffer);
 	efi_status_t (EFIAPI *write_blocks)(struct efi_block_io *this,
-			u32 media_id, u64 lba, unsigned long buffer_size,
+			u32 media_id, u64 lba, efi_uintn_t buffer_size,
 			void *buffer);
 	efi_status_t (EFIAPI *flush_blocks)(struct efi_block_io *this);
 };
diff --git a/lib/efi_loader/efi_disk.c b/lib/efi_loader/efi_disk.c
index 92c3f45ca5..8f84e7788e 100644
--- a/lib/efi_loader/efi_disk.c
+++ b/lib/efi_loader/efi_disk.c
@@ -91,7 +91,7 @@ static efi_status_t efi_disk_rw_blocks(struct efi_block_io *this,
 }
 
 static efi_status_t EFIAPI efi_disk_read_blocks(struct efi_block_io *this,
-			u32 media_id, u64 lba, unsigned long buffer_size,
+			u32 media_id, u64 lba, efi_uintn_t buffer_size,
 			void *buffer)
 {
 	void *real_buffer = buffer;
@@ -112,7 +112,7 @@ static efi_status_t EFIAPI efi_disk_read_blocks(struct efi_block_io *this,
 	real_buffer = efi_bounce_buffer;
 #endif
 
-	EFI_ENTRY("%p, %x, %"PRIx64", %lx, %p", this, media_id, lba,
+	EFI_ENTRY("%p, %x, %" PRIx64 ", %zx, %p", this, media_id, lba,
 		  buffer_size, buffer);
 
 	r = efi_disk_rw_blocks(this, media_id, lba, buffer_size, real_buffer,
@@ -126,7 +126,7 @@ static efi_status_t EFIAPI efi_disk_read_blocks(struct efi_block_io *this,
 }
 
 static efi_status_t EFIAPI efi_disk_write_blocks(struct efi_block_io *this,
-			u32 media_id, u64 lba, unsigned long buffer_size,
+			u32 media_id, u64 lba, efi_uintn_t buffer_size,
 			void *buffer)
 {
 	void *real_buffer = buffer;
@@ -147,7 +147,7 @@ static efi_status_t EFIAPI efi_disk_write_blocks(struct efi_block_io *this,
 	real_buffer = efi_bounce_buffer;
 #endif
 
-	EFI_ENTRY("%p, %x, %"PRIx64", %lx, %p", this, media_id, lba,
+	EFI_ENTRY("%p, %x, %" PRIx64 ", %zx, %p", this, media_id, lba,
 		  buffer_size, buffer);
 
 	/* Populate bounce buffer if necessary */
-- 
2.14.2

[U-Boot] [PATCH v2 13/18] efi_loader: provide function to get last node of a device path

[Heinrich Schuchardt]

On a block device and its partions the same protocols can be
installed. To tell the apart we can use the type of the last
node of the device path which is not the end node.

The patch provides a utility function to find this last node.

Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
---
v2
	no change
---
 include/efi_loader.h             |  3 +++
 lib/efi_loader/efi_device_path.c | 20 ++++++++++++++++++++
 2 files changed, 23 insertions(+)

diff --git a/include/efi_loader.h b/include/efi_loader.h
index 0ba7badb15..4060348695 100644
--- a/include/efi_loader.h
+++ b/include/efi_loader.h
@@ -312,6 +312,9 @@ struct efi_device_path *efi_dp_from_eth(void);
 struct efi_device_path *efi_dp_from_mem(uint32_t mem_type,
 					uint64_t start_address,
 					uint64_t end_address);
+/* Determine the last device path node that is not the end node. */
+const struct efi_device_path *efi_dp_last_node(
+			const struct efi_device_path *dp);
 efi_status_t efi_dp_split_file_path(struct efi_device_path *full_path,
 				    struct efi_device_path **device_path,
 				    struct efi_device_path **file_path);
diff --git a/lib/efi_loader/efi_device_path.c b/lib/efi_loader/efi_device_path.c
index f00a0ce645..c941ea7717 100644
--- a/lib/efi_loader/efi_device_path.c
+++ b/lib/efi_loader/efi_device_path.c
@@ -208,6 +208,26 @@ struct efi_object *efi_dp_find_obj(struct efi_device_path *dp,
 	return efiobj;
 }
 
+/*
+ * Determine the last device path node that is not the end node.
+ *
+ * @dp		device path
+ * @return	last node before the end node if it exists
+ *		otherwise NULL
+ */
+const struct efi_device_path *efi_dp_last_node(const struct efi_device_path *dp)
+{
+	struct efi_device_path *ret;
+
+	if (!dp || dp->type == DEVICE_PATH_TYPE_END)
+		return NULL;
+	while (dp) {
+		ret = (struct efi_device_path *)dp;
+		dp = efi_dp_next(dp);
+	}
+	return ret;
+}
+
 /* return size not including End node: */
 unsigned efi_dp_size(const struct efi_device_path *dp)
 {
-- 
2.14.2

[U-Boot] [PATCH v2 14/18] efi_loader: provide links between devices EFI handles

[Heinrich Schuchardt]

U-Boot devices and EFI handles can be related, e.g. an
IDE disk relates to a handle with the EFI_BLOCK_IO_PROTOCOL.
Provide pointers to store these links.

Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
---
v2
	no change
---
 include/dm/device.h           | 4 ++++
 include/efi_loader.h          | 2 ++
 lib/efi_loader/efi_boottime.c | 1 +
 3 files changed, 7 insertions(+)

diff --git a/include/dm/device.h b/include/dm/device.h
index 813e49f330..e5c54fe7b6 100644
--- a/include/dm/device.h
+++ b/include/dm/device.h
@@ -11,6 +11,7 @@
 #ifndef _DM_DEVICE_H
 #define _DM_DEVICE_H
 
+#include <efi_loader.h>
 #include <dm/ofnode.h>
 #include <dm/uclass-id.h>
 #include <fdtdec.h>
@@ -144,6 +145,9 @@ struct udevice {
 	uint32_t flags;
 	int req_seq;
 	int seq;
+#ifdef EFI_LOADER
+	efi_handle_t handle;
+#endif
 #ifdef CONFIG_DEVRES
 	struct list_head devres_head;
 #endif
diff --git a/include/efi_loader.h b/include/efi_loader.h
index 4060348695..711c901eda 100644
--- a/include/efi_loader.h
+++ b/include/efi_loader.h
@@ -139,6 +139,8 @@ struct efi_object {
 	struct list_head protocols;
 	/* The object spawner can either use this for data or as identifier */
 	void *handle;
+	/* Device */
+	struct udevice *dev;
 };
 
 /**
diff --git a/lib/efi_loader/efi_boottime.c b/lib/efi_loader/efi_boottime.c
index 5a3349ecb2..4b3b63e39a 100644
--- a/lib/efi_loader/efi_boottime.c
+++ b/lib/efi_loader/efi_boottime.c
@@ -362,6 +362,7 @@ efi_status_t efi_create_handle(efi_handle_t *handle)
 			      (void **)&obj);
 	if (r != EFI_SUCCESS)
 		return r;
+	obj->dev = NULL;
 	efi_add_handle(obj);
 	*handle = obj->handle;
 	return r;
-- 
2.14.2

[U-Boot] [PATCH v2 15/18] tools: provide a tool to convert a binary file to an include

[Heinrich Schuchardt]

For testing EFI disk management we need an in-memory image of
a disk.

The tool file2include converts a file to a C include. The file
is separated into strings of 8 bytes. Only the non-zero strings
are written to the include. The output format has been designed
to maintain readability.

 #define EFI_ST_DISK_IMG { 0x00010000, { \
  {0x000001b8, "\x94\x37\x69\xfc\x00\x00\x00\x00"}, /* .7i..... */ \
  {0x000001c0, "\x02\x00\x83\x02\x02\x00\x01\x00"}, /* ........ */ \
  {0x000001c8, "\x00\x00\x7f\x00\x00\x00\x00\x00"}, /* ........ */ \
  {0x000001f8, "\x00\x00\x00\x00\x00\x00\x55\xaa"}, /* ......U. */ \
 ...
  {0x00006000, "\x48\x65\x6c\x6c\x6f\x20\x77\x6f"}, /* Hello wo */ \
  {0x00006008, "\x72\x6c\x64\x21\x0a\x00\x00\x00"}, /* rld!.... */ \
  {0, NULL} } }

As the disk image needed for testing contains mostly zeroes a high
compression ratio can be attained.

Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
---
v2
	Add .gitignore entry for tools/file2include
---
 MAINTAINERS          |   1 +
 tools/.gitignore     |   1 +
 tools/Makefile       |   3 ++
 tools/file2include.c | 106 +++++++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 111 insertions(+)
 create mode 100644 tools/file2include.c

diff --git a/MAINTAINERS b/MAINTAINERS
index e399008e23..d459153503 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -290,6 +290,7 @@ F:	include/efi*
 F:	lib/efi*/
 F:	test/py/tests/test_efi*
 F:	cmd/bootefi.c
+F:	tools/file2include.c
 
 FLATTENED DEVICE TREE
 M:	Simon Glass <sjg@chromium.org>
diff --git a/tools/.gitignore b/tools/.gitignore
index 6a487d2202..c8cdaef90c 100644
--- a/tools/.gitignore
+++ b/tools/.gitignore
@@ -6,6 +6,7 @@
 /easylogo/easylogo
 /envcrc
 /fdtgrep
+/file2include
 /fit_check_sign
 /fit_info
 /gdb/gdbcont
diff --git a/tools/Makefile b/tools/Makefile
index 571f571ec9..b7d7d418ee 100644
--- a/tools/Makefile
+++ b/tools/Makefile
@@ -57,6 +57,8 @@ mkenvimage-objs := mkenvimage.o os_support.o lib/crc32.o
 hostprogs-y += dumpimage mkimage
 hostprogs-$(CONFIG_FIT_SIGNATURE) += fit_info fit_check_sign
 
+hostprogs-$(CONFIG_CMD_BOOTEFI_SELFTEST) += file2include
+
 FIT_SIG_OBJS-$(CONFIG_FIT_SIGNATURE) := common/image-sig.o
 
 # The following files are synced with upstream DTC.
@@ -118,6 +120,7 @@ dumpimage-objs := $(dumpimage-mkimage-objs) dumpimage.o
 mkimage-objs   := $(dumpimage-mkimage-objs) mkimage.o
 fit_info-objs   := $(dumpimage-mkimage-objs) fit_info.o
 fit_check_sign-objs   := $(dumpimage-mkimage-objs) fit_check_sign.o
+file2include-objs := file2include.o
 
 ifneq ($(CONFIG_MX23)$(CONFIG_MX28),)
 # Add CONFIG_MXS into host CFLAGS, so we can check whether or not register
diff --git a/tools/file2include.c b/tools/file2include.c
new file mode 100644
index 0000000000..9145f0845a
--- /dev/null
+++ b/tools/file2include.c
@@ -0,0 +1,106 @@
+/*
+ * Convert a file image to a C define
+ *
+ * Copyright (c) 2017 Heinrich Schuchardt <xypron.glpk@gmx.de>
+ *
+ * SPDX-License-Identifier:     GPL-2.0+
+ *
+ * For testing EFI disk management we need an in memory image of
+ * a disk.
+ *
+ * The tool file2include converts a file to a C include. The file
+ * is separated into strings of 8 bytes. Only the non-zero strings
+ * are written to the include. The output format has been designed
+ * to maintain readability.
+ *
+ * As the disk image needed for testing contains mostly zeroes a high
+ * compression ratio can be attained.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <malloc.h>
+
+/* Size of the blocks written to the compressed file */
+#define BLOCK_SIZE 8
+
+int main(int argc, char *argv[])
+{
+	FILE *file;
+	int ret;
+	unsigned char *buf;
+	size_t count, i, j;
+
+	/* Provide usage help */
+	if (argc != 2) {
+		printf("Usage:\n%s FILENAME\n", argv[0]);
+		return EXIT_FAILURE;
+	}
+	/* Open file */
+	file = fopen(argv[1], "r");
+	if (!file) {
+		perror("fopen");
+		return EXIT_FAILURE;
+	}
+	/* Get file length */
+	ret = fseek(file, 0, SEEK_END);
+	if (ret < 0) {
+		perror("fseek");
+		return EXIT_FAILURE;
+	}
+	count = ftell(file);
+	if (!count) {
+		fprintf(stderr, "File %s has length 0\n", argv[1]);
+		return EXIT_FAILURE;
+	}
+	rewind(file);
+	/* Read file */
+	buf = malloc(count);
+	if (!buf) {
+		perror("calloc");
+		return EXIT_FAILURE;
+	}
+	count = fread(buf, 1, count, file);
+
+	/* Generate output */
+	printf("/*\n");
+	printf(" *  Non-zero %u byte strings of a disk image\n", BLOCK_SIZE);
+	printf(" *\n");
+	printf(" *  Generated with tools/file2include\n");
+	printf(" *\n");
+	printf(" *  SPDX-License-Identifier:	GPL-2.0+\n");
+	printf(" */\n\n");
+	printf("#define EFI_ST_DISK_IMG { 0x%08zx, { \\\n", count);
+
+	for (i = 0; i < count; i += BLOCK_SIZE) {
+		int c = 0;
+
+		for (j = i; j < i + BLOCK_SIZE && j < count; ++j) {
+			if (buf[j])
+				c = 1;
+		}
+		if (!c)
+			continue;
+		printf("\t{0x%08zx, \"", i);
+		for (j = i; j < i + BLOCK_SIZE && j < count; ++j)
+			printf("\\x%02x", buf[j]);
+		printf("\"}, /* ");
+		for (j = i; j < i + BLOCK_SIZE && j < count; ++j) {
+			if (buf[j] >= 0x20 && buf[j] <= 0x7e)
+				printf("%c", buf[j]);
+			else
+				printf(".");
+		}
+		printf(" */ \\\n");
+	}
+	printf("\t{0, NULL} } }\n");
+
+	/* Release resources */
+	free(buf);
+	ret = fclose(file);
+	if (ret) {
+		perror("fclose");
+		return EXIT_FAILURE;
+	}
+	return EXIT_SUCCESS;
+}
-- 
2.14.2

[U-Boot] [PATCH v2 16/18] efi_driver: EFI block driver

[Heinrich Schuchardt]

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 partions 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>
---
v2
	Print to console only in debug mode.
	Provide more comments.
	Add commit message.
---
 common/board_r.c                  |   3 +
 drivers/block/blk-uclass.c        |   4 +-
 include/blk.h                     |   1 +
 include/config_fallbacks.h        |   1 +
 include/dm/uclass-id.h            |   1 +
 include/efi_driver.h              |  30 ++++
 include/efi_loader.h              |   2 +
 lib/Makefile                      |   1 +
 lib/efi_driver/Makefile           |  13 ++
 lib/efi_driver/efi_block_device.c | 175 ++++++++++++++++++++
 lib/efi_driver/efi_uclass.c       | 330 ++++++++++++++++++++++++++++++++++++++
 11 files changed, 560 insertions(+), 1 deletion(-)
 create mode 100644 include/efi_driver.h
 create mode 100644 lib/efi_driver/Makefile
 create mode 100644 lib/efi_driver/efi_block_device.c
 create mode 100644 lib/efi_driver/efi_uclass.c

diff --git a/common/board_r.c b/common/board_r.c
index 2baa47f3a0..4ad37ee31a 100644
--- a/common/board_r.c
+++ b/common/board_r.c
@@ -715,7 +715,10 @@ static init_fnc_t init_sequence_r[] = {
 	set_cpu_clk_info, /* Setup clock information */
 #endif
 #ifdef CONFIG_EFI_LOADER
+	/* Setup EFI memory before any other EFI related code */
 	efi_memory_init,
+	/* Install EFI drivers */
+	efi_driver_init,
 #endif
 	stdio_init_tables,
 	initr_serial,
diff --git a/drivers/block/blk-uclass.c b/drivers/block/blk-uclass.c
index 010ed32d3a..bfda2211f0 100644
--- a/drivers/block/blk-uclass.c
+++ b/drivers/block/blk-uclass.c
@@ -24,6 +24,7 @@ static const char *if_typename_str[IF_TYPE_COUNT] = {
 	[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 @@ static enum uclass_id if_type_uclass_id[IF_TYPE_COUNT] = {
 	[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)
diff --git a/include/blk.h b/include/blk.h
index 41b4d7efa8..69b5a98e56 100644
--- a/include/blk.h
+++ b/include/blk.h
@@ -34,6 +34,7 @@ enum if_type {
 	IF_TYPE_HOST,
 	IF_TYPE_SYSTEMACE,
 	IF_TYPE_NVME,
+	IF_TYPE_EFI,
 
 	IF_TYPE_COUNT,			/* Number of interface types */
 };
diff --git a/include/config_fallbacks.h b/include/config_fallbacks.h
index 2c4d43d672..524313d5aa 100644
--- a/include/config_fallbacks.h
+++ b/include/config_fallbacks.h
@@ -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
diff --git a/include/dm/uclass-id.h b/include/dm/uclass-id.h
index 3fc20834ae..07fabc3ce6 100644
--- a/include/dm/uclass-id.h
+++ b/include/dm/uclass-id.h
@@ -34,6 +34,7 @@ enum uclass_id {
 	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 */
diff --git a/include/efi_driver.h b/include/efi_driver.h
new file mode 100644
index 0000000000..2bbe26c6e3
--- /dev/null
+++ b/include/efi_driver.h
@@ -0,0 +1,30 @@
+/*
+ *  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 */
diff --git a/include/efi_loader.h b/include/efi_loader.h
index 711c901eda..a465175d1f 100644
--- a/include/efi_loader.h
+++ b/include/efi_loader.h
@@ -273,6 +273,8 @@ efi_status_t efi_get_memory_map(efi_uintn_t *memory_map_size,
 /* 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 */
diff --git a/lib/Makefile b/lib/Makefile
index 8cd779f8ca..0db41c19f3 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -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/
diff --git a/lib/efi_driver/Makefile b/lib/efi_driver/Makefile
new file mode 100644
index 0000000000..e35529a952
--- /dev/null
+++ b/lib/efi_driver/Makefile
@@ -0,0 +1,13 @@
+#
+# (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
diff --git a/lib/efi_driver/efi_block_device.c b/lib/efi_driver/efi_block_device.c
new file mode 100644
index 0000000000..837787d563
--- /dev/null
+++ b/lib/efi_driver/efi_block_device.c
@@ -0,0 +1,175 @@
+/*
+ *  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 partions with the simple file
+ * protocol.
+ *
+ * iPXE uses the simple file protocol to load Grub or the Linux Kernel.
+ */
+
+#include <efi_driver.h>
+#include <dm/root.h>
+
+static int efi_blk_max_devnum;
+
+/*
+ * 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_block_io *io = dev->platdata;
+	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_block_io *io = dev->platdata;
+	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;
+}
+
+static int efi_bl_bind_partions(efi_handle_t handle)
+{
+	struct efi_object *obj = efi_search_obj(handle);
+	struct blk_desc *desc;
+	const char *if_typename;
+
+	if (!obj || !obj->dev)
+		return -ENOENT;
+	desc = dev_get_uclass_platdata(obj->dev);
+	if_typename = blk_get_if_type_name(desc->if_type);
+
+	return efi_disk_create_partitions(handle, desc, if_typename,
+					  desc->devnum, obj->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[20];
+	struct efi_object *obj = efi_search_obj(handle);
+	struct efi_block_io *io = interface;
+	int disks;
+
+	EFI_PRINT("%s: handle %p, interface %p\n", __func__, handle, io);
+
+	if (!obj)
+		return -ENOENT;
+
+	devnum = efi_blk_max_devnum++;
+	sprintf(name, "efi#%d", devnum);
+
+	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;
+	EFI_PRINT("%s: block device '%s' created\n", __func__, bdev->name);
+	bdev->platdata = interface;
+	obj->dev = bdev;
+
+	ret = blk_prepare_device(bdev);
+
+	disks = efi_bl_bind_partions(handle);
+	EFI_PRINT("Found %d partions\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,
+};
+
+/* 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,
+};
diff --git a/lib/efi_driver/efi_uclass.c b/lib/efi_driver/efi_uclass.c
new file mode 100644
index 0000000000..798431ae74
--- /dev/null
+++ b/lib/efi_driver/efi_uclass.c
@@ -0,0 +1,330 @@
+/*
+ *  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 partions 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,
+};
-- 
2.14.2

[U-Boot] [PATCH v2 17/18] efi_selftest: provide a test for block io

[Heinrich Schuchardt]

Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
---
v2
	no change
---
 lib/efi_selftest/Makefile                    |   4 +
 lib/efi_selftest/efi_selftest_block_device.c | 395 +++++++++++++++++++++++++++
 lib/efi_selftest/efi_selftest_disk_image.h   |  69 +++++
 3 files changed, 468 insertions(+)
 create mode 100644 lib/efi_selftest/efi_selftest_block_device.c
 create mode 100644 lib/efi_selftest/efi_selftest_disk_image.h

diff --git a/lib/efi_selftest/Makefile b/lib/efi_selftest/Makefile
index e549553c82..20f614d6ba 100644
--- a/lib/efi_selftest/Makefile
+++ b/lib/efi_selftest/Makefile
@@ -21,3 +21,7 @@ efi_selftest_textoutput.o \
 efi_selftest_tpl.o \
 efi_selftest_util.o \
 efi_selftest_watchdog.o
+
+ifeq ($(CONFIG_BLK)$(CONFIG_PARTITIONS),yy)
+obj-$(CONFIG_CMD_BOOTEFI_SELFTEST) += efi_selftest_block_device.o
+endif
diff --git a/lib/efi_selftest/efi_selftest_block_device.c b/lib/efi_selftest/efi_selftest_block_device.c
new file mode 100644
index 0000000000..9e4b93d9a6
--- /dev/null
+++ b/lib/efi_selftest/efi_selftest_block_device.c
@@ -0,0 +1,395 @@
+/*
+ * efi_selftest_block
+ *
+ * Copyright (c) 2017 Heinrich Schuchardt <xypron.glpk@gmx.de>
+ *
+ * SPDX-License-Identifier:     GPL-2.0+
+ *
+ * This test checks the driver for block IO devices.
+ * A disk image is created in memory.
+ * A handle is created for the new block IO device.
+ * The block I/O protocol is installed on the handle.
+ * ConnectController is used to setup partitions and to install the simple
+ * file protocol.
+ * A known file is read from the file system and verified.
+ */
+
+#include <efi_selftest.h>
+#include "efi_selftest_disk_image.h"
+
+/* Block size of compressed disk image */
+#define COMPRESSED_DISK_IMAGE_BLOCK_SIZE 8
+
+/* Binary logarithm of the block size */
+#define LB_BLOCK_SIZE 9
+
+static struct efi_boot_services *boottime;
+
+static const efi_guid_t block_io_protocol_guid = BLOCK_IO_GUID;
+static const efi_guid_t guid_device_path = DEVICE_PATH_GUID;
+static const efi_guid_t guid_simple_file_system_protocol =
+					EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID;
+static efi_guid_t guid_vendor =
+	EFI_GUID(0xdbca4c98, 0x6cb0, 0x694d,
+		 0x08, 0x72, 0x81, 0x9c, 0x65, 0x0c, 0xb7, 0xb8);
+
+static struct efi_device_path *dp;
+
+/* One 8 byte block of the compressed disk image */
+struct line {
+	size_t addr;
+	char *line;
+};
+
+/* Compressed disk image */
+struct compressed_disk_image {
+	size_t length;
+	struct line lines[];
+};
+
+static const struct compressed_disk_image img = EFI_ST_DISK_IMG;
+
+/* Decompressed disk image */
+static u8 *image;
+
+/*
+ * Reset service of the block IO protocol.
+ *
+ * @this	block IO protocol
+ * @return	status code
+ */
+static efi_status_t EFIAPI reset(
+			struct efi_block_io *this,
+			char extended_verification)
+{
+	return EFI_SUCCESS;
+}
+
+/*
+ * Read service of the block IO protocol.
+ *
+ * @this	block IO protocol
+ * @media_id	media id
+ * @lba		start of the read in logical blocks
+ * @buffer_size	number of bytes to read
+ * @buffer	target buffer
+ * @return	status code
+ */
+static efi_status_t EFIAPI read_blocks(
+			struct efi_block_io *this, u32 media_id, u64 lba,
+			efi_uintn_t buffer_size, void *buffer)
+{
+	u8 *start;
+
+	if ((lba << LB_BLOCK_SIZE) + buffer_size > img.length)
+		return EFI_INVALID_PARAMETER;
+	start = image + (lba << LB_BLOCK_SIZE);
+
+	boottime->copy_mem(buffer, start, buffer_size);
+
+	return EFI_SUCCESS;
+}
+
+/*
+ * Write service of the block IO protocol.
+ *
+ * @this	block IO protocol
+ * @media_id	media id
+ * @lba		start of the write in logical blocks
+ * @buffer_size	number of bytes to read
+ * @buffer	source buffer
+ * @return	status code
+ */
+static efi_status_t EFIAPI write_blocks(
+			struct efi_block_io *this, u32 media_id, u64 lba,
+			efi_uintn_t buffer_size, void *buffer)
+{
+	u8 *start;
+
+	if ((lba << LB_BLOCK_SIZE) + buffer_size > img.length)
+		return EFI_INVALID_PARAMETER;
+	start = image + (lba << LB_BLOCK_SIZE);
+
+	boottime->copy_mem(start, buffer, buffer_size);
+
+	return EFI_SUCCESS;
+}
+
+/*
+ * Flush service of the block IO protocol.
+ *
+ * @this	block IO protocol
+ * @return	status code
+ */
+static efi_status_t EFIAPI flush_blocks(struct efi_block_io *this)
+{
+	return EFI_SUCCESS;
+}
+
+/*
+ * Decompress the disk image.
+ *
+ * @image	decompressed disk image
+ * @return	status code
+ */
+static efi_status_t decompress(u8 **image)
+{
+	u8 *buf;
+	size_t i;
+	size_t addr;
+	size_t len;
+	efi_status_t ret;
+
+	ret = boottime->allocate_pool(EFI_LOADER_DATA, img.length,
+				      (void **)&buf);
+	if (ret != EFI_SUCCESS) {
+		efi_st_error("Out of memory\n");
+		return ret;
+	}
+	boottime->set_mem(buf, img.length, 0);
+
+	for (i = 0; ; ++i) {
+		if (!img.lines[i].line)
+			break;
+		addr = img.lines[i].addr;
+		len = COMPRESSED_DISK_IMAGE_BLOCK_SIZE;
+		if (addr + len > img.length)
+			len = img.length - addr;
+		boottime->copy_mem(buf + addr, img.lines[i].line, len);
+	}
+	*image = buf;
+	return ret;
+}
+
+static struct efi_block_io_media media;
+
+static struct efi_block_io block_io = {
+	.media = &media,
+	.reset = reset,
+	.read_blocks = read_blocks,
+	.write_blocks = write_blocks,
+	.flush_blocks = flush_blocks,
+};
+
+/* Handle for the block IO device */
+static efi_handle_t disk_handle;
+
+/*
+ * Setup unit test.
+ *
+ * @handle:	handle of the loaded image
+ * @systable:	system table
+ * @return:	EFI_ST_SUCCESS for success
+ */
+static int setup(const efi_handle_t handle,
+		 const struct efi_system_table *systable)
+{
+	efi_status_t ret;
+	struct efi_device_path_vendor vendor_node;
+	struct efi_device_path end_node;
+
+	boottime = systable->boottime;
+
+	decompress(&image);
+
+	block_io.media->block_size = 1 << LB_BLOCK_SIZE;
+	block_io.media->last_block = img.length >> LB_BLOCK_SIZE;
+
+	ret = boottime->install_protocol_interface(
+				&disk_handle, &block_io_protocol_guid,
+				EFI_NATIVE_INTERFACE, &block_io);
+	if (ret != EFI_SUCCESS) {
+		efi_st_error("Failed to install block I/O protocol\n");
+		return EFI_ST_FAILURE;
+	}
+
+	ret = boottime->allocate_pool(EFI_LOADER_DATA,
+				      sizeof(struct efi_device_path_vendor) +
+				      sizeof(struct efi_device_path),
+				      (void **)&dp);
+	if (ret != EFI_SUCCESS) {
+		efi_st_error("Out of memory\n");
+		return EFI_ST_FAILURE;
+	}
+	vendor_node.dp.type = DEVICE_PATH_TYPE_HARDWARE_DEVICE;
+	vendor_node.dp.sub_type = DEVICE_PATH_SUB_TYPE_VENDOR;
+	vendor_node.dp.length = sizeof(struct efi_device_path_vendor);
+
+	boottime->copy_mem(&vendor_node.guid, &guid_vendor,
+			   sizeof(efi_guid_t));
+	boottime->copy_mem(dp, &vendor_node,
+			   sizeof(struct efi_device_path_vendor));
+	end_node.type = DEVICE_PATH_TYPE_END;
+	end_node.sub_type = DEVICE_PATH_SUB_TYPE_END;
+	end_node.length = sizeof(struct efi_device_path);
+
+	boottime->copy_mem((char *)dp + sizeof(struct efi_device_path_vendor),
+			   &end_node, sizeof(struct efi_device_path));
+	ret = boottime->install_protocol_interface(&disk_handle,
+						   &guid_device_path,
+						   EFI_NATIVE_INTERFACE,
+						   dp);
+	if (ret != EFI_SUCCESS) {
+		efi_st_error("InstallProtocolInterface failed\n");
+		return EFI_ST_FAILURE;
+	}
+	return EFI_ST_SUCCESS;
+}
+
+/*
+ * Tear down unit test.
+ *
+ * @return:	EFI_ST_SUCCESS for success
+ */
+static int teardown(void)
+{
+	efi_status_t r = EFI_ST_SUCCESS;
+
+	if (disk_handle) {
+		r = boottime->uninstall_protocol_interface(disk_handle,
+							   &guid_device_path,
+							   dp);
+		if (r != EFI_SUCCESS) {
+			efi_st_error("Uninstall device path failed\n");
+			return EFI_ST_FAILURE;
+		}
+		r = boottime->uninstall_protocol_interface(
+				disk_handle, &block_io_protocol_guid,
+				&block_io);
+		if (r != EFI_SUCCESS) {
+			efi_st_todo(
+				"Failed to uninstall block I/O protocol\n");
+			return EFI_ST_SUCCESS;
+		}
+	}
+
+	if (image) {
+		r = efi_free_pool(image);
+		if (r != EFI_SUCCESS) {
+			efi_st_error("Failed to free image\n");
+			return EFI_ST_FAILURE;
+		}
+	}
+	return r;
+}
+
+/*
+ * Get length of device path without end tag.
+ *
+ * @dp		device path
+ * @return	length of device path in bytes
+ */
+static efi_uintn_t dp_size(struct efi_device_path *dp)
+{
+	struct efi_device_path *pos = dp;
+
+	while (pos->type != DEVICE_PATH_TYPE_END)
+		pos = (struct efi_device_path *)((char *)pos + pos->length);
+	return (char *)pos - (char *)dp;
+}
+
+/*
+ * Execute unit test.
+ *
+ * @return:	EFI_ST_SUCCESS for success
+ */
+static int execute(void)
+{
+	efi_status_t ret;
+	efi_uintn_t no_handles, i, len;
+	efi_handle_t *handles;
+	efi_handle_t handle_partition = NULL;
+	struct efi_device_path *dp_partition;
+	struct efi_simple_file_system_protocol *file_system;
+	struct efi_file_handle *root, *file;
+	u64 buf_size;
+	char buf[16] __aligned(ARCH_DMA_MINALIGN);
+
+	ret = boottime->connect_controller(disk_handle, NULL, NULL, 1);
+	if (ret != EFI_SUCCESS) {
+		efi_st_error("Failed to connect controller\n");
+		return EFI_ST_FAILURE;
+	}
+	ret = boottime->locate_handle_buffer(
+				BY_PROTOCOL, &guid_device_path, NULL,
+				&no_handles, &handles);
+	if (ret != EFI_SUCCESS) {
+		efi_st_error("Failed to locate handles\n");
+		return EFI_ST_FAILURE;
+	}
+	len = dp_size(dp);
+	for (i = 0; i < no_handles; ++i) {
+		ret = boottime->open_protocol(handles[i], &guid_device_path,
+					      (void **)&dp_partition,
+					      NULL, NULL,
+					      EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+		if (ret != EFI_SUCCESS) {
+			efi_st_error("Failed to open device path protocol\n");
+			return EFI_ST_FAILURE;
+		}
+		if (len >= dp_size(dp_partition))
+			continue;
+		if (efi_st_memcmp(dp, dp_partition, len))
+			continue;
+		handle_partition = handles[i];
+		break;
+	}
+	ret = boottime->free_pool(handles);
+	if (ret != EFI_SUCCESS) {
+		efi_st_error("Failed to free pool memory\n");
+		return EFI_ST_FAILURE;
+	}
+	if (!handle_partition) {
+		efi_st_error("Partition handle not found\n");
+		return EFI_ST_FAILURE;
+	}
+	ret = boottime->open_protocol(handle_partition,
+				      &guid_simple_file_system_protocol,
+				      (void **)&file_system, NULL, NULL,
+				      EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+	if (ret != EFI_SUCCESS) {
+		efi_st_error("Failed to open simple file system protocol\n");
+		return EFI_ST_FAILURE;
+	}
+	ret = file_system->open_volume(file_system, &root);
+	if (ret != EFI_SUCCESS) {
+		efi_st_error("Failed to open volume\n");
+		return EFI_ST_FAILURE;
+	}
+	ret = root->open(root, &file, (s16 *)L"hello.txt", EFI_FILE_MODE_READ,
+			 0);
+	if (ret != EFI_SUCCESS) {
+		efi_st_error("Failed to open file\n");
+		return EFI_ST_FAILURE;
+	}
+	buf_size = sizeof(buf) - 1;
+	ret = file->read(file, &buf_size, buf);
+	if (ret != EFI_SUCCESS) {
+		efi_st_error("Failed to read file\n");
+		return EFI_ST_FAILURE;
+	}
+	if (efi_st_memcmp(buf, "Hello world!", 12)) {
+		efi_st_error("Unexpected file content\n");
+		return EFI_ST_FAILURE;
+	}
+	ret = file->close(file);
+	if (ret != EFI_SUCCESS) {
+		efi_st_error("Failed to close file\n");
+		return EFI_ST_FAILURE;
+	}
+	ret = root->close(root);
+	if (ret != EFI_SUCCESS) {
+		efi_st_error("Failed to close volume\n");
+		return EFI_ST_FAILURE;
+	}
+
+	return EFI_ST_SUCCESS;
+}
+
+EFI_UNIT_TEST(blkdev) = {
+	.name = "block device",
+	.phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
+	.setup = setup,
+	.execute = execute,
+	.teardown = teardown,
+};
diff --git a/lib/efi_selftest/efi_selftest_disk_image.h b/lib/efi_selftest/efi_selftest_disk_image.h
new file mode 100644
index 0000000000..4775dace70
--- /dev/null
+++ b/lib/efi_selftest/efi_selftest_disk_image.h
@@ -0,0 +1,69 @@
+/*
+ *  Non-zero 8 byte strings of a disk image
+ *
+ *  Generated with tools/file2include
+ *
+ *  SPDX-License-Identifier:     GPL-2.0+
+ */
+
+#define EFI_ST_DISK_IMG { 0x00010000, { \
+	{0x000001b8, "\x94\x37\x69\xfc\x00\x00\x00\x00"}, /* .7i..... */ \
+	{0x000001c0, "\x02\x00\x83\x02\x02\x00\x01\x00"}, /* ........ */ \
+	{0x000001c8, "\x00\x00\x7f\x00\x00\x00\x00\x00"}, /* ........ */ \
+	{0x000001f8, "\x00\x00\x00\x00\x00\x00\x55\xaa"}, /* ......U. */ \
+	{0x00000200, "\xeb\x3c\x90\x6d\x6b\x66\x73\x2e"}, /* .<.mkfs. */ \
+	{0x00000208, "\x66\x61\x74\x00\x02\x04\x01\x00"}, /* fat..... */ \
+	{0x00000210, "\x02\x00\x02\x7f\x00\xf8\x01\x00"}, /* ........ */ \
+	{0x00000218, "\x20\x00\x40\x00\x00\x00\x00\x00"}, /*  .@..... */ \
+	{0x00000220, "\x00\x00\x00\x00\x80\x00\x29\x86"}, /* ......). */ \
+	{0x00000228, "\xe8\x82\x80\x4e\x4f\x20\x4e\x41"}, /* ...NO NA */ \
+	{0x00000230, "\x4d\x45\x20\x20\x20\x20\x46\x41"}, /* ME    FA */ \
+	{0x00000238, "\x54\x31\x32\x20\x20\x20\x0e\x1f"}, /* T12   .. */ \
+	{0x00000240, "\xbe\x5b\x7c\xac\x22\xc0\x74\x0b"}, /* .[|.".t. */ \
+	{0x00000248, "\x56\xb4\x0e\xbb\x07\x00\xcd\x10"}, /* V....... */ \
+	{0x00000250, "\x5e\xeb\xf0\x32\xe4\xcd\x16\xcd"}, /* ^..2.... */ \
+	{0x00000258, "\x19\xeb\xfe\x54\x68\x69\x73\x20"}, /* ...This  */ \
+	{0x00000260, "\x69\x73\x20\x6e\x6f\x74\x20\x61"}, /* is not a */ \
+	{0x00000268, "\x20\x62\x6f\x6f\x74\x61\x62\x6c"}, /*  bootabl */ \
+	{0x00000270, "\x65\x20\x64\x69\x73\x6b\x2e\x20"}, /* e disk.  */ \
+	{0x00000278, "\x20\x50\x6c\x65\x61\x73\x65\x20"}, /*  Please  */ \
+	{0x00000280, "\x69\x6e\x73\x65\x72\x74\x20\x61"}, /* insert a */ \
+	{0x00000288, "\x20\x62\x6f\x6f\x74\x61\x62\x6c"}, /*  bootabl */ \
+	{0x00000290, "\x65\x20\x66\x6c\x6f\x70\x70\x79"}, /* e floppy */ \
+	{0x00000298, "\x20\x61\x6e\x64\x0d\x0a\x70\x72"}, /*  and..pr */ \
+	{0x000002a0, "\x65\x73\x73\x20\x61\x6e\x79\x20"}, /* ess any  */ \
+	{0x000002a8, "\x6b\x65\x79\x20\x74\x6f\x20\x74"}, /* key to t */ \
+	{0x000002b0, "\x72\x79\x20\x61\x67\x61\x69\x6e"}, /* ry again */ \
+	{0x000002b8, "\x20\x2e\x2e\x2e\x20\x0d\x0a\x00"}, /*  ... ... */ \
+	{0x000003f8, "\x00\x00\x00\x00\x00\x00\x55\xaa"}, /* ......U. */ \
+	{0x00000400, "\xf8\xff\xff\x00\x00\x00\x00\xf0"}, /* ........ */ \
+	{0x00000408, "\xff\x00\x00\x00\x00\x00\x00\x00"}, /* ........ */ \
+	{0x00000600, "\xf8\xff\xff\x00\x00\x00\x00\xf0"}, /* ........ */ \
+	{0x00000608, "\xff\x00\x00\x00\x00\x00\x00\x00"}, /* ........ */ \
+	{0x00000800, "\xe5\x70\x00\x00\x00\xff\xff\xff"}, /* .p...... */ \
+	{0x00000808, "\xff\xff\xff\x0f\x00\x0e\xff\xff"}, /* ........ */ \
+	{0x00000810, "\xff\xff\xff\xff\xff\xff\xff\xff"}, /* ........ */ \
+	{0x00000818, "\xff\xff\x00\x00\xff\xff\xff\xff"}, /* ........ */ \
+	{0x00000820, "\xe5\x2e\x00\x68\x00\x65\x00\x6c"}, /* ...h.e.l */ \
+	{0x00000828, "\x00\x6c\x00\x0f\x00\x0e\x6f\x00"}, /* .l....o. */ \
+	{0x00000830, "\x2e\x00\x74\x00\x78\x00\x74\x00"}, /* ..t.x.t. */ \
+	{0x00000838, "\x2e\x00\x00\x00\x73\x00\x77\x00"}, /* ....s.w. */ \
+	{0x00000840, "\xe5\x45\x4c\x4c\x4f\x54\x7e\x31"}, /* .ELLOT~1 */ \
+	{0x00000848, "\x53\x57\x50\x20\x00\x64\xd0\x8a"}, /* SWP .d.. */ \
+	{0x00000850, "\x92\x4b\x92\x4b\x00\x00\xd0\x8a"}, /* .K.K.... */ \
+	{0x00000858, "\x92\x4b\x00\x00\x00\x00\x00\x00"}, /* .K...... */ \
+	{0x00000860, "\x41\x68\x00\x65\x00\x6c\x00\x6c"}, /* Ah.e.l.l */ \
+	{0x00000868, "\x00\x6f\x00\x0f\x00\xf1\x2e\x00"}, /* .o...... */ \
+	{0x00000870, "\x74\x00\x78\x00\x74\x00\x00\x00"}, /* t.x.t... */ \
+	{0x00000878, "\xff\xff\x00\x00\xff\xff\xff\xff"}, /* ........ */ \
+	{0x00000880, "\x48\x45\x4c\x4c\x4f\x20\x20\x20"}, /* HELLO    */ \
+	{0x00000888, "\x54\x58\x54\x20\x00\x64\xd4\x8a"}, /* TXT .d.. */ \
+	{0x00000890, "\x92\x4b\x92\x4b\x00\x00\xd4\x8a"}, /* .K.K.... */ \
+	{0x00000898, "\x92\x4b\x05\x00\x0d\x00\x00\x00"}, /* .K...... */ \
+	{0x000008a0, "\xe5\x45\x4c\x4c\x4f\x54\x7e\x31"}, /* .ELLOT~1 */ \
+	{0x000008a8, "\x53\x57\x58\x20\x00\x64\xd0\x8a"}, /* SWX .d.. */ \
+	{0x000008b0, "\x92\x4b\x92\x4b\x00\x00\xd0\x8a"}, /* .K.K.... */ \
+	{0x000008b8, "\x92\x4b\x00\x00\x00\x00\x00\x00"}, /* .K...... */ \
+	{0x00006000, "\x48\x65\x6c\x6c\x6f\x20\x77\x6f"}, /* Hello wo */ \
+	{0x00006008, "\x72\x6c\x64\x21\x0a\x00\x00\x00"}, /* rld!.... */ \
+	{0, NULL} } }
-- 
2.14.2

[U-Boot] [PATCH v2 18/18] efi_loader: fix ExitBootServices

[Heinrich Schuchardt]

This patch lets the implementation of ExitBootServices conform to
the UEFI standard.

The timer events must be disabled before calling the notification
functions of the exit boot services events.

The boot services must be disabled in the system table.

The handles in the system table should be defined as efi_handle_t.

Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
---
v2
	new patch
---
 include/efi_api.h             |  6 +++---
 lib/efi_loader/efi_boottime.c | 36 +++++++++++++++++++++++++++++++-----
 2 files changed, 34 insertions(+), 8 deletions(-)

diff --git a/include/efi_api.h b/include/efi_api.h
index 0bc244444d..4252d11398 100644
--- a/include/efi_api.h
+++ b/include/efi_api.h
@@ -247,11 +247,11 @@ struct efi_system_table {
 	struct efi_table_hdr hdr;
 	unsigned long fw_vendor;   /* physical addr of wchar_t vendor string */
 	u32 fw_revision;
-	unsigned long con_in_handle;
+	efi_handle_t con_in_handle;
 	struct efi_simple_input_interface *con_in;
-	unsigned long con_out_handle;
+	efi_handle_t con_out_handle;
 	struct efi_simple_text_output_protocol *con_out;
-	unsigned long stderr_handle;
+	efi_handle_t stderr_handle;
 	struct efi_simple_text_output_protocol *std_err;
 	struct efi_runtime_services *runtime;
 	struct efi_boot_services *boottime;
diff --git a/lib/efi_loader/efi_boottime.c b/lib/efi_loader/efi_boottime.c
index 4b3b63e39a..2c5499e0c8 100644
--- a/lib/efi_loader/efi_boottime.c
+++ b/lib/efi_loader/efi_boottime.c
@@ -1645,12 +1645,16 @@ static void efi_exit_caches(void)
 }
 
 /*
- * Stop boot services.
+ * Stop all boot services.
  *
  * This function implements the ExitBootServices service.
  * See the Unified Extensible Firmware Interface (UEFI) specification
  * for details.
  *
+ * All timer events are disabled.
+ * For exit boot services events the notification function is called.
+ * The boot services are disabled in the system table.
+ *
  * @image_handle	handle of the loaded image
  * @map_key		key of the memory map
  * @return		status code
@@ -1662,16 +1666,24 @@ static efi_status_t EFIAPI efi_exit_boot_services(efi_handle_t image_handle,
 
 	EFI_ENTRY("%p, %ld", image_handle, map_key);
 
+	/* Make sure that notification functions are not called anymore */
+	efi_tpl = TPL_HIGH_LEVEL;
+
+	/* Check if ExitBootServices has already been called */
+	if (!systab.boottime)
+		return EFI_EXIT(EFI_SUCCESS);
+
 	/* Notify that ExitBootServices is invoked. */
 	for (i = 0; i < ARRAY_SIZE(efi_events); ++i) {
 		if (efi_events[i].type != EVT_SIGNAL_EXIT_BOOT_SERVICES)
 			continue;
-		efi_signal_event(&efi_events[i]);
+		if (!efi_events[i].notify_function)
+			continue;
+		EFI_CALL_VOID(efi_events[i].notify_function(
+				&efi_events[i], efi_events[i].notify_context));
 	}
-	/* Make sure that notification functions are not called anymore */
-	efi_tpl = TPL_HIGH_LEVEL;
 
-	/* XXX Should persist EFI variables here */
+	/* TODO Should persist EFI variables here */
 
 	board_quiesce_devices();
 
@@ -1681,6 +1693,20 @@ static efi_status_t EFIAPI efi_exit_boot_services(efi_handle_t image_handle,
 	/* This stops all lingering devices */
 	bootm_disable_interrupts();
 
+	/* Disable boottime services */
+	systab.con_in_handle = NULL;
+	systab.con_in = NULL;
+	systab.con_out_handle = NULL;
+	systab.con_out = NULL;
+	systab.stderr_handle = NULL;
+	systab.std_err = NULL;
+	systab.boottime = NULL;
+
+	/* Recalculate CRC32 */
+	systab.hdr.crc32 = 0;
+	systab.hdr.crc32 = crc32(0, (const unsigned char *)&systab,
+				 sizeof(struct efi_system_table));
+
 	/* Give the payload some time to boot */
 	efi_set_watchdog(0);
 	WATCHDOG_RESET();
-- 
2.14.2

[U-Boot] [PATCH v2 02/18] efi_loader: address of the simple file system protocol

[Alexander Graf]

On 17.01.18 20:15, Heinrich Schuchardt wrote:
> When installing the the simple file system protocol we have to path
> the address of the structure and not the address of a pointer ot the

s/ot/to/


Alex

> structure.
> 
> Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
> ---
> v2
> 	no change
> ---
>  lib/efi_loader/efi_disk.c | 2 +-
>  1 file changed, 1 insertion(+), 1 deletion(-)
> 
> diff --git a/lib/efi_loader/efi_disk.c b/lib/efi_loader/efi_disk.c
> index d299fc8dea..85b4a147e2 100644
> --- a/lib/efi_loader/efi_disk.c
> +++ b/lib/efi_loader/efi_disk.c
> @@ -242,7 +242,7 @@ static void efi_disk_add_dev(const char *name,
>  							 diskobj->dp);
>  		ret = efi_add_protocol(diskobj->parent.handle,
>  				       &efi_simple_file_system_protocol_guid,
> -				       &diskobj->volume);
> +				       diskobj->volume);
>  		if (ret != EFI_SUCCESS)
>  			goto out_of_memory;
>  	}
> 

[U-Boot] [PATCH v2 12/18] efi_loader: correct EFI_BLOCK_IO_PROTOCOL definitions

[Alexander Graf]

On 17.01.18 20:16, Heinrich Schuchardt wrote:
> Add the revision constants.
> Depending on the revision additional fields are needed in the
> media descriptor.
> Use efi_uintn_t for number of bytes to read or write.
> 
> Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
> ---
> v2
> 	no change
> ---
>  include/efi_api.h         | 10 ++++++++--
>  lib/efi_loader/efi_disk.c |  8 ++++----
>  2 files changed, 12 insertions(+), 6 deletions(-)
> 
> diff --git a/include/efi_api.h b/include/efi_api.h
> index 502fffed20..0bc244444d 100644
> --- a/include/efi_api.h
> +++ b/include/efi_api.h
> @@ -424,18 +424,24 @@ struct efi_block_io_media
>  	u32 io_align;
>  	u8 pad2[4];
>  	u64 last_block;

Please add comments on each field which revision it's available in. Or
alternatively revision cut lines, like /* Below is available as of
revision 2 */.


Alex

> +	u64 lowest_aligned_lba;
> +	u32 logical_blocks_per_physical_block;
> +	u32 optimal_transfer_length_granualarity;
>  };
>  
> +#define EFI_BLOCK_IO_PROTOCOL_REVISION2	0x00020001
> +#define EFI_BLOCK_IO_PROTOCOL_REVISION3	0x0002001f
> +
>  struct efi_block_io {
>  	u64 revision;
>  	struct efi_block_io_media *media;
>  	efi_status_t (EFIAPI *reset)(struct efi_block_io *this,
>  			char extended_verification);
>  	efi_status_t (EFIAPI *read_blocks)(struct efi_block_io *this,
> -			u32 media_id, u64 lba, unsigned long buffer_size,
> +			u32 media_id, u64 lba, efi_uintn_t buffer_size,
>  			void *buffer);
>  	efi_status_t (EFIAPI *write_blocks)(struct efi_block_io *this,
> -			u32 media_id, u64 lba, unsigned long buffer_size,
> +			u32 media_id, u64 lba, efi_uintn_t buffer_size,
>  			void *buffer);
>  	efi_status_t (EFIAPI *flush_blocks)(struct efi_block_io *this);
>  };
> diff --git a/lib/efi_loader/efi_disk.c b/lib/efi_loader/efi_disk.c
> index 92c3f45ca5..8f84e7788e 100644
> --- a/lib/efi_loader/efi_disk.c
> +++ b/lib/efi_loader/efi_disk.c
> @@ -91,7 +91,7 @@ static efi_status_t efi_disk_rw_blocks(struct efi_block_io *this,
>  }
>  
>  static efi_status_t EFIAPI efi_disk_read_blocks(struct efi_block_io *this,
> -			u32 media_id, u64 lba, unsigned long buffer_size,
> +			u32 media_id, u64 lba, efi_uintn_t buffer_size,
>  			void *buffer)
>  {
>  	void *real_buffer = buffer;
> @@ -112,7 +112,7 @@ static efi_status_t EFIAPI efi_disk_read_blocks(struct efi_block_io *this,
>  	real_buffer = efi_bounce_buffer;
>  #endif
>  
> -	EFI_ENTRY("%p, %x, %"PRIx64", %lx, %p", this, media_id, lba,
> +	EFI_ENTRY("%p, %x, %" PRIx64 ", %zx, %p", this, media_id, lba,
>  		  buffer_size, buffer);
>  
>  	r = efi_disk_rw_blocks(this, media_id, lba, buffer_size, real_buffer,
> @@ -126,7 +126,7 @@ static efi_status_t EFIAPI efi_disk_read_blocks(struct efi_block_io *this,
>  }
>  
>  static efi_status_t EFIAPI efi_disk_write_blocks(struct efi_block_io *this,
> -			u32 media_id, u64 lba, unsigned long buffer_size,
> +			u32 media_id, u64 lba, efi_uintn_t buffer_size,
>  			void *buffer)
>  {
>  	void *real_buffer = buffer;
> @@ -147,7 +147,7 @@ static efi_status_t EFIAPI efi_disk_write_blocks(struct efi_block_io *this,
>  	real_buffer = efi_bounce_buffer;
>  #endif
>  
> -	EFI_ENTRY("%p, %x, %"PRIx64", %lx, %p", this, media_id, lba,
> +	EFI_ENTRY("%p, %x, %" PRIx64 ", %zx, %p", this, media_id, lba,
>  		  buffer_size, buffer);
>  
>  	/* Populate bounce buffer if necessary */
> 

[U-Boot] [PATCH v2 11/18] efi_loader: make efi_disk_create_partitions a global symbol

[Alexander Graf]

On 17.01.18 20:16, Heinrich Schuchardt wrote:
> Up to now we have been using efi_disk_create_partitions() to create
> partions for block device that existed before starting an EFI

partitions

devices

> application.
> 
> We need to to call it for for block devices created by EFI

s/to//
s/for//


Alex

[U-Boot] [PATCH v2 14/18] efi_loader: provide links between devices EFI handles

[Alexander Graf]

On 17.01.18 20:16, Heinrich Schuchardt wrote:
> U-Boot devices and EFI handles can be related, e.g. an
> IDE disk relates to a handle with the EFI_BLOCK_IO_PROTOCOL.
> Provide pointers to store these links.
> 
> Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
> ---
> v2
> 	no change
> ---
>  include/dm/device.h           | 4 ++++
>  include/efi_loader.h          | 2 ++
>  lib/efi_loader/efi_boottime.c | 1 +
>  3 files changed, 7 insertions(+)
> 
> diff --git a/include/dm/device.h b/include/dm/device.h
> index 813e49f330..e5c54fe7b6 100644
> --- a/include/dm/device.h
> +++ b/include/dm/device.h
> @@ -11,6 +11,7 @@
>  #ifndef _DM_DEVICE_H
>  #define _DM_DEVICE_H
>  
> +#include <efi_loader.h>
>  #include <dm/ofnode.h>
>  #include <dm/uclass-id.h>
>  #include <fdtdec.h>
> @@ -144,6 +145,9 @@ struct udevice {
>  	uint32_t flags;
>  	int req_seq;
>  	int seq;
> +#ifdef EFI_LOADER
> +	efi_handle_t handle;
> +#endif

I fail to find where you actually make use of the handle inside

>  #ifdef CONFIG_DEVRES
>  	struct list_head devres_head;
>  #endif
> diff --git a/include/efi_loader.h b/include/efi_loader.h
> index 4060348695..711c901eda 100644
> --- a/include/efi_loader.h
> +++ b/include/efi_loader.h
> @@ -139,6 +139,8 @@ struct efi_object {
>  	struct list_head protocols;
>  	/* The object spawner can either use this for data or as identifier */
>  	void *handle;
> +	/* Device */
> +	struct udevice *dev;
>  };
>  
>  /**
> diff --git a/lib/efi_loader/efi_boottime.c b/lib/efi_loader/efi_boottime.c
> index 5a3349ecb2..4b3b63e39a 100644
> --- a/lib/efi_loader/efi_boottime.c
> +++ b/lib/efi_loader/efi_boottime.c
> @@ -362,6 +362,7 @@ efi_status_t efi_create_handle(efi_handle_t *handle)
>  			      (void **)&obj);
>  	if (r != EFI_SUCCESS)
>  		return r;
> +	obj->dev = NULL;

How about we just zero initialize the whole struct?

Alex

>  	efi_add_handle(obj);
>  	*handle = obj->handle;
>  	return r;
> 

[U-Boot] [PATCH v2 14/18] efi_loader: provide links between devices EFI handles

[Heinrich Schuchardt]

On 01/18/2018 05:09 PM, Alexander Graf wrote:
> 
> 
> On 17.01.18 20:16, Heinrich Schuchardt wrote:
>> U-Boot devices and EFI handles can be related, e.g. an
>> IDE disk relates to a handle with the EFI_BLOCK_IO_PROTOCOL.
>> Provide pointers to store these links.
>>
>> Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
>> ---
>> v2
>> 	no change
>> ---
>>  include/dm/device.h           | 4 ++++
>>  include/efi_loader.h          | 2 ++
>>  lib/efi_loader/efi_boottime.c | 1 +
>>  3 files changed, 7 insertions(+)
>>
>> diff --git a/include/dm/device.h b/include/dm/device.h
>> index 813e49f330..e5c54fe7b6 100644
>> --- a/include/dm/device.h
>> +++ b/include/dm/device.h
>> @@ -11,6 +11,7 @@
>>  #ifndef _DM_DEVICE_H
>>  #define _DM_DEVICE_H
>>  
>> +#include <efi_loader.h>
>>  #include <dm/ofnode.h>
>>  #include <dm/uclass-id.h>
>>  #include <fdtdec.h>
>> @@ -144,6 +145,9 @@ struct udevice {
>>  	uint32_t flags;
>>  	int req_seq;
>>  	int seq;
>> +#ifdef EFI_LOADER
>> +	efi_handle_t handle;
>> +#endif
> 
> I fail to find where you actually make use of the handle inside
> 
>>  #ifdef CONFIG_DEVRES
>>  	struct list_head devres_head;
>>  #endif
>> diff --git a/include/efi_loader.h b/include/efi_loader.h
>> index 4060348695..711c901eda 100644
>> --- a/include/efi_loader.h
>> +++ b/include/efi_loader.h
>> @@ -139,6 +139,8 @@ struct efi_object {
>>  	struct list_head protocols;
>>  	/* The object spawner can either use this for data or as identifier */
>>  	void *handle;
>> +	/* Device */
>> +	struct udevice *dev;
>>  };
>>  
>>  /**
>> diff --git a/lib/efi_loader/efi_boottime.c b/lib/efi_loader/efi_boottime.c
>> index 5a3349ecb2..4b3b63e39a 100644
>> --- a/lib/efi_loader/efi_boottime.c
>> +++ b/lib/efi_loader/efi_boottime.c
>> @@ -362,6 +362,7 @@ efi_status_t efi_create_handle(efi_handle_t *handle)
>>  			      (void **)&obj);
>>  	if (r != EFI_SUCCESS)
>>  		return r;
>> +	obj->dev = NULL;
> 
> How about we just zero initialize the whole struct?

All other fields are initialized in efi_add_handle().
So why invest more CPU cycles?

Regards

Heinrich

> 
> Alex
> 
>>  	efi_add_handle(obj);
>>  	*handle = obj->handle;
>>  	return r;
>>
> 

[U-Boot] [PATCH v2 14/18] efi_loader: provide links between devices EFI handles

[Alexander Graf]

On 18.01.18 17:18, Heinrich Schuchardt wrote:
> On 01/18/2018 05:09 PM, Alexander Graf wrote:
>>
>>
>> On 17.01.18 20:16, Heinrich Schuchardt wrote:
>>> U-Boot devices and EFI handles can be related, e.g. an
>>> IDE disk relates to a handle with the EFI_BLOCK_IO_PROTOCOL.
>>> Provide pointers to store these links.
>>>
>>> Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
>>> ---
>>> v2
>>> 	no change
>>> ---
>>>  include/dm/device.h           | 4 ++++
>>>  include/efi_loader.h          | 2 ++
>>>  lib/efi_loader/efi_boottime.c | 1 +
>>>  3 files changed, 7 insertions(+)
>>>
>>> diff --git a/include/dm/device.h b/include/dm/device.h
>>> index 813e49f330..e5c54fe7b6 100644
>>> --- a/include/dm/device.h
>>> +++ b/include/dm/device.h
>>> @@ -11,6 +11,7 @@
>>>  #ifndef _DM_DEVICE_H
>>>  #define _DM_DEVICE_H
>>>  
>>> +#include <efi_loader.h>
>>>  #include <dm/ofnode.h>
>>>  #include <dm/uclass-id.h>
>>>  #include <fdtdec.h>
>>> @@ -144,6 +145,9 @@ struct udevice {
>>>  	uint32_t flags;
>>>  	int req_seq;
>>>  	int seq;
>>> +#ifdef EFI_LOADER
>>> +	efi_handle_t handle;
>>> +#endif
>>
>> I fail to find where you actually make use of the handle inside

Care to answer here too? :)

>>
>>>  #ifdef CONFIG_DEVRES
>>>  	struct list_head devres_head;
>>>  #endif
>>> diff --git a/include/efi_loader.h b/include/efi_loader.h
>>> index 4060348695..711c901eda 100644
>>> --- a/include/efi_loader.h
>>> +++ b/include/efi_loader.h
>>> @@ -139,6 +139,8 @@ struct efi_object {
>>>  	struct list_head protocols;
>>>  	/* The object spawner can either use this for data or as identifier */
>>>  	void *handle;
>>> +	/* Device */
>>> +	struct udevice *dev;
>>>  };
>>>  
>>>  /**
>>> diff --git a/lib/efi_loader/efi_boottime.c b/lib/efi_loader/efi_boottime.c
>>> index 5a3349ecb2..4b3b63e39a 100644
>>> --- a/lib/efi_loader/efi_boottime.c
>>> +++ b/lib/efi_loader/efi_boottime.c
>>> @@ -362,6 +362,7 @@ efi_status_t efi_create_handle(efi_handle_t *handle)
>>>  			      (void **)&obj);
>>>  	if (r != EFI_SUCCESS)
>>>  		return r;
>>> +	obj->dev = NULL;
>>
>> How about we just zero initialize the whole struct?
> 
> All other fields are initialized in efi_add_handle().
> So why invest more CPU cycles?

I'm mostly concerned that we get into a situation where people don't
fully grasp the flow of what gets initialized where and nasty bugs happen.

So I guess we should either initialize obj->dev in efi_add_handle() or
fully zero initialize obj, like we do for most other callers of
efi_add_handle().


Alex

[U-Boot] [PATCH v2 14/18] efi_loader: provide links between devices EFI handles

[Alexander Graf]

On 17.01.18 20:16, Heinrich Schuchardt wrote:
> U-Boot devices and EFI handles can be related, e.g. an
> IDE disk relates to a handle with the EFI_BLOCK_IO_PROTOCOL.
> Provide pointers to store these links.
> 
> Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>

You actually wouldn't need any of these changes I think. With a small
change to the block driver, even the need for "dev" disappears.

Alex

diff --git a/lib/efi_driver/efi_block_device.c
b/lib/efi_driver/efi_block_device.c
index 837787d563..71c752d107 100644
--- a/lib/efi_driver/efi_block_device.c
+++ b/lib/efi_driver/efi_block_device.c
@@ -91,19 +91,19 @@ static ulong efi_bl_write(struct udevice *dev,
lbaint_t blknr, lbaint_t blkcnt,
 	return blkcnt;
 }

-static int efi_bl_bind_partions(efi_handle_t handle)
+static int efi_bl_bind_partions(efi_object *obj, struct udevice *bdev)
 {
 	struct efi_object *obj = efi_search_obj(handle);
 	struct blk_desc *desc;
 	const char *if_typename;

-	if (!obj || !obj->dev)
+	if (!obj || !bdev)
 		return -ENOENT;
-	desc = dev_get_uclass_platdata(obj->dev);
+	desc = dev_get_uclass_platdata(bdev);
 	if_typename = blk_get_if_type_name(desc->if_type);

 	return efi_disk_create_partitions(handle, desc, if_typename,
-					  desc->devnum, obj->dev->name);
+					  desc->devnum, bdev->name);
 }

 /*
@@ -137,11 +137,10 @@ static int efi_bl_bind(efi_handle_t handle, void
*interface)
 		return ret;
 	EFI_PRINT("%s: block device '%s' created\n", __func__, bdev->name);
 	bdev->platdata = interface;
-	obj->dev = bdev;

 	ret = blk_prepare_device(bdev);

-	disks = efi_bl_bind_partions(handle);
+	disks = efi_bl_bind_partions(obj, bdev);
 	EFI_PRINT("Found %d partions\n", disks);

 	return 0;

[U-Boot] [PATCH v2 14/18] efi_loader: provide links between devices EFI handles

[Heinrich Schuchardt]

On 01/18/2018 07:13 PM, Alexander Graf wrote:
> 
> 
> On 18.01.18 17:18, Heinrich Schuchardt wrote:
>> On 01/18/2018 05:09 PM, Alexander Graf wrote:
>>>
>>>
>>> On 17.01.18 20:16, Heinrich Schuchardt wrote:
>>>> U-Boot devices and EFI handles can be related, e.g. an
>>>> IDE disk relates to a handle with the EFI_BLOCK_IO_PROTOCOL.
>>>> Provide pointers to store these links.
>>>>
>>>> Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
>>>> ---
>>>> v2
>>>> 	no change
>>>> ---
>>>>  include/dm/device.h           | 4 ++++
>>>>  include/efi_loader.h          | 2 ++
>>>>  lib/efi_loader/efi_boottime.c | 1 +
>>>>  3 files changed, 7 insertions(+)
>>>>
>>>> diff --git a/include/dm/device.h b/include/dm/device.h
>>>> index 813e49f330..e5c54fe7b6 100644
>>>> --- a/include/dm/device.h
>>>> +++ b/include/dm/device.h
>>>> @@ -11,6 +11,7 @@
>>>>  #ifndef _DM_DEVICE_H
>>>>  #define _DM_DEVICE_H
>>>>  
>>>> +#include <efi_loader.h>
>>>>  #include <dm/ofnode.h>
>>>>  #include <dm/uclass-id.h>
>>>>  #include <fdtdec.h>
>>>> @@ -144,6 +145,9 @@ struct udevice {
>>>>  	uint32_t flags;
>>>>  	int req_seq;
>>>>  	int seq;
>>>> +#ifdef EFI_LOADER
>>>> +	efi_handle_t handle;
>>>> +#endif
>>>
>>> I fail to find where you actually make use of the handle inside
> 
> Care to answer here too? :)

The changes in include/dm/device.h are not needed. I will revert these.

Maybe in future we will have to back link devices to handles but not now.

Regards

Heinrich

> 
>>>
>>>>  #ifdef CONFIG_DEVRES
>>>>  	struct list_head devres_head;
>>>>  #endif
>>>> diff --git a/include/efi_loader.h b/include/efi_loader.h
>>>> index 4060348695..711c901eda 100644
>>>> --- a/include/efi_loader.h
>>>> +++ b/include/efi_loader.h
>>>> @@ -139,6 +139,8 @@ struct efi_object {
>>>>  	struct list_head protocols;
>>>>  	/* The object spawner can either use this for data or as identifier */
>>>>  	void *handle;
>>>> +	/* Device */
>>>> +	struct udevice *dev;
>>>>  };
>>>>  
>>>>  /**
>>>> diff --git a/lib/efi_loader/efi_boottime.c b/lib/efi_loader/efi_boottime.c
>>>> index 5a3349ecb2..4b3b63e39a 100644
>>>> --- a/lib/efi_loader/efi_boottime.c
>>>> +++ b/lib/efi_loader/efi_boottime.c
>>>> @@ -362,6 +362,7 @@ efi_status_t efi_create_handle(efi_handle_t *handle)
>>>>  			      (void **)&obj);
>>>>  	if (r != EFI_SUCCESS)
>>>>  		return r;
>>>> +	obj->dev = NULL;
>>>
>>> How about we just zero initialize the whole struct?
>>
>> All other fields are initialized in efi_add_handle().
>> So why invest more CPU cycles?
> 
> I'm mostly concerned that we get into a situation where people don't
> fully grasp the flow of what gets initialized where and nasty bugs happen.
> 
> So I guess we should either initialize obj->dev in efi_add_handle() or
> fully zero initialize obj, like we do for most other callers of
> efi_add_handle().
> 
> 
> Alex
> 

[U-Boot] [PATCH v2 16/18] efi_driver: EFI block driver

[Heinrich Schuchardt]

On 01/17/2018 08:16 PM, Heinrich Schuchardt wrote:
> 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 partions 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>
> ---
> v2
> 	Print to console only in debug mode.
> 	Provide more comments.
> 	Add commit message.
> ---
>  common/board_r.c                  |   3 +
>  drivers/block/blk-uclass.c        |   4 +-
>  include/blk.h                     |   1 +
>  include/config_fallbacks.h        |   1 +
>  include/dm/uclass-id.h            |   1 +
>  include/efi_driver.h              |  30 ++++
>  include/efi_loader.h              |   2 +
>  lib/Makefile                      |   1 +
>  lib/efi_driver/Makefile           |  13 ++
>  lib/efi_driver/efi_block_device.c | 175 ++++++++++++++++++++
>  lib/efi_driver/efi_uclass.c       | 330 ++++++++++++++++++++++++++++++++++++++
>  11 files changed, 560 insertions(+), 1 deletion(-)
>  create mode 100644 include/efi_driver.h
>  create mode 100644 lib/efi_driver/Makefile
>  create mode 100644 lib/efi_driver/efi_block_device.c
>  create mode 100644 lib/efi_driver/efi_uclass.c
> 
> diff --git a/common/board_r.c b/common/board_r.c
> index 2baa47f3a0..4ad37ee31a 100644
> --- a/common/board_r.c
> +++ b/common/board_r.c
> @@ -715,7 +715,10 @@ static init_fnc_t init_sequence_r[] = {
>  	set_cpu_clk_info, /* Setup clock information */
>  #endif
>  #ifdef CONFIG_EFI_LOADER
> +	/* Setup EFI memory before any other EFI related code */
>  	efi_memory_init,
> +	/* Install EFI drivers */
> +	efi_driver_init,
>  #endif
>  	stdio_init_tables,
>  	initr_serial,
> diff --git a/drivers/block/blk-uclass.c b/drivers/block/blk-uclass.c
> index 010ed32d3a..bfda2211f0 100644
> --- a/drivers/block/blk-uclass.c
> +++ b/drivers/block/blk-uclass.c
> @@ -24,6 +24,7 @@ static const char *if_typename_str[IF_TYPE_COUNT] = {
>  	[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 @@ static enum uclass_id if_type_uclass_id[IF_TYPE_COUNT] = {
>  	[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)
> diff --git a/include/blk.h b/include/blk.h
> index 41b4d7efa8..69b5a98e56 100644
> --- a/include/blk.h
> +++ b/include/blk.h
> @@ -34,6 +34,7 @@ enum if_type {
>  	IF_TYPE_HOST,
>  	IF_TYPE_SYSTEMACE,
>  	IF_TYPE_NVME,
> +	IF_TYPE_EFI,
>  
>  	IF_TYPE_COUNT,			/* Number of interface types */
>  };
> diff --git a/include/config_fallbacks.h b/include/config_fallbacks.h
> index 2c4d43d672..524313d5aa 100644
> --- a/include/config_fallbacks.h
> +++ b/include/config_fallbacks.h
> @@ -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
> diff --git a/include/dm/uclass-id.h b/include/dm/uclass-id.h
> index 3fc20834ae..07fabc3ce6 100644
> --- a/include/dm/uclass-id.h
> +++ b/include/dm/uclass-id.h
> @@ -34,6 +34,7 @@ enum uclass_id {
>  	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 */
> diff --git a/include/efi_driver.h b/include/efi_driver.h
> new file mode 100644
> index 0000000000..2bbe26c6e3
> --- /dev/null
> +++ b/include/efi_driver.h
> @@ -0,0 +1,30 @@
> +/*
> + *  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 */
> diff --git a/include/efi_loader.h b/include/efi_loader.h
> index 711c901eda..a465175d1f 100644
> --- a/include/efi_loader.h
> +++ b/include/efi_loader.h
> @@ -273,6 +273,8 @@ efi_status_t efi_get_memory_map(efi_uintn_t *memory_map_size,
>  /* 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 */
> diff --git a/lib/Makefile b/lib/Makefile
> index 8cd779f8ca..0db41c19f3 100644
> --- a/lib/Makefile
> +++ b/lib/Makefile
> @@ -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/
> diff --git a/lib/efi_driver/Makefile b/lib/efi_driver/Makefile
> new file mode 100644
> index 0000000000..e35529a952
> --- /dev/null
> +++ b/lib/efi_driver/Makefile
> @@ -0,0 +1,13 @@
> +#
> +# (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
> diff --git a/lib/efi_driver/efi_block_device.c b/lib/efi_driver/efi_block_device.c
> new file mode 100644
> index 0000000000..837787d563
> --- /dev/null
> +++ b/lib/efi_driver/efi_block_device.c
> @@ -0,0 +1,175 @@
> +/*
> + *  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 partions with the simple file
> + * protocol.
> + *
> + * iPXE uses the simple file protocol to load Grub or the Linux Kernel.
> + */
> +
> +#include <efi_driver.h>
> +#include <dm/root.h>
> +
> +static int efi_blk_max_devnum;
> +
> +/*
> + * 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_block_io *io = dev->platdata;
> +	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_block_io *io = dev->platdata;
> +	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;
> +}
> +
> +static int efi_bl_bind_partions(efi_handle_t handle)
> +{
> +	struct efi_object *obj = efi_search_obj(handle);
> +	struct blk_desc *desc;
> +	const char *if_typename;
> +
> +	if (!obj || !obj->dev)
> +		return -ENOENT;
> +	desc = dev_get_uclass_platdata(obj->dev);
> +	if_typename = blk_get_if_type_name(desc->if_type);
> +
> +	return efi_disk_create_partitions(handle, desc, if_typename,
> +					  desc->devnum, obj->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[20];
> +	struct efi_object *obj = efi_search_obj(handle);
> +	struct efi_block_io *io = interface;
> +	int disks;
> +
> +	EFI_PRINT("%s: handle %p, interface %p\n", __func__, handle, io);
> +
> +	if (!obj)
> +		return -ENOENT;
> +
> +	devnum = efi_blk_max_devnum++;
> +	sprintf(name, "efi#%d", devnum);
> +
> +	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;
> +	EFI_PRINT("%s: block device '%s' created\n", __func__, bdev->name);
> +	bdev->platdata = interface;
> +	obj->dev = bdev;
> +
> +	ret = blk_prepare_device(bdev);
> +
> +	disks = efi_bl_bind_partions(handle);
> +	EFI_PRINT("Found %d partions\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,
> +};
> +
> +/* 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,
> +};
> diff --git a/lib/efi_driver/efi_uclass.c b/lib/efi_driver/efi_uclass.c
> new file mode 100644
> index 0000000000..798431ae74
> --- /dev/null
> +++ b/lib/efi_driver/efi_uclass.c
> @@ -0,0 +1,330 @@
> +/*
> + *  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 partions 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().

Hello Alex,

in a chat you asked why this is not called in efi_init_obj_list() after
entering the bootefi command.

My architectural perspective is that in future we will create the EFI
handles from the device tree in parallel to creating the udevices and
use ConnectController to install the EFI drivers (e.g. for the simple
network protocol in the case of network interfaces). This is only
possible if the EFI uclass exists before udevices are created.

Best regards

Heinrich

> + *
> + * @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,
> +};
>

[U-Boot] [PATCH v2 00/18] efi_loader: enable EFI driver provided block device

[Simon Glass]

Hi Heinrich,

On 17 January 2018 at 11:15, Heinrich Schuchardt <xypron.glpk@gmx.de> wrote:
> With this patch series an EFI application or driver can supply
> a block device which in turn can be used to download an image.
>
> E.g. we can load iPXE, connect iSCSI drives, download grub from the
> SAN and afterwards with grub download and run an EFI application.
> Booting Linux from an iSCSI drive was successful on arm64.
>
> v2:
>         Add an additional patch to fix ExitBootServices.
>         Provide comments for EFI block driver.
>         Avoid printing when not in debug mode
>         Add product tools/file2include to .gitignore.
>         Put the patch with the test for block io after the patch for the
>         driver.
>
> Heinrich Schuchardt (18):
>   efi_loader: return NULL from device path functions
>   efi_loader: address of the simple file system protocol
>   efi_loader: correct find simple file system protocol
>   efi_loader: print device path when entering efi_load_image
>   efi_loader: allocate correct memory type for EFI image
>   efi_loader: check tables in helloworld.efi
>   efi_loader: fix StartImage bootservice
>   efi_loader: efi_disk_register: correctly determine if_type_name
>   efi_loader: make efi_block_io_guid a global symbol
>   efi_loader: provide a function to create a partition node
>   efi_loader: make efi_disk_create_partitions a global symbol
>   efi_loader: correct EFI_BLOCK_IO_PROTOCOL definitions
>   efi_loader: provide function to get last node of a device path
>   efi_loader: provide links between devices EFI handles
>   tools: provide a tool to convert a binary file to an include
>   efi_driver: EFI block driver
>   efi_selftest: provide a test for block io
>   efi_loader: fix ExitBootServices
>
>  MAINTAINERS                                  |   1 +
>  common/board_r.c                             |   3 +
>  drivers/block/blk-uclass.c                   |   4 +-
>  include/blk.h                                |   1 +
>  include/config_fallbacks.h                   |   1 +
>  include/dm/device.h                          |   4 +
>  include/dm/uclass-id.h                       |   1 +
>  include/efi_api.h                            |  16 +-
>  include/efi_driver.h                         |  30 ++
>  include/efi_loader.h                         |  21 +-
>  lib/Makefile                                 |   1 +
>  lib/efi_driver/Makefile                      |  13 +
>  lib/efi_driver/efi_block_device.c            | 175 ++++++++++++
>  lib/efi_driver/efi_uclass.c                  | 330 ++++++++++++++++++++++
>  lib/efi_loader/efi_boottime.c                |  42 ++-
>  lib/efi_loader/efi_device_path.c             | 168 +++++++++---
>  lib/efi_loader/efi_disk.c                    | 137 +++++++---
>  lib/efi_loader/efi_image_loader.c            |  64 +++--
>  lib/efi_loader/helloworld.c                  |  26 ++
>  lib/efi_selftest/Makefile                    |   4 +
>  lib/efi_selftest/efi_selftest_block_device.c | 395 +++++++++++++++++++++++++++
>  lib/efi_selftest/efi_selftest_disk_image.h   |  69 +++++
>  tools/.gitignore                             |   1 +
>  tools/Makefile                               |   3 +
>  tools/file2include.c                         | 106 +++++++
>  25 files changed, 1493 insertions(+), 123 deletions(-)
>  create mode 100644 include/efi_driver.h
>  create mode 100644 lib/efi_driver/Makefile
>  create mode 100644 lib/efi_driver/efi_block_device.c
>  create mode 100644 lib/efi_driver/efi_uclass.c
>  create mode 100644 lib/efi_selftest/efi_selftest_block_device.c
>  create mode 100644 lib/efi_selftest/efi_selftest_disk_image.h
>  create mode 100644 tools/file2include.c
>
> --
> 2.14.2
>

Do you have a git tree with these patches? I get errors when applying them.

Some general comments for discussion, based on my limited understanding.

At present from what I can tell, this looks through the UCLASS_EFI
drivers and instantiates a EFI driver/device for each. But it does not
seem to relate this to the U-Boot driver. It seems in fact to create a
new device. For example efi_bl_bind() calls blk_create_device().

Instead I think there should be a real driver-rmodel device creasted
with UCLASS_EFI. It should be a child of the DM UCLASS_BLK device. The
could work in a similar way to now, except that it can scan DM devices
of a particular UCLASS rather than scanning DM drivers.

Also the patch that creates a tool to generate a binary as a header
file - can we use the same method as we use for other embedding? See
for example how .dtb is done.

Regards,
Simon

[U-Boot] [PATCH v2 00/18] efi_loader: enable EFI driver provided block device

[Heinrich Schuchardt]

On 01/19/2018 12:00 AM, Simon Glass wrote:
> Hi Heinrich,
> 
> On 17 January 2018 at 11:15, Heinrich Schuchardt <xypron.glpk@gmx.de> wrote:
>> With this patch series an EFI application or driver can supply
>> a block device which in turn can be used to download an image.
>>
>> E.g. we can load iPXE, connect iSCSI drives, download grub from the
>> SAN and afterwards with grub download and run an EFI application.
>> Booting Linux from an iSCSI drive was successful on arm64.
>>
>> v2:
>>          Add an additional patch to fix ExitBootServices.
>>          Provide comments for EFI block driver.
>>          Avoid printing when not in debug mode
>>          Add product tools/file2include to .gitignore.
>>          Put the patch with the test for block io after the patch for the
>>          driver.
>>
>> Heinrich Schuchardt (18):
>>    efi_loader: return NULL from device path functions
>>    efi_loader: address of the simple file system protocol
>>    efi_loader: correct find simple file system protocol
>>    efi_loader: print device path when entering efi_load_image
>>    efi_loader: allocate correct memory type for EFI image
>>    efi_loader: check tables in helloworld.efi
>>    efi_loader: fix StartImage bootservice
>>    efi_loader: efi_disk_register: correctly determine if_type_name
>>    efi_loader: make efi_block_io_guid a global symbol
>>    efi_loader: provide a function to create a partition node
>>    efi_loader: make efi_disk_create_partitions a global symbol
>>    efi_loader: correct EFI_BLOCK_IO_PROTOCOL definitions
>>    efi_loader: provide function to get last node of a device path
>>    efi_loader: provide links between devices EFI handles
>>    tools: provide a tool to convert a binary file to an include
>>    efi_driver: EFI block driver
>>    efi_selftest: provide a test for block io
>>    efi_loader: fix ExitBootServices
>>
>>   MAINTAINERS                                  |   1 +
>>   common/board_r.c                             |   3 +
>>   drivers/block/blk-uclass.c                   |   4 +-
>>   include/blk.h                                |   1 +
>>   include/config_fallbacks.h                   |   1 +
>>   include/dm/device.h                          |   4 +
>>   include/dm/uclass-id.h                       |   1 +
>>   include/efi_api.h                            |  16 +-
>>   include/efi_driver.h                         |  30 ++
>>   include/efi_loader.h                         |  21 +-
>>   lib/Makefile                                 |   1 +
>>   lib/efi_driver/Makefile                      |  13 +
>>   lib/efi_driver/efi_block_device.c            | 175 ++++++++++++
>>   lib/efi_driver/efi_uclass.c                  | 330 ++++++++++++++++++++++
>>   lib/efi_loader/efi_boottime.c                |  42 ++-
>>   lib/efi_loader/efi_device_path.c             | 168 +++++++++---
>>   lib/efi_loader/efi_disk.c                    | 137 +++++++---
>>   lib/efi_loader/efi_image_loader.c            |  64 +++--
>>   lib/efi_loader/helloworld.c                  |  26 ++
>>   lib/efi_selftest/Makefile                    |   4 +
>>   lib/efi_selftest/efi_selftest_block_device.c | 395 +++++++++++++++++++++++++++
>>   lib/efi_selftest/efi_selftest_disk_image.h   |  69 +++++
>>   tools/.gitignore                             |   1 +
>>   tools/Makefile                               |   3 +
>>   tools/file2include.c                         | 106 +++++++
>>   25 files changed, 1493 insertions(+), 123 deletions(-)
>>   create mode 100644 include/efi_driver.h
>>   create mode 100644 lib/efi_driver/Makefile
>>   create mode 100644 lib/efi_driver/efi_block_device.c
>>   create mode 100644 lib/efi_driver/efi_uclass.c
>>   create mode 100644 lib/efi_selftest/efi_selftest_block_device.c
>>   create mode 100644 lib/efi_selftest/efi_selftest_disk_image.h
>>   create mode 100644 tools/file2include.c
>>
>> --
>> 2.14.2
>>
> 
> Do you have a git tree with these patches? I get errors when applying them.

https://github.com/xypron2/u-boot.git
branch efi-2018-03-rc1

> 
> Some general comments for discussion, based on my limited understanding.
> 
> At present from what I can tell, this looks through the UCLASS_EFI
> drivers and instantiates a EFI driver/device for each. But it does not
> seem to relate this to the U-Boot driver. It seems in fact to create a
> new device. For example efi_bl_bind() calls blk_create_device().

It is important to understand the sequence of events:

U-Boot creates the EFI uclass.
This uclass iterates over all EFI drivers (only one up to now).
For each driver it creates a handle.
on the handle it install the EFI_DRIVER_BINDING protocol.
U-Boot loads iPXE.
iPXE creates connects to a target on an iSCSI server

Up to this point the iSCSI drive that we want to connect to as a block 
device is completely unknown to U-Boot.

iPXE creates a handle for the target and installs the 
EFI_BLOCK_IO_PROTOCOL on the handle.
iPXE calls ConnectController for this handle (which is referred to as 
controller).
efi_connect_controller() loops over all handles implementing the 
EFI_DRIVER_BINDING protocol and calls the supported() method of the 
protocol to identify a driver supporting the controller.
For each driver supporting the controller the start() method is called.

The supported() and start() methods are implemented in the EFI uclass.
In the supported() and start() methods the protocol GUID exposed by the 
EFI driver is compared to the GUIDS of the protocols installed on the 
controller to find a match.
If a match is found the EFI uclass calls the bind function of the EFI 
driver.

The EFI block driver now creates a block device.
For the block device it creates partitions.
On the partitions it installs the EFI_SIMPLE_FILE_SYSTEM_PROTOCOL.
The EFI block driver has a read (efi_bl_read) and a write (efi_bl_write) 
function.
These delegate reads and writes to the EFI_BLOCK_IO_PROTOCOL.

Now iPXE tries to load grub.
It calls the OpenVolume method of the EFI_SIMPLE_FILE_SYSTEM_PROTOCOL of 
the partition to get an instance of the EFI_FILE_PROTOCOL.
iPXE calls the Open method of the EFI_FILE_PROTOCOL with the path to grub.
This method is implemented in efi_file_open().
efi_file_open calls fs_exists() which calls ext4fs_exitsts() which calls 
the read method of the block device created by the EFI block driver. 
This method is implemented in efi_bl_read().
efi_bl_read() calls the read_blocks() method of the 
EFI_BLOCK_IO_PROTOCOL exposed by iPXE.
iPXE now uses the iSCSI protocol to read the requested blocks from the 
iSCSI server.


> 
> Instead I think there should be a real driver-rmodel device creasted
> with UCLASS_EFI. It should be a child of the DM UCLASS_BLK device. The
> could work in a similar way to now, except that it can scan DM devices
> of a particular UCLASS rather than scanning DM drivers.
> 

There is nothing to scan before the EFI application is running.
The starting point is ConnectController being called by the EFI application

The EFI uclass is not specific to block devices. It is responsible for 
all future EFI drivers. These could support any kind of virtual devices, 
e.g. a network interface.

> Also the patch that creates a tool to generate a binary as a header
> file - can we use the same method as we use for other embedding? See
> for example how .dtb is done.

I avoid embedding a 64kiB disk image. My include results in 728 bytes in 
the binary. I really want compression here.

With further patches I have to include binaries again which compress nicely.

Regards

Heinrich

> 
> Regards,
> Simon
> 

[U-Boot] [PATCH v2 18/18] efi_loader: fix ExitBootServices

[Alexander Graf]

On 17.01.18 20:16, Heinrich Schuchardt wrote:
> This patch lets the implementation of ExitBootServices conform to
> the UEFI standard.
> 
> The timer events must be disabled before calling the notification
> functions of the exit boot services events.
> 
> The boot services must be disabled in the system table.
> 
> The handles in the system table should be defined as efi_handle_t.
> 
> Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
> ---
> v2
> 	new patch
> ---
>  include/efi_api.h             |  6 +++---
>  lib/efi_loader/efi_boottime.c | 36 +++++++++++++++++++++++++++++++-----
>  2 files changed, 34 insertions(+), 8 deletions(-)
> 
> diff --git a/include/efi_api.h b/include/efi_api.h
> index 0bc244444d..4252d11398 100644
> --- a/include/efi_api.h
> +++ b/include/efi_api.h
> @@ -247,11 +247,11 @@ struct efi_system_table {
>  	struct efi_table_hdr hdr;
>  	unsigned long fw_vendor;   /* physical addr of wchar_t vendor string */
>  	u32 fw_revision;
> -	unsigned long con_in_handle;
> +	efi_handle_t con_in_handle;
>  	struct efi_simple_input_interface *con_in;
> -	unsigned long con_out_handle;
> +	efi_handle_t con_out_handle;
>  	struct efi_simple_text_output_protocol *con_out;
> -	unsigned long stderr_handle;
> +	efi_handle_t stderr_handle;
>  	struct efi_simple_text_output_protocol *std_err;
>  	struct efi_runtime_services *runtime;
>  	struct efi_boot_services *boottime;
> diff --git a/lib/efi_loader/efi_boottime.c b/lib/efi_loader/efi_boottime.c
> index 4b3b63e39a..2c5499e0c8 100644
> --- a/lib/efi_loader/efi_boottime.c
> +++ b/lib/efi_loader/efi_boottime.c
> @@ -1645,12 +1645,16 @@ static void efi_exit_caches(void)
>  }
>  
>  /*
> - * Stop boot services.
> + * Stop all boot services.
>   *
>   * This function implements the ExitBootServices service.
>   * See the Unified Extensible Firmware Interface (UEFI) specification
>   * for details.
>   *
> + * All timer events are disabled.
> + * For exit boot services events the notification function is called.
> + * The boot services are disabled in the system table.
> + *
>   * @image_handle	handle of the loaded image
>   * @map_key		key of the memory map
>   * @return		status code
> @@ -1662,16 +1666,24 @@ static efi_status_t EFIAPI efi_exit_boot_services(efi_handle_t image_handle,
>  
>  	EFI_ENTRY("%p, %ld", image_handle, map_key);
>  
> +	/* Make sure that notification functions are not called anymore */
> +	efi_tpl = TPL_HIGH_LEVEL;
> +
> +	/* Check if ExitBootServices has already been called */
> +	if (!systab.boottime)
> +		return EFI_EXIT(EFI_SUCCESS);
> +
>  	/* Notify that ExitBootServices is invoked. */
>  	for (i = 0; i < ARRAY_SIZE(efi_events); ++i) {
>  		if (efi_events[i].type != EVT_SIGNAL_EXIT_BOOT_SERVICES)
>  			continue;
> -		efi_signal_event(&efi_events[i]);
> +		if (!efi_events[i].notify_function)
> +			continue;
> +		EFI_CALL_VOID(efi_events[i].notify_function(
> +				&efi_events[i], efi_events[i].notify_context));

This basically just bypasses the event->notify_tpl check. Can't you add
an enum parameter to efi_signal_event to indicate EFI_SIGNAL_CHECK_TPL
vs EFI_SIGNAL_NOCHECK and only do the TPL check in there if
EFI_SIGNAL_CHECK_TPL is set?


Alex

>  	}
> -	/* Make sure that notification functions are not called anymore */
> -	efi_tpl = TPL_HIGH_LEVEL;
>  
> -	/* XXX Should persist EFI variables here */
> +	/* TODO Should persist EFI variables here */
>  
>  	board_quiesce_devices();
>  
> @@ -1681,6 +1693,20 @@ static efi_status_t EFIAPI efi_exit_boot_services(efi_handle_t image_handle,
>  	/* This stops all lingering devices */
>  	bootm_disable_interrupts();
>  
> +	/* Disable boottime services */
> +	systab.con_in_handle = NULL;
> +	systab.con_in = NULL;
> +	systab.con_out_handle = NULL;
> +	systab.con_out = NULL;
> +	systab.stderr_handle = NULL;
> +	systab.std_err = NULL;
> +	systab.boottime = NULL;
> +
> +	/* Recalculate CRC32 */
> +	systab.hdr.crc32 = 0;
> +	systab.hdr.crc32 = crc32(0, (const unsigned char *)&systab,
> +				 sizeof(struct efi_system_table));
> +
>  	/* Give the payload some time to boot */
>  	efi_set_watchdog(0);
>  	WATCHDOG_RESET();
> 

[U-Boot] [PATCH v2 16/18] efi_driver: EFI block driver

[Alexander Graf]

On 18.01.18 21:08, Heinrich Schuchardt wrote:
> On 01/17/2018 08:16 PM, Heinrich Schuchardt wrote:
>> 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 partions 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>
>> ---
>> v2
>> 	Print to console only in debug mode.
>> 	Provide more comments.
>> 	Add commit message.
>> ---
>>  common/board_r.c                  |   3 +
>>  drivers/block/blk-uclass.c        |   4 +-
>>  include/blk.h                     |   1 +
>>  include/config_fallbacks.h        |   1 +
>>  include/dm/uclass-id.h            |   1 +
>>  include/efi_driver.h              |  30 ++++
>>  include/efi_loader.h              |   2 +
>>  lib/Makefile                      |   1 +
>>  lib/efi_driver/Makefile           |  13 ++
>>  lib/efi_driver/efi_block_device.c | 175 ++++++++++++++++++++
>>  lib/efi_driver/efi_uclass.c       | 330 ++++++++++++++++++++++++++++++++++++++
>>  11 files changed, 560 insertions(+), 1 deletion(-)
>>  create mode 100644 include/efi_driver.h
>>  create mode 100644 lib/efi_driver/Makefile
>>  create mode 100644 lib/efi_driver/efi_block_device.c
>>  create mode 100644 lib/efi_driver/efi_uclass.c
>>
>> diff --git a/common/board_r.c b/common/board_r.c
>> index 2baa47f3a0..4ad37ee31a 100644
>> --- a/common/board_r.c
>> +++ b/common/board_r.c
>> @@ -715,7 +715,10 @@ static init_fnc_t init_sequence_r[] = {
>>  	set_cpu_clk_info, /* Setup clock information */
>>  #endif
>>  #ifdef CONFIG_EFI_LOADER
>> +	/* Setup EFI memory before any other EFI related code */
>>  	efi_memory_init,
>> +	/* Install EFI drivers */
>> +	efi_driver_init,
>>  #endif
>>  	stdio_init_tables,
>>  	initr_serial,
>> diff --git a/drivers/block/blk-uclass.c b/drivers/block/blk-uclass.c
>> index 010ed32d3a..bfda2211f0 100644
>> --- a/drivers/block/blk-uclass.c
>> +++ b/drivers/block/blk-uclass.c
>> @@ -24,6 +24,7 @@ static const char *if_typename_str[IF_TYPE_COUNT] = {
>>  	[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 @@ static enum uclass_id if_type_uclass_id[IF_TYPE_COUNT] = {
>>  	[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)
>> diff --git a/include/blk.h b/include/blk.h
>> index 41b4d7efa8..69b5a98e56 100644
>> --- a/include/blk.h
>> +++ b/include/blk.h
>> @@ -34,6 +34,7 @@ enum if_type {
>>  	IF_TYPE_HOST,
>>  	IF_TYPE_SYSTEMACE,
>>  	IF_TYPE_NVME,
>> +	IF_TYPE_EFI,
>>  
>>  	IF_TYPE_COUNT,			/* Number of interface types */
>>  };
>> diff --git a/include/config_fallbacks.h b/include/config_fallbacks.h
>> index 2c4d43d672..524313d5aa 100644
>> --- a/include/config_fallbacks.h
>> +++ b/include/config_fallbacks.h
>> @@ -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
>> diff --git a/include/dm/uclass-id.h b/include/dm/uclass-id.h
>> index 3fc20834ae..07fabc3ce6 100644
>> --- a/include/dm/uclass-id.h
>> +++ b/include/dm/uclass-id.h
>> @@ -34,6 +34,7 @@ enum uclass_id {
>>  	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 */
>> diff --git a/include/efi_driver.h b/include/efi_driver.h
>> new file mode 100644
>> index 0000000000..2bbe26c6e3
>> --- /dev/null
>> +++ b/include/efi_driver.h
>> @@ -0,0 +1,30 @@
>> +/*
>> + *  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 */
>> diff --git a/include/efi_loader.h b/include/efi_loader.h
>> index 711c901eda..a465175d1f 100644
>> --- a/include/efi_loader.h
>> +++ b/include/efi_loader.h
>> @@ -273,6 +273,8 @@ efi_status_t efi_get_memory_map(efi_uintn_t *memory_map_size,
>>  /* 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 */
>> diff --git a/lib/Makefile b/lib/Makefile
>> index 8cd779f8ca..0db41c19f3 100644
>> --- a/lib/Makefile
>> +++ b/lib/Makefile
>> @@ -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/
>> diff --git a/lib/efi_driver/Makefile b/lib/efi_driver/Makefile
>> new file mode 100644
>> index 0000000000..e35529a952
>> --- /dev/null
>> +++ b/lib/efi_driver/Makefile
>> @@ -0,0 +1,13 @@
>> +#
>> +# (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
>> diff --git a/lib/efi_driver/efi_block_device.c b/lib/efi_driver/efi_block_device.c
>> new file mode 100644
>> index 0000000000..837787d563
>> --- /dev/null
>> +++ b/lib/efi_driver/efi_block_device.c
>> @@ -0,0 +1,175 @@
>> +/*
>> + *  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 partions with the simple file
>> + * protocol.
>> + *
>> + * iPXE uses the simple file protocol to load Grub or the Linux Kernel.
>> + */
>> +
>> +#include <efi_driver.h>
>> +#include <dm/root.h>
>> +
>> +static int efi_blk_max_devnum;
>> +
>> +/*
>> + * 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_block_io *io = dev->platdata;
>> +	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_block_io *io = dev->platdata;
>> +	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;
>> +}
>> +
>> +static int efi_bl_bind_partions(efi_handle_t handle)
>> +{
>> +	struct efi_object *obj = efi_search_obj(handle);
>> +	struct blk_desc *desc;
>> +	const char *if_typename;
>> +
>> +	if (!obj || !obj->dev)
>> +		return -ENOENT;
>> +	desc = dev_get_uclass_platdata(obj->dev);
>> +	if_typename = blk_get_if_type_name(desc->if_type);
>> +
>> +	return efi_disk_create_partitions(handle, desc, if_typename,
>> +					  desc->devnum, obj->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[20];
>> +	struct efi_object *obj = efi_search_obj(handle);
>> +	struct efi_block_io *io = interface;
>> +	int disks;
>> +
>> +	EFI_PRINT("%s: handle %p, interface %p\n", __func__, handle, io);
>> +
>> +	if (!obj)
>> +		return -ENOENT;
>> +
>> +	devnum = efi_blk_max_devnum++;
>> +	sprintf(name, "efi#%d", devnum);
>> +
>> +	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;
>> +	EFI_PRINT("%s: block device '%s' created\n", __func__, bdev->name);
>> +	bdev->platdata = interface;
>> +	obj->dev = bdev;
>> +
>> +	ret = blk_prepare_device(bdev);
>> +
>> +	disks = efi_bl_bind_partions(handle);
>> +	EFI_PRINT("Found %d partions\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,
>> +};
>> +
>> +/* 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,
>> +};
>> diff --git a/lib/efi_driver/efi_uclass.c b/lib/efi_driver/efi_uclass.c
>> new file mode 100644
>> index 0000000000..798431ae74
>> --- /dev/null
>> +++ b/lib/efi_driver/efi_uclass.c
>> @@ -0,0 +1,330 @@
>> +/*
>> + *  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 partions 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().
> 
> Hello Alex,
> 
> in a chat you asked why this is not called in efi_init_obj_list() after
> entering the bootefi command.
> 
> My architectural perspective is that in future we will create the EFI
> handles from the device tree in parallel to creating the udevices and
> use ConnectController to install the EFI drivers (e.g. for the simple
> network protocol in the case of network interfaces). This is only
> possible if the EFI uclass exists before udevices are created.

I'm not 100% sure that's the right direction yet, let's just leave it in
bootefi for now.


Alex

[U-Boot] [PATCH v2 00/18] efi_loader: enable EFI driver provided block device

[Simon Glass]

Hi Heinrich,

On 19 January 2018 at 00:41, Heinrich Schuchardt <xypron.glpk@gmx.de> wrote:
> On 01/19/2018 12:00 AM, Simon Glass wrote:
>>
>> Hi Heinrich,
>>
>> On 17 January 2018 at 11:15, Heinrich Schuchardt <xypron.glpk@gmx.de>
>> wrote:
>>>
>>> With this patch series an EFI application or driver can supply
>>> a block device which in turn can be used to download an image.
>>>
>>> E.g. we can load iPXE, connect iSCSI drives, download grub from the
>>> SAN and afterwards with grub download and run an EFI application.
>>> Booting Linux from an iSCSI drive was successful on arm64.
>>>
>>> v2:
>>>          Add an additional patch to fix ExitBootServices.
>>>          Provide comments for EFI block driver.
>>>          Avoid printing when not in debug mode
>>>          Add product tools/file2include to .gitignore.
>>>          Put the patch with the test for block io after the patch for the
>>>          driver.
>>>
>>> Heinrich Schuchardt (18):
>>>    efi_loader: return NULL from device path functions
>>>    efi_loader: address of the simple file system protocol
>>>    efi_loader: correct find simple file system protocol
>>>    efi_loader: print device path when entering efi_load_image
>>>    efi_loader: allocate correct memory type for EFI image
>>>    efi_loader: check tables in helloworld.efi
>>>    efi_loader: fix StartImage bootservice
>>>    efi_loader: efi_disk_register: correctly determine if_type_name
>>>    efi_loader: make efi_block_io_guid a global symbol
>>>    efi_loader: provide a function to create a partition node
>>>    efi_loader: make efi_disk_create_partitions a global symbol
>>>    efi_loader: correct EFI_BLOCK_IO_PROTOCOL definitions
>>>    efi_loader: provide function to get last node of a device path
>>>    efi_loader: provide links between devices EFI handles
>>>    tools: provide a tool to convert a binary file to an include
>>>    efi_driver: EFI block driver
>>>    efi_selftest: provide a test for block io
>>>    efi_loader: fix ExitBootServices
>>>
>>>   MAINTAINERS                                  |   1 +
>>>   common/board_r.c                             |   3 +
>>>   drivers/block/blk-uclass.c                   |   4 +-
>>>   include/blk.h                                |   1 +
>>>   include/config_fallbacks.h                   |   1 +
>>>   include/dm/device.h                          |   4 +
>>>   include/dm/uclass-id.h                       |   1 +
>>>   include/efi_api.h                            |  16 +-
>>>   include/efi_driver.h                         |  30 ++
>>>   include/efi_loader.h                         |  21 +-
>>>   lib/Makefile                                 |   1 +
>>>   lib/efi_driver/Makefile                      |  13 +
>>>   lib/efi_driver/efi_block_device.c            | 175 ++++++++++++
>>>   lib/efi_driver/efi_uclass.c                  | 330
>>> ++++++++++++++++++++++
>>>   lib/efi_loader/efi_boottime.c                |  42 ++-
>>>   lib/efi_loader/efi_device_path.c             | 168 +++++++++---
>>>   lib/efi_loader/efi_disk.c                    | 137 +++++++---
>>>   lib/efi_loader/efi_image_loader.c            |  64 +++--
>>>   lib/efi_loader/helloworld.c                  |  26 ++
>>>   lib/efi_selftest/Makefile                    |   4 +
>>>   lib/efi_selftest/efi_selftest_block_device.c | 395
>>> +++++++++++++++++++++++++++
>>>   lib/efi_selftest/efi_selftest_disk_image.h   |  69 +++++
>>>   tools/.gitignore                             |   1 +
>>>   tools/Makefile                               |   3 +
>>>   tools/file2include.c                         | 106 +++++++
>>>   25 files changed, 1493 insertions(+), 123 deletions(-)
>>>   create mode 100644 include/efi_driver.h
>>>   create mode 100644 lib/efi_driver/Makefile
>>>   create mode 100644 lib/efi_driver/efi_block_device.c
>>>   create mode 100644 lib/efi_driver/efi_uclass.c
>>>   create mode 100644 lib/efi_selftest/efi_selftest_block_device.c
>>>   create mode 100644 lib/efi_selftest/efi_selftest_disk_image.h
>>>   create mode 100644 tools/file2include.c
>>>
>>> --
>>> 2.14.2
>>>
>>
>> Do you have a git tree with these patches? I get errors when applying
>> them.
>
>
> https://github.com/xypron2/u-boot.git
> branch efi-2018-03-rc1
>
>>
>> Some general comments for discussion, based on my limited understanding.
>>
>> At present from what I can tell, this looks through the UCLASS_EFI
>> drivers and instantiates a EFI driver/device for each. But it does not
>> seem to relate this to the U-Boot driver. It seems in fact to create a
>> new device. For example efi_bl_bind() calls blk_create_device().
>
>
> It is important to understand the sequence of events:
>
> U-Boot creates the EFI uclass.
> This uclass iterates over all EFI drivers (only one up to now).
> For each driver it creates a handle.
> on the handle it install the EFI_DRIVER_BINDING protocol.
> U-Boot loads iPXE.
> iPXE creates connects to a target on an iSCSI server
>
> Up to this point the iSCSI drive that we want to connect to as a block
> device is completely unknown to U-Boot.

This seems wonky to me. If U-Boot is hosting a device it should at
least know about it. We should not have a parallel system with its own
devices - it will get horribly confusing.

Is it not possible to create a device within the U-Boot driver model,
with an EFI device connecting to it?

>
> iPXE creates a handle for the target and installs the EFI_BLOCK_IO_PROTOCOL
> on the handle.
> iPXE calls ConnectController for this handle (which is referred to as
> controller).
> efi_connect_controller() loops over all handles implementing the
> EFI_DRIVER_BINDING protocol and calls the supported() method of the protocol
> to identify a driver supporting the controller.
> For each driver supporting the controller the start() method is called.
>
> The supported() and start() methods are implemented in the EFI uclass.
> In the supported() and start() methods the protocol GUID exposed by the EFI
> driver is compared to the GUIDS of the protocols installed on the controller
> to find a match.
> If a match is found the EFI uclass calls the bind function of the EFI
> driver.
>
> The EFI block driver now creates a block device.
> For the block device it creates partitions.
> On the partitions it installs the EFI_SIMPLE_FILE_SYSTEM_PROTOCOL.
> The EFI block driver has a read (efi_bl_read) and a write (efi_bl_write)
> function.
> These delegate reads and writes to the EFI_BLOCK_IO_PROTOCOL.
>
> Now iPXE tries to load grub.
> It calls the OpenVolume method of the EFI_SIMPLE_FILE_SYSTEM_PROTOCOL of the
> partition to get an instance of the EFI_FILE_PROTOCOL.
> iPXE calls the Open method of the EFI_FILE_PROTOCOL with the path to grub.
> This method is implemented in efi_file_open().
> efi_file_open calls fs_exists() which calls ext4fs_exitsts() which calls the
> read method of the block device created by the EFI block driver. This method
> is implemented in efi_bl_read().
> efi_bl_read() calls the read_blocks() method of the EFI_BLOCK_IO_PROTOCOL
> exposed by iPXE.
> iPXE now uses the iSCSI protocol to read the requested blocks from the iSCSI
> server.

So are you saying that EFI discovers the device, and then creates a
block device within U-Boot? What is the parent of the block device?

>
>
>>
>> Instead I think there should be a real driver-rmodel device creasted
>> with UCLASS_EFI. It should be a child of the DM UCLASS_BLK device. The
>> could work in a similar way to now, except that it can scan DM devices
>> of a particular UCLASS rather than scanning DM drivers.
>>
>
> There is nothing to scan before the EFI application is running.
> The starting point is ConnectController being called by the EFI application
>
> The EFI uclass is not specific to block devices. It is responsible for all
> future EFI drivers. These could support any kind of virtual devices, e.g. a
> network interface.

Yes, I understand that.

But I think if EFI discovers a device, it should bind it in DM, then
attach an EFI device to that device if needed.

>
>> Also the patch that creates a tool to generate a binary as a header
>> file - can we use the same method as we use for other embedding? See
>> for example how .dtb is done.
>
>
> I avoid embedding a 64kiB disk image. My include results in 728 bytes in the
> binary. I really want compression here.
>
> With further patches I have to include binaries again which compress nicely.

Are you saying that you want to compress the disk image and compile it
into U-Boot? What does that have to do with the .dtb method? It should
not be hard to embedded a compressed image that way, too.

Regards,
Simon