summaryrefslogtreecommitdiff
path: root/lib
diff options
context:
space:
mode:
Diffstat (limited to 'lib')
-rw-r--r--lib/charset.c29
-rw-r--r--lib/efi_driver/efi_uclass.c3
-rw-r--r--lib/efi_loader/Kconfig16
-rw-r--r--lib/efi_loader/Makefile4
-rw-r--r--lib/efi_loader/efi_boottime.c34
-rw-r--r--lib/efi_loader/efi_file.c18
-rw-r--r--lib/efi_loader/efi_freestanding.c90
-rw-r--r--lib/efi_loader/efi_hii.c1095
-rw-r--r--lib/efi_loader/efi_hii_config.c146
-rw-r--r--lib/efi_loader/efi_memory.c6
-rw-r--r--lib/efi_loader/efi_runtime.c3
-rw-r--r--lib/efi_loader/efi_setup.c86
-rw-r--r--lib/efi_loader/efi_variable.c300
-rw-r--r--lib/efi_loader/helloworld.c36
-rw-r--r--lib/efi_selftest/Makefile11
-rw-r--r--lib/efi_selftest/efi_selftest_block_device.c6
-rw-r--r--lib/efi_selftest/efi_selftest_events.c6
-rw-r--r--lib/efi_selftest/efi_selftest_hii.c1035
-rw-r--r--lib/efi_selftest/efi_selftest_hii_data.c453
-rw-r--r--lib/efi_selftest/efi_selftest_snp.c8
-rw-r--r--lib/efi_selftest/efi_selftest_tpl.c4
-rw-r--r--lib/efi_selftest/efi_selftest_variables.c17
-rw-r--r--lib/fdtdec.c33
-rw-r--r--lib/vsprintf.c10
24 files changed, 3309 insertions, 140 deletions
diff --git a/lib/charset.c b/lib/charset.c
index 10557b9e75..5e349ed5ee 100644
--- a/lib/charset.c
+++ b/lib/charset.c
@@ -349,6 +349,35 @@ size_t u16_strnlen(const u16 *in, size_t count)
return i;
}
+u16 *u16_strcpy(u16 *dest, const u16 *src)
+{
+ u16 *tmp = dest;
+
+ for (;; dest++, src++) {
+ *dest = *src;
+ if (!*src)
+ break;
+ }
+
+ return tmp;
+}
+
+u16 *u16_strdup(const u16 *src)
+{
+ u16 *new;
+
+ if (!src)
+ return NULL;
+
+ new = malloc((u16_strlen(src) + 1) * sizeof(u16));
+ if (!new)
+ return NULL;
+
+ u16_strcpy(new, src);
+
+ return new;
+}
+
/* Convert UTF-16 to UTF-8. */
uint8_t *utf16_to_utf8(uint8_t *dest, const uint16_t *src, size_t size)
{
diff --git a/lib/efi_driver/efi_uclass.c b/lib/efi_driver/efi_uclass.c
index bb86ffd399..7cdf81f40c 100644
--- a/lib/efi_driver/efi_uclass.c
+++ b/lib/efi_driver/efi_uclass.c
@@ -233,8 +233,7 @@ static efi_status_t EFIAPI efi_uc_stop(
}
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__);
+ printf("%s: ERROR: Cannot free pool\n", __func__);
/* Detach driver from controller */
ret = EFI_CALL(systab.boottime->close_protocol(
diff --git a/lib/efi_loader/Kconfig b/lib/efi_loader/Kconfig
index b921ea8821..23487b8130 100644
--- a/lib/efi_loader/Kconfig
+++ b/lib/efi_loader/Kconfig
@@ -8,6 +8,7 @@ config EFI_LOADER
default y
select LIB_UUID
select HAVE_BLOCK_DEVICE
+ select REGEX
imply CFB_CONSOLE_ANSI
help
Select this option if you want to run EFI applications (like grub2)
@@ -33,3 +34,18 @@ config EFI_LOADER_BOUNCE_BUFFER
Some hardware does not support DMA to full 64bit addresses. For this
hardware we can create a bounce buffer so that payloads don't have to
worry about platform details.
+
+config EFI_LOADER_HII
+ bool "Expose HII protocols to EFI applications"
+ depends on EFI_LOADER
+ default n
+ help
+ The Human Interface Infrastructure is a complicated framework that
+ allows UEFI applications to draw fancy menus and hook strings using
+ a translation framework.
+
+ U-Boot implements enough of its features to be able to run the UEFI
+ Shell, but not more than that. The code is experimental still, so
+ beware that your system might break with HII enabled.
+
+ If unsure, say n.
diff --git a/lib/efi_loader/Makefile b/lib/efi_loader/Makefile
index 6703435947..4e90a35896 100644
--- a/lib/efi_loader/Makefile
+++ b/lib/efi_loader/Makefile
@@ -10,7 +10,7 @@ CFLAGS_efi_boottime.o += \
-DFW_VERSION="0x$(VERSION)" \
-DFW_PATCHLEVEL="0x$(PATCHLEVEL)"
CFLAGS_helloworld.o := $(CFLAGS_EFI) -Os -ffreestanding
-CFLAGS_REMOVE_helloworld.o := $(CFLAGS_NON_EFI) -Os
+CFLAGS_REMOVE_helloworld.o := $(CFLAGS_NON_EFI)
ifneq ($(CONFIG_CMD_BOOTEFI_HELLO_COMPILE),)
always += helloworld.efi
@@ -24,10 +24,12 @@ obj-y += efi_device_path.o
obj-y += efi_device_path_to_text.o
obj-y += efi_device_path_utilities.o
obj-y += efi_file.o
+obj-y += efi_hii.o efi_hii_config.o
obj-y += efi_image_loader.o
obj-y += efi_memory.o
obj-y += efi_root_node.o
obj-y += efi_runtime.o
+obj-y += efi_setup.o
obj-y += efi_unicode_collation.o
obj-y += efi_variable.o
obj-y += efi_watchdog.o
diff --git a/lib/efi_loader/efi_boottime.c b/lib/efi_loader/efi_boottime.c
index cc9efbb0cb..f74f989e0a 100644
--- a/lib/efi_loader/efi_boottime.c
+++ b/lib/efi_loader/efi_boottime.c
@@ -1558,6 +1558,26 @@ efi_status_t efi_setup_loaded_image(struct efi_device_path *device_path,
if (ret != EFI_SUCCESS)
goto failure;
+#if CONFIG_IS_ENABLED(EFI_LOADER_HII)
+ ret = efi_add_protocol(&obj->header,
+ &efi_guid_hii_string_protocol,
+ (void *)&efi_hii_string);
+ if (ret != EFI_SUCCESS)
+ goto failure;
+
+ ret = efi_add_protocol(&obj->header,
+ &efi_guid_hii_database_protocol,
+ (void *)&efi_hii_database);
+ if (ret != EFI_SUCCESS)
+ goto failure;
+
+ ret = efi_add_protocol(&obj->header,
+ &efi_guid_hii_config_routing_protocol,
+ (void *)&efi_hii_config_routing);
+ if (ret != EFI_SUCCESS)
+ goto failure;
+#endif
+
return ret;
failure:
printf("ERROR: Failure to install protocols for loaded image\n");
@@ -1706,8 +1726,8 @@ error:
* Return: status code
*/
static efi_status_t EFIAPI efi_start_image(efi_handle_t image_handle,
- unsigned long *exit_data_size,
- s16 **exit_data)
+ efi_uintn_t *exit_data_size,
+ u16 **exit_data)
{
struct efi_loaded_image_obj *image_obj =
(struct efi_loaded_image_obj *)image_handle;
@@ -1773,8 +1793,8 @@ static efi_status_t EFIAPI efi_start_image(efi_handle_t image_handle,
*/
static efi_status_t EFIAPI efi_exit(efi_handle_t image_handle,
efi_status_t exit_status,
- unsigned long exit_data_size,
- int16_t *exit_data)
+ efi_uintn_t exit_data_size,
+ u16 *exit_data)
{
/*
* TODO: We should call the unload procedure of the loaded
@@ -1783,7 +1803,7 @@ static efi_status_t EFIAPI efi_exit(efi_handle_t image_handle,
struct efi_loaded_image_obj *image_obj =
(struct efi_loaded_image_obj *)image_handle;
- EFI_ENTRY("%p, %ld, %ld, %p", image_handle, exit_status,
+ EFI_ENTRY("%p, %ld, %zu, %p", image_handle, exit_status,
exit_data_size, exit_data);
/* Make sure entry/exit counts for EFI world cross-overs match */
@@ -2483,7 +2503,7 @@ static void EFIAPI efi_copy_mem(void *destination, const void *source,
size_t length)
{
EFI_ENTRY("%p, %p, %ld", destination, source, (unsigned long)length);
- memcpy(destination, source, length);
+ memmove(destination, source, length);
EFI_EXIT(EFI_SUCCESS);
}
@@ -2825,7 +2845,7 @@ static efi_status_t EFIAPI efi_connect_controller(
efi_status_t ret = EFI_NOT_FOUND;
struct efi_object *efiobj;
- EFI_ENTRY("%p, %p, %p, %d", controller_handle, driver_image_handle,
+ EFI_ENTRY("%p, %p, %pD, %d", controller_handle, driver_image_handle,
remain_device_path, recursive);
efiobj = efi_search_obj(controller_handle);
diff --git a/lib/efi_loader/efi_file.c b/lib/efi_loader/efi_file.c
index 8a4f3a9f40..4b4422205d 100644
--- a/lib/efi_loader/efi_file.c
+++ b/lib/efi_loader/efi_file.c
@@ -148,7 +148,7 @@ static int sanitize_path(char *path)
* Returns: handle to the opened file or NULL
*/
static struct efi_file_handle *file_open(struct file_system *fs,
- struct file_handle *parent, s16 *file_name, u64 mode,
+ struct file_handle *parent, u16 *file_name, u64 mode,
u64 attributes)
{
struct file_handle *fh;
@@ -157,8 +157,8 @@ static struct efi_file_handle *file_open(struct file_system *fs,
int flen = 0;
if (file_name) {
- utf16_to_utf8((u8 *)f0, (u16 *)file_name, 1);
- flen = u16_strlen((u16 *)file_name);
+ utf16_to_utf8((u8 *)f0, file_name, 1);
+ flen = u16_strlen(file_name);
}
/* we could have a parent, but also an absolute path: */
@@ -183,7 +183,7 @@ static struct efi_file_handle *file_open(struct file_system *fs,
*p++ = '/';
}
- utf16_to_utf8((u8 *)p, (u16 *)file_name, flen);
+ utf16_to_utf8((u8 *)p, file_name, flen);
if (sanitize_path(fh->path))
goto error;
@@ -200,6 +200,10 @@ static struct efi_file_handle *file_open(struct file_system *fs,
fs_exists(fh->path)))
goto error;
+ /* fs_exists() calls fs_close(), so open file system again */
+ if (set_blk_dev(fh))
+ goto error;
+
/* figure out if file is a directory: */
fh->isdir = is_dir(fh);
} else {
@@ -216,7 +220,7 @@ error:
static efi_status_t EFIAPI efi_file_open(struct efi_file_handle *file,
struct efi_file_handle **new_handle,
- s16 *file_name, u64 open_mode, u64 attributes)
+ u16 *file_name, u64 open_mode, u64 attributes)
{
struct file_handle *fh = to_fh(file);
efi_status_t ret;
@@ -375,7 +379,7 @@ static efi_status_t dir_read(struct file_handle *fh, u64 *buffer_size,
if (dent->type == FS_DT_DIR)
info->attribute |= EFI_FILE_DIRECTORY;
- ascii2unicode((u16 *)info->file_name, dent->name);
+ ascii2unicode(info->file_name, dent->name);
fh->offset++;
@@ -666,7 +670,7 @@ struct efi_file_handle *efi_file_from_path(struct efi_device_path *fp)
return NULL;
}
- EFI_CALL(ret = f->open(f, &f2, (s16 *)fdp->str,
+ EFI_CALL(ret = f->open(f, &f2, fdp->str,
EFI_FILE_MODE_READ, 0));
if (ret != EFI_SUCCESS)
return NULL;
diff --git a/lib/efi_loader/efi_freestanding.c b/lib/efi_loader/efi_freestanding.c
new file mode 100644
index 0000000000..bd9da5bbc8
--- /dev/null
+++ b/lib/efi_loader/efi_freestanding.c
@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Library for freestanding binary
+ *
+ * Copyright 2019, Heinrich Schuchardt <xypron.glpk@gmx.de>
+ *
+ * GCC requires that freestanding programs provide memcpy(), memmove(),
+ * memset(), and memcmp().
+ */
+
+#include <common.h>
+
+/**
+ * memcmp() - compare memory areas
+ *
+ * @s1: pointer to first area
+ * @s2: pointer to second area
+ * @n: number of bytes to compare
+ * Return: 0 if both memory areas are the same, otherwise the sign of the
+ * result value is the same as the sign of the difference between
+ * the first differing pair of bytes taken as u8.
+ */
+int memcmp(const void *s1, const void *s2, size_t n)
+{
+ const u8 *pos1 = s1;
+ const u8 *pos2 = s2;
+
+ for (; n; --n) {
+ if (*pos1 != *pos2)
+ return *pos1 - *pos2;
+ ++pos1;
+ ++pos2;
+ }
+ return 0;
+}
+
+/**
+ * memcpy() - copy memory area
+ *
+ * @dest: destination buffer
+ * @src: source buffer
+ * @n: number of bytes to copy
+ * Return: pointer to destination buffer
+ */
+void *memmove(void *dest, const void *src, size_t n)
+{
+ u8 *d = dest;
+ const u8 *s = src;
+
+ if (d >= s) {
+ for (; n; --n)
+ *d++ = *s++;
+ } else {
+ d += n;
+ s += n;
+ for (; n; --n)
+ *--d = *--s;
+ }
+ return dest;
+}
+
+/**
+ * memcpy() - copy memory area
+ *
+ * @dest: destination buffer
+ * @src: source buffer
+ * @n: number of bytes to copy
+ * Return: pointer to destination buffer
+ */
+void *memcpy(void *dest, const void *src, size_t n)
+{
+ return memmove(dest, src, n);
+}
+
+/**
+ * memset() - fill memory with a constant byte
+ *
+ * @s: destination buffer
+ * @c: byte value
+ * @n: number of bytes to set
+ * Return: pointer to destination buffer
+ */
+void *memset(void *s, int c, size_t n)
+{
+ u8 *d = s;
+
+ for (; n; --n)
+ *d++ = c;
+ return s;
+}
diff --git a/lib/efi_loader/efi_hii.c b/lib/efi_loader/efi_hii.c
new file mode 100644
index 0000000000..d63d2d8418
--- /dev/null
+++ b/lib/efi_loader/efi_hii.c
@@ -0,0 +1,1095 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * EFI Human Interface Infrastructure ... database and packages
+ *
+ * Copyright (c) 2017 Leif Lindholm
+ * Copyright (c) 2018 AKASHI Takahiro, Linaro Limited
+ */
+
+#include <common.h>
+#include <efi_loader.h>
+#include <malloc.h>
+#include <asm/unaligned.h>
+
+const efi_guid_t efi_guid_hii_database_protocol
+ = EFI_HII_DATABASE_PROTOCOL_GUID;
+const efi_guid_t efi_guid_hii_string_protocol = EFI_HII_STRING_PROTOCOL_GUID;
+
+static LIST_HEAD(efi_package_lists);
+static LIST_HEAD(efi_keyboard_layout_list);
+
+struct efi_hii_packagelist {
+ struct list_head link;
+ // TODO should there be an associated efi_object?
+ efi_handle_t driver_handle;
+ u32 max_string_id;
+ struct list_head string_tables; /* list of efi_string_table */
+ struct list_head guid_list;
+ struct list_head keyboard_packages;
+
+ /* we could also track fonts, images, etc */
+};
+
+static int efi_hii_packagelist_exists(efi_hii_handle_t package_list)
+{
+ struct efi_hii_packagelist *hii;
+ int found = 0;
+
+ list_for_each_entry(hii, &efi_package_lists, link) {
+ if (hii == package_list) {
+ found = 1;
+ break;
+ }
+ }
+
+ return found;
+}
+
+static u32 efi_hii_package_type(struct efi_hii_package_header *header)
+{
+ u32 fields;
+
+ fields = get_unaligned_le32(&header->fields);
+
+ return (fields >> __EFI_HII_PACKAGE_TYPE_SHIFT)
+ & __EFI_HII_PACKAGE_TYPE_MASK;
+}
+
+static u32 efi_hii_package_len(struct efi_hii_package_header *header)
+{
+ u32 fields;
+
+ fields = get_unaligned_le32(&header->fields);
+
+ return (fields >> __EFI_HII_PACKAGE_LEN_SHIFT)
+ & __EFI_HII_PACKAGE_LEN_MASK;
+}
+
+struct efi_string_info {
+ efi_string_t string;
+ /* we could also track font info, etc */
+};
+
+struct efi_string_table {
+ struct list_head link;
+ efi_string_id_t language_name;
+ char *language;
+ u32 nstrings;
+ /*
+ * NOTE:
+ * string id starts at 1 so value is stbl->strings[id-1],
+ * and strings[] is a array of stbl->nstrings elements
+ */
+ struct efi_string_info *strings;
+};
+
+struct efi_guid_data {
+ struct list_head link;
+ struct efi_hii_guid_package package;
+};
+
+struct efi_keyboard_layout_data {
+ struct list_head link; /* in package */
+ struct list_head link_sys; /* in global list */
+ struct efi_hii_keyboard_layout keyboard_layout;
+};
+
+struct efi_keyboard_package_data {
+ struct list_head link; /* in package_list */
+ struct list_head keyboard_layout_list;
+};
+
+static void free_strings_table(struct efi_string_table *stbl)
+{
+ int i;
+
+ for (i = 0; i < stbl->nstrings; i++)
+ free(stbl->strings[i].string);
+ free(stbl->strings);
+ free(stbl->language);
+ free(stbl);
+}
+
+static void remove_strings_package(struct efi_hii_packagelist *hii)
+{
+ while (!list_empty(&hii->string_tables)) {
+ struct efi_string_table *stbl;
+
+ stbl = list_first_entry(&hii->string_tables,
+ struct efi_string_table, link);
+ list_del(&stbl->link);
+ free_strings_table(stbl);
+ }
+}
+
+static efi_status_t
+add_strings_package(struct efi_hii_packagelist *hii,
+ struct efi_hii_strings_package *strings_package)
+{
+ struct efi_hii_string_block *block;
+ void *end;
+ u32 nstrings = 0, idx = 0;
+ struct efi_string_table *stbl = NULL;
+ efi_status_t ret;
+
+ EFI_PRINT("header_size: %08x\n",
+ get_unaligned_le32(&strings_package->header_size));
+ EFI_PRINT("string_info_offset: %08x\n",
+ get_unaligned_le32(&strings_package->string_info_offset));
+ EFI_PRINT("language_name: %u\n",
+ get_unaligned_le16(&strings_package->language_name));
+ EFI_PRINT("language: %s\n", strings_package->language);
+
+ /* count # of string entries: */
+ end = ((void *)strings_package)
+ + efi_hii_package_len(&strings_package->header);
+ block = ((void *)strings_package)
+ + get_unaligned_le32(&strings_package->string_info_offset);
+
+ while ((void *)block < end) {
+ switch (block->block_type) {
+ case EFI_HII_SIBT_STRING_UCS2: {
+ struct efi_hii_sibt_string_ucs2_block *ucs2;
+
+ ucs2 = (void *)block;
+ nstrings++;
+ block = efi_hii_sibt_string_ucs2_block_next(ucs2);
+ break;
+ }
+ case EFI_HII_SIBT_END:
+ block = end;
+ break;
+ default:
+ EFI_PRINT("unknown HII string block type: %02x\n",
+ block->block_type);
+ return EFI_INVALID_PARAMETER;
+ }
+ }
+
+ stbl = calloc(sizeof(*stbl), 1);
+ if (!stbl) {
+ ret = EFI_OUT_OF_RESOURCES;
+ goto error;
+ }
+ stbl->strings = calloc(sizeof(stbl->strings[0]), nstrings);
+ if (!stbl->strings) {
+ ret = EFI_OUT_OF_RESOURCES;
+ goto error;
+ }
+ stbl->language_name =
+ get_unaligned_le16(&strings_package->language_name);
+ stbl->language = strdup((char *)strings_package->language);
+ if (!stbl->language) {
+ ret = EFI_OUT_OF_RESOURCES;
+ goto error;
+ }
+ stbl->nstrings = nstrings;
+
+ /* and now parse string entries and populate efi_string_table */
+ block = ((void *)strings_package)
+ + get_unaligned_le32(&strings_package->string_info_offset);
+
+ while ((void *)block < end) {
+ switch (block->block_type) {
+ case EFI_HII_SIBT_STRING_UCS2: {
+ struct efi_hii_sibt_string_ucs2_block *ucs2;
+
+ ucs2 = (void *)block;
+ EFI_PRINT("%4u: \"%ls\"\n", idx + 1, ucs2->string_text);
+ stbl->strings[idx].string =
+ u16_strdup(ucs2->string_text);
+ if (!stbl->strings[idx].string) {
+ ret = EFI_OUT_OF_RESOURCES;
+ goto error;
+ }
+ idx++;
+ /* FIXME: accessing u16 * here */
+ block = efi_hii_sibt_string_ucs2_block_next(ucs2);
+ break;
+ }
+ case EFI_HII_SIBT_END:
+ goto out;
+ default:
+ EFI_PRINT("unknown HII string block type: %02x\n",
+ block->block_type);
+ ret = EFI_INVALID_PARAMETER;
+ goto error;
+ }
+ }
+
+out:
+ list_add(&stbl->link, &hii->string_tables);
+ if (hii->max_string_id < nstrings)
+ hii->max_string_id = nstrings;
+
+ return EFI_SUCCESS;
+
+error:
+ if (stbl) {
+ free(stbl->language);
+ if (idx > 0)
+ while (--idx >= 0)
+ free(stbl->strings[idx].string);
+ free(stbl->strings);
+ }
+ free(stbl);
+
+ return ret;
+}
+
+static void remove_guid_package(struct efi_hii_packagelist *hii)
+{
+ struct efi_guid_data *data;
+
+ while (!list_empty(&hii->guid_list)) {
+ data = list_first_entry(&hii->guid_list,
+ struct efi_guid_data, link);
+ list_del(&data->link);
+ free(data);
+ }
+}
+
+static efi_status_t
+add_guid_package(struct efi_hii_packagelist *hii,
+ struct efi_hii_guid_package *package)
+{
+ struct efi_guid_data *data;
+
+ data = calloc(sizeof(*data), 1);
+ if (!data)
+ return EFI_OUT_OF_RESOURCES;
+
+ /* TODO: we don't know any about data field */
+ memcpy(&data->package, package, sizeof(*package));
+ list_add_tail(&data->link, &hii->guid_list);
+
+ return EFI_SUCCESS;
+}
+
+static void free_keyboard_layouts(struct efi_keyboard_package_data *package)
+{
+ struct efi_keyboard_layout_data *layout_data;
+
+ while (!list_empty(&package->keyboard_layout_list)) {
+ layout_data = list_first_entry(&package->keyboard_layout_list,
+ struct efi_keyboard_layout_data,
+ link);
+ list_del(&layout_data->link);
+ list_del(&layout_data->link_sys);
+ free(layout_data);
+ }
+}
+
+static void remove_keyboard_package(struct efi_hii_packagelist *hii)
+{
+ struct efi_keyboard_package_data *package;
+
+ while (!list_empty(&hii->keyboard_packages)) {
+ package = list_first_entry(&hii->keyboard_packages,
+ struct efi_keyboard_package_data,
+ link);
+ free_keyboard_layouts(package);
+ list_del(&package->link);
+ free(package);
+ }
+}
+
+static efi_status_t
+add_keyboard_package(struct efi_hii_packagelist *hii,
+ struct efi_hii_keyboard_package *keyboard_package)
+{
+ struct efi_keyboard_package_data *package_data;
+ struct efi_hii_keyboard_layout *layout;
+ struct efi_keyboard_layout_data *layout_data;
+ u16 layout_count, layout_length;
+ int i;
+
+ package_data = malloc(sizeof(*package_data));
+ if (!package_data)
+ return EFI_OUT_OF_RESOURCES;
+ INIT_LIST_HEAD(&package_data->link);
+ INIT_LIST_HEAD(&package_data->keyboard_layout_list);
+
+ layout = &keyboard_package->layout[0];
+ layout_count = get_unaligned_le16(&keyboard_package->layout_count);
+ for (i = 0; i < layout_count; i++) {
+ layout_length = get_unaligned_le16(&layout->layout_length);
+ layout_data = malloc(sizeof(*layout_data) + layout_length);
+ if (!layout_data)
+ goto out;
+
+ memcpy(&layout_data->keyboard_layout, layout, layout_length);
+ list_add_tail(&layout_data->link,
+ &package_data->keyboard_layout_list);
+ list_add_tail(&layout_data->link_sys,
+ &efi_keyboard_layout_list);
+
+ layout += layout_length;
+ }
+
+ list_add_tail(&package_data->link, &hii->keyboard_packages);
+
+ return EFI_SUCCESS;
+
+out:
+ free_keyboard_layouts(package_data);
+ free(package_data);
+
+ return EFI_OUT_OF_RESOURCES;
+}
+
+static struct efi_hii_packagelist *new_packagelist(void)
+{
+ struct efi_hii_packagelist *hii;
+
+ hii = malloc(sizeof(*hii));
+ hii->max_string_id = 0;
+ INIT_LIST_HEAD(&hii->string_tables);
+ INIT_LIST_HEAD(&hii->guid_list);
+ INIT_LIST_HEAD(&hii->keyboard_packages);
+
+ return hii;
+}
+
+static void free_packagelist(struct efi_hii_packagelist *hii)
+{
+ remove_strings_package(hii);
+ remove_guid_package(hii);
+ remove_keyboard_package(hii);
+
+ list_del(&hii->link);
+ free(hii);
+}
+
+static efi_status_t
+add_packages(struct efi_hii_packagelist *hii,
+ const struct efi_hii_package_list_header *package_list)
+{
+ struct efi_hii_package_header *package;
+ void *end;
+ efi_status_t ret = EFI_SUCCESS;
+
+ end = ((void *)package_list)
+ + get_unaligned_le32(&package_list->package_length);
+
+ EFI_PRINT("package_list: %pUl (%u)\n", &package_list->package_list_guid,
+ get_unaligned_le32(&package_list->package_length));
+
+ package = ((void *)package_list) + sizeof(*package_list);
+ while ((void *)package < end) {
+ EFI_PRINT("package=%p, package type=%x, length=%u\n", package,
+ efi_hii_package_type(package),
+ efi_hii_package_len(package));
+
+ switch (efi_hii_package_type(package)) {
+ case EFI_HII_PACKAGE_TYPE_GUID:
+ ret = add_guid_package(hii,
+ (struct efi_hii_guid_package *)package);
+ break;
+ case EFI_HII_PACKAGE_FORMS:
+ printf("\tForm package not supported\n");
+ ret = EFI_INVALID_PARAMETER;
+ break;
+ case EFI_HII_PACKAGE_STRINGS:
+ ret = add_strings_package(hii,
+ (struct efi_hii_strings_package *)package);
+ break;
+ case EFI_HII_PACKAGE_FONTS:
+ printf("\tFont package not supported\n");
+ ret = EFI_INVALID_PARAMETER;
+ break;
+ case EFI_HII_PACKAGE_IMAGES:
+ printf("\tImage package not supported\n");
+ ret = EFI_INVALID_PARAMETER;
+ break;
+ case EFI_HII_PACKAGE_SIMPLE_FONTS:
+ printf("\tSimple font package not supported\n");
+ ret = EFI_INVALID_PARAMETER;
+ break;
+ case EFI_HII_PACKAGE_DEVICE_PATH:
+ printf("\tDevice path package not supported\n");
+ ret = EFI_INVALID_PARAMETER;
+ break;
+ case EFI_HII_PACKAGE_KEYBOARD_LAYOUT:
+ ret = add_keyboard_package(hii,
+ (struct efi_hii_keyboard_package *)package);
+ break;
+ case EFI_HII_PACKAGE_ANIMATIONS:
+ printf("\tAnimation package not supported\n");
+ ret = EFI_INVALID_PARAMETER;
+ break;
+ case EFI_HII_PACKAGE_END:
+ goto out;
+ case EFI_HII_PACKAGE_TYPE_SYSTEM_BEGIN:
+ case EFI_HII_PACKAGE_TYPE_SYSTEM_END:
+ default:
+ break;
+ }
+
+ if (ret != EFI_SUCCESS)
+ return ret;
+
+ package = (void *)package + efi_hii_package_len(package);
+ }
+out:
+ // TODO in theory there is some notifications that should be sent..
+ return EFI_SUCCESS;
+}
+
+/*
+ * EFI_HII_DATABASE_PROTOCOL
+ */
+
+static efi_status_t EFIAPI
+new_package_list(const struct efi_hii_database_protocol *this,
+ const struct efi_hii_package_list_header *package_list,
+ const efi_handle_t driver_handle,
+ efi_hii_handle_t *handle)
+{
+ struct efi_hii_packagelist *hii;
+ efi_status_t ret;
+
+ EFI_ENTRY("%p, %p, %p, %p", this, package_list, driver_handle, handle);
+
+ if (!package_list || !handle)
+ return EFI_EXIT(EFI_INVALID_PARAMETER);
+
+ hii = new_packagelist();
+ if (!hii)
+ return EFI_EXIT(EFI_OUT_OF_RESOURCES);
+
+ ret = add_packages(hii, package_list);
+ if (ret != EFI_SUCCESS) {
+ free_packagelist(hii);
+ return EFI_EXIT(ret);
+ }
+
+ hii->driver_handle = driver_handle;
+ list_add_tail(&hii->link, &efi_package_lists);
+ *handle = hii;
+
+ return EFI_EXIT(EFI_SUCCESS);
+}
+
+static efi_status_t EFIAPI
+remove_package_list(const struct efi_hii_database_protocol *this,
+ efi_hii_handle_t handle)
+{
+ struct efi_hii_packagelist *hii = handle;
+
+ EFI_ENTRY("%p, %p", this, handle);
+
+ if (!handle || !efi_hii_packagelist_exists(handle))
+ return EFI_EXIT(EFI_NOT_FOUND);
+
+ free_packagelist(hii);
+
+ return EFI_EXIT(EFI_SUCCESS);
+}
+
+static efi_status_t EFIAPI
+update_package_list(const struct efi_hii_database_protocol *this,
+ efi_hii_handle_t handle,
+ const struct efi_hii_package_list_header *package_list)
+{
+ struct efi_hii_packagelist *hii = handle;
+ struct efi_hii_package_header *package;
+ void *end;
+ efi_status_t ret = EFI_SUCCESS;
+
+ EFI_ENTRY("%p, %p, %p", this, handle, package_list);
+
+ if (!handle || !efi_hii_packagelist_exists(handle))
+ return EFI_EXIT(EFI_NOT_FOUND);
+
+ if (!package_list)
+ return EFI_EXIT(EFI_INVALID_PARAMETER);
+
+ EFI_PRINT("package_list: %pUl (%u)\n", &package_list->package_list_guid,
+ get_unaligned_le32(&package_list->package_length));
+
+ package = ((void *)package_list) + sizeof(*package_list);
+ end = ((void *)package_list)
+ + get_unaligned_le32(&package_list->package_length);
+
+ while ((void *)package < end) {
+ EFI_PRINT("package=%p, package type=%x, length=%u\n", package,
+ efi_hii_package_type(package),
+ efi_hii_package_len(package));
+
+ switch (efi_hii_package_type(package)) {
+ case EFI_HII_PACKAGE_TYPE_GUID:
+ remove_guid_package(hii);
+ break;
+ case EFI_HII_PACKAGE_FORMS:
+ printf("\tForm package not supported\n");
+ ret = EFI_INVALID_PARAMETER;
+ break;
+ case EFI_HII_PACKAGE_STRINGS:
+ remove_strings_package(hii);
+ break;
+ case EFI_HII_PACKAGE_FONTS:
+ printf("\tFont package not supported\n");
+ ret = EFI_INVALID_PARAMETER;
+ break;
+ case EFI_HII_PACKAGE_IMAGES:
+ printf("\tImage package not supported\n");
+ ret = EFI_INVALID_PARAMETER;
+ break;
+ case EFI_HII_PACKAGE_SIMPLE_FONTS:
+ printf("\tSimple font package not supported\n");
+ ret = EFI_INVALID_PARAMETER;
+ break;
+ case EFI_HII_PACKAGE_DEVICE_PATH:
+ printf("\tDevice path package not supported\n");
+ ret = EFI_INVALID_PARAMETER;
+ break;
+ case EFI_HII_PACKAGE_KEYBOARD_LAYOUT:
+ remove_keyboard_package(hii);
+ break;
+ case EFI_HII_PACKAGE_ANIMATIONS:
+ printf("\tAnimation package not supported\n");
+ ret = EFI_INVALID_PARAMETER;
+ break;
+ case EFI_HII_PACKAGE_END:
+ goto out;
+ case EFI_HII_PACKAGE_TYPE_SYSTEM_BEGIN:
+ case EFI_HII_PACKAGE_TYPE_SYSTEM_END:
+ default:
+ break;
+ }
+
+ /* TODO: already removed some packages */
+ if (ret != EFI_SUCCESS)
+ return EFI_EXIT(ret);
+
+ package = ((void *)package)
+ + efi_hii_package_len(package);
+ }
+out:
+ ret = add_packages(hii, package_list);
+
+ return EFI_EXIT(ret);
+}
+
+static efi_status_t EFIAPI
+list_package_lists(const struct efi_hii_database_protocol *this,
+ u8 package_type,
+ const efi_guid_t *package_guid,
+ efi_uintn_t *handle_buffer_length,
+ efi_hii_handle_t *handle)
+{
+ struct efi_hii_packagelist *hii =
+ (struct efi_hii_packagelist *)handle;
+ int package_cnt, package_max;
+ efi_status_t ret = EFI_SUCCESS;
+
+ EFI_ENTRY("%p, %u, %pUl, %p, %p", this, package_type, package_guid,
+ handle_buffer_length, handle);
+
+ if (!handle_buffer_length ||
+ (*handle_buffer_length && !handle))
+ return EFI_EXIT(EFI_INVALID_PARAMETER);
+
+ if ((package_type != EFI_HII_PACKAGE_TYPE_GUID && package_guid) ||
+ (package_type == EFI_HII_PACKAGE_TYPE_GUID && !package_guid))
+ return EFI_EXIT(EFI_INVALID_PARAMETER);
+
+ EFI_PRINT("package type=%x, guid=%pUl, length=%zu\n", (int)package_type,
+ package_guid, *handle_buffer_length);
+
+ package_cnt = 0;
+ package_max = *handle_buffer_length / sizeof(*handle);
+ list_for_each_entry(hii, &efi_package_lists, link) {
+ switch (package_type) {
+ case EFI_HII_PACKAGE_TYPE_ALL:
+ break;
+ case EFI_HII_PACKAGE_TYPE_GUID:
+ if (!list_empty(&hii->guid_list))
+ break;
+ continue;
+ case EFI_HII_PACKAGE_FORMS:
+ printf("\tForm package not supported\n");
+ ret = EFI_INVALID_PARAMETER;
+ continue;
+ case EFI_HII_PACKAGE_STRINGS:
+ if (!list_empty(&hii->string_tables))
+ break;
+ continue;
+ case EFI_HII_PACKAGE_FONTS:
+ printf("\tFont package not supported\n");
+ ret = EFI_INVALID_PARAMETER;
+ continue;
+ case EFI_HII_PACKAGE_IMAGES:
+ printf("\tImage package not supported\n");
+ ret = EFI_INVALID_PARAMETER;
+ continue;
+ case EFI_HII_PACKAGE_SIMPLE_FONTS:
+ printf("\tSimple font package not supported\n");
+ ret = EFI_INVALID_PARAMETER;
+ continue;
+ case EFI_HII_PACKAGE_DEVICE_PATH:
+ printf("\tDevice path package not supported\n");
+ ret = EFI_INVALID_PARAMETER;
+ continue;
+ case EFI_HII_PACKAGE_KEYBOARD_LAYOUT:
+ if (!list_empty(&hii->keyboard_packages))
+ break;
+ continue;
+ case EFI_HII_PACKAGE_ANIMATIONS:
+ printf("\tAnimation package not supported\n");
+ ret = EFI_INVALID_PARAMETER;
+ continue;
+ case EFI_HII_PACKAGE_END:
+ case EFI_HII_PACKAGE_TYPE_SYSTEM_BEGIN:
+ case EFI_HII_PACKAGE_TYPE_SYSTEM_END:
+ default:
+ continue;
+ }
+
+ package_cnt++;
+ if (package_cnt <= package_max)
+ *handle++ = hii;
+ else
+ ret = EFI_BUFFER_TOO_SMALL;
+ }
+ *handle_buffer_length = package_cnt * sizeof(*handle);
+
+ return EFI_EXIT(ret);
+}
+
+static efi_status_t EFIAPI
+export_package_lists(const struct efi_hii_database_protocol *this,
+ efi_hii_handle_t handle,
+ efi_uintn_t *buffer_size,
+ struct efi_hii_package_list_header *buffer)
+{
+ EFI_ENTRY("%p, %p, %p, %p", this, handle, buffer_size, buffer);
+
+ if (!buffer_size || !buffer)
+ return EFI_EXIT(EFI_INVALID_PARAMETER);
+
+ return EFI_EXIT(EFI_NOT_FOUND);
+}
+
+static efi_status_t EFIAPI
+register_package_notify(const struct efi_hii_database_protocol *this,
+ u8 package_type,
+ const efi_guid_t *package_guid,
+ const void *package_notify_fn,
+ efi_uintn_t notify_type,
+ efi_handle_t *notify_handle)
+{
+ EFI_ENTRY("%p, %u, %pUl, %p, %zu, %p", this, package_type,
+ package_guid, package_notify_fn, notify_type,
+ notify_handle);
+
+ if (!notify_handle)
+ return EFI_EXIT(EFI_INVALID_PARAMETER);
+
+ if ((package_type != EFI_HII_PACKAGE_TYPE_GUID && package_guid) ||
+ (package_type == EFI_HII_PACKAGE_TYPE_GUID && !package_guid))
+ return EFI_EXIT(EFI_INVALID_PARAMETER);
+
+ return EFI_EXIT(EFI_OUT_OF_RESOURCES);
+}
+
+static efi_status_t EFIAPI
+unregister_package_notify(const struct efi_hii_database_protocol *this,
+ efi_handle_t notification_handle)
+{
+ EFI_ENTRY("%p, %p", this, notification_handle);
+
+ return EFI_EXIT(EFI_NOT_FOUND);
+}
+
+static efi_status_t EFIAPI
+find_keyboard_layouts(const struct efi_hii_database_protocol *this,
+ u16 *key_guid_buffer_length,
+ efi_guid_t *key_guid_buffer)
+{
+ struct efi_keyboard_layout_data *layout_data;
+ int package_cnt, package_max;
+ efi_status_t ret = EFI_SUCCESS;
+
+ EFI_ENTRY("%p, %p, %p", this, key_guid_buffer_length, key_guid_buffer);
+
+ if (!key_guid_buffer_length ||
+ (*key_guid_buffer_length && !key_guid_buffer))
+ return EFI_EXIT(EFI_INVALID_PARAMETER);
+
+ package_cnt = 0;
+ package_max = *key_guid_buffer_length / sizeof(*key_guid_buffer);
+ list_for_each_entry(layout_data, &efi_keyboard_layout_list, link_sys) {
+ package_cnt++;
+ if (package_cnt <= package_max)
+ memcpy(key_guid_buffer++,
+ &layout_data->keyboard_layout.guid,
+ sizeof(*key_guid_buffer));
+ else
+ ret = EFI_BUFFER_TOO_SMALL;
+ }
+ *key_guid_buffer_length = package_cnt * sizeof(*key_guid_buffer);
+
+ return EFI_EXIT(ret);
+}
+
+static efi_status_t EFIAPI
+get_keyboard_layout(const struct efi_hii_database_protocol *this,
+ efi_guid_t *key_guid,
+ u16 *keyboard_layout_length,
+ struct efi_hii_keyboard_layout *keyboard_layout)
+{
+ struct efi_keyboard_layout_data *layout_data;
+ u16 layout_length;
+
+ EFI_ENTRY("%p, %pUl, %p, %p", this, key_guid, keyboard_layout_length,
+ keyboard_layout);
+
+ if (!keyboard_layout_length ||
+ (*keyboard_layout_length && !keyboard_layout))
+ return EFI_EXIT(EFI_INVALID_PARAMETER);
+
+ /* TODO: no notion of current keyboard layout */
+ if (!key_guid)
+ return EFI_EXIT(EFI_INVALID_PARAMETER);
+
+ list_for_each_entry(layout_data, &efi_keyboard_layout_list, link_sys) {
+ if (!guidcmp(&layout_data->keyboard_layout.guid, key_guid))
+ goto found;
+ }
+
+ return EFI_EXIT(EFI_NOT_FOUND);
+
+found:
+ layout_length =
+ get_unaligned_le16(&layout_data->keyboard_layout.layout_length);
+ if (*keyboard_layout_length < layout_length) {
+ *keyboard_layout_length = layout_length;
+ return EFI_EXIT(EFI_BUFFER_TOO_SMALL);
+ }
+
+ memcpy(keyboard_layout, &layout_data->keyboard_layout, layout_length);
+
+ return EFI_EXIT(EFI_SUCCESS);
+}
+
+static efi_status_t EFIAPI
+set_keyboard_layout(const struct efi_hii_database_protocol *this,
+ efi_guid_t *key_guid)
+{
+ EFI_ENTRY("%p, %pUl", this, key_guid);
+
+ return EFI_EXIT(EFI_NOT_FOUND);
+}
+
+static efi_status_t EFIAPI
+get_package_list_handle(const struct efi_hii_database_protocol *this,
+ efi_hii_handle_t package_list_handle,
+ efi_handle_t *driver_handle)
+{
+ struct efi_hii_packagelist *hii;
+
+ EFI_ENTRY("%p, %p, %p", this, package_list_handle, driver_handle);
+
+ if (!driver_handle)
+ return EFI_EXIT(EFI_INVALID_PARAMETER);
+
+ list_for_each_entry(hii, &efi_package_lists, link) {
+ if (hii == package_list_handle) {
+ *driver_handle = hii->driver_handle;
+ return EFI_EXIT(EFI_SUCCESS);
+ }
+ }
+
+ return EFI_EXIT(EFI_NOT_FOUND);
+}
+
+const struct efi_hii_database_protocol efi_hii_database = {
+ .new_package_list = new_package_list,
+ .remove_package_list = remove_package_list,
+ .update_package_list = update_package_list,
+ .list_package_lists = list_package_lists,
+ .export_package_lists = export_package_lists,
+ .register_package_notify = register_package_notify,
+ .unregister_package_notify = unregister_package_notify,
+ .find_keyboard_layouts = find_keyboard_layouts,
+ .get_keyboard_layout = get_keyboard_layout,
+ .set_keyboard_layout = set_keyboard_layout,
+ .get_package_list_handle = get_package_list_handle
+};
+
+/*
+ * EFI_HII_STRING_PROTOCOL
+ */
+
+static bool language_match(char *language, char *languages)
+{
+ size_t n;
+
+ n = strlen(language);
+ /* match primary language? */
+ if (!strncasecmp(language, languages, n) &&
+ (languages[n] == ';' || languages[n] == '\0'))
+ return true;
+
+ return false;
+}
+
+static efi_status_t EFIAPI
+new_string(const struct efi_hii_string_protocol *this,
+ efi_hii_handle_t package_list,
+ efi_string_id_t *string_id,
+ const u8 *language,
+ const u16 *language_name,
+ const efi_string_t string,
+ const struct efi_font_info *string_font_info)
+{
+ struct efi_hii_packagelist *hii = package_list;
+ struct efi_string_table *stbl;
+
+ EFI_ENTRY("%p, %p, %p, \"%s\", %p, \"%ls\", %p", this, package_list,
+ string_id, language, language_name, string,
+ string_font_info);
+
+ if (!package_list || !efi_hii_packagelist_exists(package_list))
+ return EFI_EXIT(EFI_NOT_FOUND);
+
+ if (!string_id || !language || !string)
+ return EFI_EXIT(EFI_INVALID_PARAMETER);
+
+ list_for_each_entry(stbl, &hii->string_tables, link) {
+ if (language_match((char *)language, stbl->language)) {
+ efi_string_id_t new_id;
+ void *buf;
+ efi_string_t str;
+
+ new_id = ++hii->max_string_id;
+ if (stbl->nstrings < new_id) {
+ buf = realloc(stbl->strings,
+ sizeof(stbl->strings[0])
+ * new_id);
+ if (!buf)
+ return EFI_EXIT(EFI_OUT_OF_RESOURCES);
+
+ memset(&stbl->strings[stbl->nstrings], 0,
+ (new_id - stbl->nstrings)
+ * sizeof(stbl->strings[0]));
+ stbl->strings = buf;
+ stbl->nstrings = new_id;
+ }
+
+ str = u16_strdup(string);
+ if (!str)
+ return EFI_EXIT(EFI_OUT_OF_RESOURCES);
+
+ stbl->strings[new_id - 1].string = str;
+ *string_id = new_id;
+
+ return EFI_EXIT(EFI_SUCCESS);
+ }
+ }
+
+ return EFI_EXIT(EFI_NOT_FOUND);
+}
+
+static efi_status_t EFIAPI
+get_string(const struct efi_hii_string_protocol *this,
+ const u8 *language,
+ efi_hii_handle_t package_list,
+ efi_string_id_t string_id,
+ efi_string_t string,
+ efi_uintn_t *string_size,
+ struct efi_font_info **string_font_info)
+{
+ struct efi_hii_packagelist *hii = package_list;
+ struct efi_string_table *stbl;
+
+ EFI_ENTRY("%p, \"%s\", %p, %u, %p, %p, %p", this, language,
+ package_list, string_id, string, string_size,
+ string_font_info);
+
+ if (!package_list || !efi_hii_packagelist_exists(package_list))
+ return EFI_EXIT(EFI_NOT_FOUND);
+
+ list_for_each_entry(stbl, &hii->string_tables, link) {
+ if (language_match((char *)language, stbl->language)) {
+ efi_string_t str;
+ size_t len;
+
+ if (stbl->nstrings < string_id)
+ return EFI_EXIT(EFI_NOT_FOUND);
+
+ str = stbl->strings[string_id - 1].string;
+ if (str) {
+ len = (u16_strlen(str) + 1) * sizeof(u16);
+ if (*string_size < len) {
+ *string_size = len;
+
+ return EFI_EXIT(EFI_BUFFER_TOO_SMALL);
+ }
+ memcpy(string, str, len);
+ *string_size = len;
+ } else {
+ return EFI_EXIT(EFI_NOT_FOUND);
+ }
+
+ return EFI_EXIT(EFI_SUCCESS);
+ }
+ }
+
+ return EFI_EXIT(EFI_NOT_FOUND);
+}
+
+static efi_status_t EFIAPI
+set_string(const struct efi_hii_string_protocol *this,
+ efi_hii_handle_t package_list,
+ efi_string_id_t string_id,
+ const u8 *language,
+ const efi_string_t string,
+ const struct efi_font_info *string_font_info)
+{
+ struct efi_hii_packagelist *hii = package_list;
+ struct efi_string_table *stbl;
+
+ EFI_ENTRY("%p, %p, %u, \"%s\", \"%ls\", %p", this, package_list,
+ string_id, language, string, string_font_info);
+
+ if (!package_list || !efi_hii_packagelist_exists(package_list))
+ return EFI_EXIT(EFI_NOT_FOUND);
+
+ if (string_id > hii->max_string_id)
+ return EFI_EXIT(EFI_NOT_FOUND);
+
+ if (!string || !language)
+ return EFI_EXIT(EFI_INVALID_PARAMETER);
+
+ list_for_each_entry(stbl, &hii->string_tables, link) {
+ if (language_match((char *)language, stbl->language)) {
+ efi_string_t str;
+
+ if (hii->max_string_id < string_id)
+ return EFI_EXIT(EFI_NOT_FOUND);
+
+ if (stbl->nstrings < string_id) {
+ void *buf;
+
+ buf = realloc(stbl->strings,
+ string_id
+ * sizeof(stbl->strings[0]));
+ if (!buf)
+ return EFI_EXIT(EFI_OUT_OF_RESOURCES);
+
+ memset(&stbl->strings[string_id - 1], 0,
+ (string_id - stbl->nstrings)
+ * sizeof(stbl->strings[0]));
+ stbl->strings = buf;
+ }
+
+ str = u16_strdup(string);
+ if (!str)
+ return EFI_EXIT(EFI_OUT_OF_RESOURCES);
+
+ free(stbl->strings[string_id - 1].string);
+ stbl->strings[string_id - 1].string = str;
+
+ return EFI_EXIT(EFI_SUCCESS);
+ }
+ }
+
+ return EFI_EXIT(EFI_NOT_FOUND);
+}
+
+static efi_status_t EFIAPI
+get_languages(const struct efi_hii_string_protocol *this,
+ efi_hii_handle_t package_list,
+ u8 *languages,
+ efi_uintn_t *languages_size)
+{
+ struct efi_hii_packagelist *hii = package_list;
+ struct efi_string_table *stbl;
+ size_t len = 0;
+ char *p;
+
+ EFI_ENTRY("%p, %p, %p, %p", this, package_list, languages,
+ languages_size);
+
+ if (!package_list || !efi_hii_packagelist_exists(package_list))
+ return EFI_EXIT(EFI_NOT_FOUND);
+
+ if (!languages_size ||
+ (*languages_size && !languages))
+ return EFI_EXIT(EFI_INVALID_PARAMETER);
+
+ /* figure out required size: */
+ list_for_each_entry(stbl, &hii->string_tables, link) {
+ len += strlen((char *)stbl->language) + 1;
+ }
+
+ if (*languages_size < len) {
+ *languages_size = len;
+
+ return EFI_EXIT(EFI_BUFFER_TOO_SMALL);
+ }
+
+ p = (char *)languages;
+ list_for_each_entry(stbl, &hii->string_tables, link) {
+ if (p != (char *)languages)
+ *p++ = ';';
+ strcpy(p, stbl->language);
+ p += strlen((char *)stbl->language);
+ }
+ *p = '\0';
+
+ EFI_PRINT("languages: %s\n", languages);
+
+ return EFI_EXIT(EFI_SUCCESS);
+}
+
+static efi_status_t EFIAPI
+get_secondary_languages(const struct efi_hii_string_protocol *this,
+ efi_hii_handle_t package_list,
+ const u8 *primary_language,
+ u8 *secondary_languages,
+ efi_uintn_t *secondary_languages_size)
+{
+ struct efi_hii_packagelist *hii = package_list;
+ struct efi_string_table *stbl;
+ bool found = false;
+
+ EFI_ENTRY("%p, %p, \"%s\", %p, %p", this, package_list,
+ primary_language, secondary_languages,
+ secondary_languages_size);
+
+ if (!package_list || !efi_hii_packagelist_exists(package_list))
+ return EFI_EXIT(EFI_NOT_FOUND);
+
+ if (!secondary_languages_size ||
+ (*secondary_languages_size && !secondary_languages))
+ return EFI_EXIT(EFI_INVALID_PARAMETER);
+
+ list_for_each_entry(stbl, &hii->string_tables, link) {
+ if (language_match((char *)primary_language, stbl->language)) {
+ found = true;
+ break;
+ }
+ }
+ if (!found)
+ return EFI_EXIT(EFI_INVALID_LANGUAGE);
+
+ /*
+ * TODO: What is secondary language?
+ * *secondary_languages = '\0';
+ * *secondary_languages_size = 0;
+ */
+
+ return EFI_EXIT(EFI_NOT_FOUND);
+}
+
+const struct efi_hii_string_protocol efi_hii_string = {
+ .new_string = new_string,
+ .get_string = get_string,
+ .set_string = set_string,
+ .get_languages = get_languages,
+ .get_secondary_languages = get_secondary_languages
+};
diff --git a/lib/efi_loader/efi_hii_config.c b/lib/efi_loader/efi_hii_config.c
new file mode 100644
index 0000000000..26ea4b9bc0
--- /dev/null
+++ b/lib/efi_loader/efi_hii_config.c
@@ -0,0 +1,146 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * EFI Human Interface Infrastructure ... Configuration
+ *
+ * Copyright (c) 2017 Leif Lindholm
+ * Copyright (c) 2018 AKASHI Takahiro, Linaro Limited
+ */
+
+#include <common.h>
+#include <efi_loader.h>
+
+const efi_guid_t efi_guid_hii_config_routing_protocol
+ = EFI_HII_CONFIG_ROUTING_PROTOCOL_GUID;
+const efi_guid_t efi_guid_hii_config_access_protocol
+ = EFI_HII_CONFIG_ACCESS_PROTOCOL_GUID;
+
+/*
+ * EFI_HII_CONFIG_ROUTING_PROTOCOL
+ */
+
+static efi_status_t EFIAPI
+extract_config(const struct efi_hii_config_routing_protocol *this,
+ const efi_string_t request,
+ efi_string_t *progress,
+ efi_string_t *results)
+{
+ EFI_ENTRY("%p, \"%ls\", %p, %p", this, request, progress, results);
+
+ return EFI_EXIT(EFI_OUT_OF_RESOURCES);
+}
+
+static efi_status_t EFIAPI
+export_config(const struct efi_hii_config_routing_protocol *this,
+ efi_string_t *results)
+{
+ EFI_ENTRY("%p, %p", this, results);
+
+ return EFI_EXIT(EFI_OUT_OF_RESOURCES);
+}
+
+static efi_status_t EFIAPI
+route_config(const struct efi_hii_config_routing_protocol *this,
+ const efi_string_t configuration,
+ efi_string_t *progress)
+{
+ EFI_ENTRY("%p, \"%ls\", %p", this, configuration, progress);
+
+ return EFI_EXIT(EFI_OUT_OF_RESOURCES);
+}
+
+static efi_status_t EFIAPI
+block_to_config(const struct efi_hii_config_routing_protocol *this,
+ const efi_string_t config_request,
+ const u8 *block,
+ const efi_uintn_t block_size,
+ efi_string_t *config,
+ efi_string_t *progress)
+{
+ EFI_ENTRY("%p, \"%ls\", %p, %zu, %p, %p", this, config_request,
+ block, block_size, config, progress);
+
+ return EFI_EXIT(EFI_OUT_OF_RESOURCES);
+}
+
+static efi_status_t EFIAPI
+config_to_block(const struct efi_hii_config_routing_protocol *this,
+ const efi_string_t config_resp,
+ const u8 *block,
+ const efi_uintn_t *block_size,
+ efi_string_t *progress)
+{
+ EFI_ENTRY("%p, \"%ls\", %p, %p, %p", this, config_resp,
+ block, block_size, progress);
+
+ return EFI_EXIT(EFI_OUT_OF_RESOURCES);
+}
+
+static efi_status_t EFIAPI
+get_alt_config(const struct efi_hii_config_routing_protocol *this,
+ const efi_string_t config_resp,
+ const efi_guid_t *guid,
+ const efi_string_t name,
+ const struct efi_device_path *device_path,
+ const efi_string_t alt_cfg_id,
+ efi_string_t *alt_cfg_resp)
+{
+ EFI_ENTRY("%p, \"%ls\", %pUl, \"%ls\", %p, \"%ls\", %p",
+ this, config_resp, guid, name, device_path,
+ alt_cfg_id, alt_cfg_resp);
+
+ return EFI_EXIT(EFI_OUT_OF_RESOURCES);
+}
+
+/*
+ * EFI_HII_ACCESS_PROTOCOL
+ */
+
+efi_status_t EFIAPI
+extract_config_access(const struct efi_hii_config_access_protocol *this,
+ const efi_string_t request,
+ efi_string_t *progress,
+ efi_string_t *results)
+{
+ EFI_ENTRY("%p, \"%ls\", %p, %p", this, request, progress, results);
+
+ return EFI_EXIT(EFI_OUT_OF_RESOURCES);
+};
+
+efi_status_t EFIAPI
+route_config_access(const struct efi_hii_config_access_protocol *this,
+ const efi_string_t configuration,
+ efi_string_t *progress)
+{
+ EFI_ENTRY("%p, \"%ls\", %p", this, configuration, progress);
+
+ return EFI_EXIT(EFI_OUT_OF_RESOURCES);
+};
+
+efi_status_t EFIAPI
+form_callback(const struct efi_hii_config_access_protocol *this,
+ efi_browser_action_t action,
+ efi_question_id_t question_id,
+ u8 type,
+ union efi_ifr_type_value *value,
+ efi_browser_action_request_t *action_request)
+{
+ EFI_ENTRY("%p, 0x%zx, 0x%x, 0x%x, %p, %p", this, action,
+ question_id, type, value, action_request);
+
+ return EFI_EXIT(EFI_DEVICE_ERROR);
+};
+
+const struct efi_hii_config_routing_protocol efi_hii_config_routing = {
+ .extract_config = extract_config,
+ .export_config = export_config,
+ .route_config = route_config,
+ .block_to_config = block_to_config,
+ .config_to_block = config_to_block,
+ .get_alt_config = get_alt_config
+};
+
+const struct efi_hii_config_access_protocol efi_hii_config_access = {
+ .extract_config_access = extract_config_access,
+ .route_config_access = route_config_access,
+ .form_callback = form_callback
+};
diff --git a/lib/efi_loader/efi_memory.c b/lib/efi_loader/efi_memory.c
index 4bb517473e..ebd2b36c03 100644
--- a/lib/efi_loader/efi_memory.c
+++ b/lib/efi_loader/efi_memory.c
@@ -554,6 +554,12 @@ __weak void efi_add_known_memory(void)
u64 ram_top = board_get_usable_ram_top(0) & ~EFI_PAGE_MASK;
int i;
+ /*
+ * ram_top is just outside mapped memory. So use an offset of one for
+ * mapping the sandbox address.
+ */
+ ram_top = (uintptr_t)map_sysmem(ram_top - 1, 0) + 1;
+
/* Fix for 32bit targets with ram_top at 4G */
if (!ram_top)
ram_top = 0x100000000ULL;
diff --git a/lib/efi_loader/efi_runtime.c b/lib/efi_loader/efi_runtime.c
index fff93f0960..636dfdab39 100644
--- a/lib/efi_loader/efi_runtime.c
+++ b/lib/efi_loader/efi_runtime.c
@@ -530,7 +530,8 @@ static efi_status_t EFIAPI efi_set_virtual_address_map(
* This function adds a memory-mapped IO region to the memory map to make it
* available at runtime.
*
- * @mmio_ptr: address of the memory-mapped IO region
+ * @mmio_ptr: pointer to a pointer to the start of the memory-mapped
+ * IO region
* @len: size of the memory-mapped IO region
* Returns: status code
*/
diff --git a/lib/efi_loader/efi_setup.c b/lib/efi_loader/efi_setup.c
new file mode 100644
index 0000000000..8266d06c2e
--- /dev/null
+++ b/lib/efi_loader/efi_setup.c
@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * EFI setup code
+ *
+ * Copyright (c) 2016-2018 Alexander Graf et al.
+ */
+
+#include <common.h>
+#include <efi_loader.h>
+
+#define OBJ_LIST_NOT_INITIALIZED 1
+
+static efi_status_t efi_obj_list_initialized = OBJ_LIST_NOT_INITIALIZED;
+
+/* Initialize and populate EFI object list */
+efi_status_t efi_init_obj_list(void)
+{
+ efi_status_t ret = EFI_SUCCESS;
+
+ /*
+ * On the ARM architecture gd is mapped to a fixed register (r9 or x18).
+ * As this register may be overwritten by an EFI payload we save it here
+ * and restore it on every callback entered.
+ */
+ efi_save_gd();
+
+ /* Initialize once only */
+ if (efi_obj_list_initialized != OBJ_LIST_NOT_INITIALIZED)
+ return efi_obj_list_initialized;
+
+ /* Initialize system table */
+ ret = efi_initialize_system_table();
+ if (ret != EFI_SUCCESS)
+ goto out;
+
+ /* Initialize root node */
+ ret = efi_root_node_register();
+ if (ret != EFI_SUCCESS)
+ goto out;
+
+ /* Initialize EFI driver uclass */
+ ret = efi_driver_init();
+ if (ret != EFI_SUCCESS)
+ goto out;
+
+ ret = efi_console_register();
+ if (ret != EFI_SUCCESS)
+ goto out;
+#ifdef CONFIG_PARTITIONS
+ ret = efi_disk_register();
+ if (ret != EFI_SUCCESS)
+ goto out;
+#endif
+#if defined(CONFIG_LCD) || defined(CONFIG_DM_VIDEO)
+ ret = efi_gop_register();
+ if (ret != EFI_SUCCESS)
+ goto out;
+#endif
+#ifdef CONFIG_NET
+ ret = efi_net_register();
+ if (ret != EFI_SUCCESS)
+ goto out;
+#endif
+#ifdef CONFIG_GENERATE_ACPI_TABLE
+ ret = efi_acpi_register();
+ if (ret != EFI_SUCCESS)
+ goto out;
+#endif
+#ifdef CONFIG_GENERATE_SMBIOS_TABLE
+ ret = efi_smbios_register();
+ if (ret != EFI_SUCCESS)
+ goto out;
+#endif
+ ret = efi_watchdog_register();
+ if (ret != EFI_SUCCESS)
+ goto out;
+
+ /* Initialize EFI runtime services */
+ ret = efi_reset_system_init();
+ if (ret != EFI_SUCCESS)
+ goto out;
+
+out:
+ efi_obj_list_initialized = ret;
+ return ret;
+}
diff --git a/lib/efi_loader/efi_variable.c b/lib/efi_loader/efi_variable.c
index 19d9cb865f..e0d7f5736d 100644
--- a/lib/efi_loader/efi_variable.c
+++ b/lib/efi_loader/efi_variable.c
@@ -8,6 +8,10 @@
#include <malloc.h>
#include <charset.h>
#include <efi_loader.h>
+#include <hexdump.h>
+#include <environment.h>
+#include <search.h>
+#include <uuid.h>
#define READ_ONLY BIT(31)
@@ -46,60 +50,21 @@
#define PREFIX_LEN (strlen("efi_xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx_"))
-static int hex(int ch)
-{
- if (ch >= 'a' && ch <= 'f')
- return ch-'a'+10;
- if (ch >= '0' && ch <= '9')
- return ch-'0';
- if (ch >= 'A' && ch <= 'F')
- return ch-'A'+10;
- return -1;
-}
-
-static int hex2mem(u8 *mem, const char *hexstr, int size)
-{
- int nibble;
- int i;
-
- for (i = 0; i < size; i++) {
- if (*hexstr == '\0')
- break;
-
- nibble = hex(*hexstr);
- if (nibble < 0)
- return -1;
-
- *mem = nibble;
- hexstr++;
-
- nibble = hex(*hexstr);
- if (nibble < 0)
- return -1;
-
- *mem = (*mem << 4) | nibble;
- hexstr++;
- mem++;
- }
-
- return i;
-}
-
-static char *mem2hex(char *hexstr, const u8 *mem, int count)
-{
- static const char hexchars[] = "0123456789abcdef";
-
- while (count-- > 0) {
- u8 ch = *mem++;
- *hexstr++ = hexchars[ch >> 4];
- *hexstr++ = hexchars[ch & 0xf];
- }
-
- return hexstr;
-}
-
+/**
+ * efi_to_native() - convert the UEFI variable name and vendor GUID to U-Boot
+ * variable name
+ *
+ * The U-Boot variable name is a concatenation of prefix 'efi', the hexstring
+ * encoded vendor GUID, and the UTF-8 encoded UEFI variable name separated by
+ * underscores, e.g. 'efi_8be4df61-93ca-11d2-aa0d-00e098032b8c_BootOrder'.
+ *
+ * @native: pointer to pointer to U-Boot variable name
+ * @variable_name: UEFI variable name
+ * @vendor: vendor GUID
+ * Return: status code
+ */
static efi_status_t efi_to_native(char **native, const u16 *variable_name,
- efi_guid_t *vendor)
+ const efi_guid_t *vendor)
{
size_t len;
char *pos;
@@ -116,6 +81,15 @@ static efi_status_t efi_to_native(char **native, const u16 *variable_name,
return EFI_SUCCESS;
}
+/**
+ * prefix() - skip over prefix
+ *
+ * Skip over a prefix string.
+ *
+ * @str: string with prefix
+ * @prefix: prefix string
+ * Return: string without prefix, or NULL if prefix not found
+ */
static const char *prefix(const char *str, const char *prefix)
{
size_t n = strlen(prefix);
@@ -124,7 +98,16 @@ static const char *prefix(const char *str, const char *prefix)
return NULL;
}
-/* parse attributes part of variable value, if present: */
+/**
+ * parse_attr() - decode attributes part of variable value
+ *
+ * Convert the string encoded attributes of a UEFI variable to a bit mask.
+ * TODO: Several attributes are not supported.
+ *
+ * @str: value of U-Boot variable
+ * @attrp: pointer to UEFI attributes
+ * Return: pointer to remainder of U-Boot variable value
+ */
static const char *parse_attr(const char *str, u32 *attrp)
{
u32 attr = 0;
@@ -162,10 +145,24 @@ static const char *parse_attr(const char *str, u32 *attrp)
return str;
}
-/* http://wiki.phoenix.com/wiki/index.php/EFI_RUNTIME_SERVICES#GetVariable.28.29 */
-efi_status_t EFIAPI efi_get_variable(u16 *variable_name, efi_guid_t *vendor,
- u32 *attributes, efi_uintn_t *data_size,
- void *data)
+/**
+ * efi_efi_get_variable() - retrieve value of a UEFI variable
+ *
+ * This function implements the GetVariable runtime service.
+ *
+ * See the Unified Extensible Firmware Interface (UEFI) specification for
+ * details.
+ *
+ * @variable_name: name of the variable
+ * @vendor: vendor GUID
+ * @attributes: attributes of the variable
+ * @data_size: size of the buffer to which the variable value is copied
+ * @data: buffer to which the variable value is copied
+ * Return: status code
+ */
+efi_status_t EFIAPI efi_get_variable(u16 *variable_name,
+ const efi_guid_t *vendor, u32 *attributes,
+ efi_uintn_t *data_size, void *data)
{
char *native_name;
efi_status_t ret;
@@ -195,7 +192,7 @@ efi_status_t EFIAPI efi_get_variable(u16 *variable_name, efi_guid_t *vendor,
in_size = *data_size;
if ((s = prefix(val, "(blob)"))) {
- unsigned len = strlen(s);
+ size_t len = strlen(s);
/* number of hexadecimal digits must be even */
if (len & 1)
@@ -211,7 +208,7 @@ efi_status_t EFIAPI efi_get_variable(u16 *variable_name, efi_guid_t *vendor,
if (!data)
return EFI_EXIT(EFI_INVALID_PARAMETER);
- if (hex2mem(data, s, len) != len)
+ if (hex2bin(data, s, len))
return EFI_EXIT(EFI_DEVICE_ERROR);
debug("%s: got value: \"%s\"\n", __func__, s);
@@ -241,20 +238,182 @@ efi_status_t EFIAPI efi_get_variable(u16 *variable_name, efi_guid_t *vendor,
return EFI_EXIT(EFI_SUCCESS);
}
-/* http://wiki.phoenix.com/wiki/index.php/EFI_RUNTIME_SERVICES#GetNextVariableName.28.29 */
+static char *efi_variables_list;
+static char *efi_cur_variable;
+
+/**
+ * parse_uboot_variable() - parse a u-boot variable and get uefi-related
+ * information
+ * @variable: whole data of u-boot variable (ie. name=value)
+ * @variable_name_size: size of variable_name buffer in byte
+ * @variable_name: name of uefi variable in u16, null-terminated
+ * @vendor: vendor's guid
+ * @attributes: attributes
+ *
+ * A uefi variable is encoded into a u-boot variable as described above.
+ * This function parses such a u-boot variable and retrieve uefi-related
+ * information into respective parameters. In return, variable_name_size
+ * is the size of variable name including NULL.
+ *
+ * Return: EFI_SUCCESS if parsing is OK, EFI_NOT_FOUND when
+ the entire variable list has been returned,
+ otherwise non-zero status code
+ */
+static efi_status_t parse_uboot_variable(char *variable,
+ efi_uintn_t *variable_name_size,
+ u16 *variable_name,
+ const efi_guid_t *vendor,
+ u32 *attributes)
+{
+ char *guid, *name, *end, c;
+ unsigned long name_len;
+ u16 *p;
+
+ guid = strchr(variable, '_');
+ if (!guid)
+ return EFI_INVALID_PARAMETER;
+ guid++;
+ name = strchr(guid, '_');
+ if (!name)
+ return EFI_INVALID_PARAMETER;
+ name++;
+ end = strchr(name, '=');
+ if (!end)
+ return EFI_INVALID_PARAMETER;
+
+ name_len = end - name;
+ if (*variable_name_size < (name_len + 1)) {
+ *variable_name_size = name_len + 1;
+ return EFI_BUFFER_TOO_SMALL;
+ }
+ end++; /* point to value */
+
+ /* variable name */
+ p = variable_name;
+ utf8_utf16_strncpy(&p, name, name_len);
+ variable_name[name_len] = 0;
+ *variable_name_size = name_len + 1;
+
+ /* guid */
+ c = *(name - 1);
+ *(name - 1) = '\0'; /* guid need be null-terminated here */
+ uuid_str_to_bin(guid, (unsigned char *)vendor, UUID_STR_FORMAT_GUID);
+ *(name - 1) = c;
+
+ /* attributes */
+ parse_attr(end, attributes);
+
+ return EFI_SUCCESS;
+}
+
+/**
+ * efi_get_next_variable_name() - enumerate the current variable names
+ * @variable_name_size: size of variable_name buffer in byte
+ * @variable_name: name of uefi variable's name in u16
+ * @vendor: vendor's guid
+ *
+ * This function implements the GetNextVariableName service.
+ *
+ * See the Unified Extensible Firmware Interface (UEFI) specification for
+ * details: http://wiki.phoenix.com/wiki/index.php/
+ * EFI_RUNTIME_SERVICES#GetNextVariableName.28.29
+ *
+ * Return: status code
+ */
efi_status_t EFIAPI efi_get_next_variable_name(efi_uintn_t *variable_name_size,
u16 *variable_name,
- efi_guid_t *vendor)
+ const efi_guid_t *vendor)
{
+ char *native_name, *variable;
+ ssize_t name_len, list_len;
+ char regex[256];
+ char * const regexlist[] = {regex};
+ u32 attributes;
+ int i;
+ efi_status_t ret;
+
EFI_ENTRY("%p \"%ls\" %pUl", variable_name_size, variable_name, vendor);
- return EFI_EXIT(EFI_DEVICE_ERROR);
+ if (!variable_name_size || !variable_name || !vendor)
+ EFI_EXIT(EFI_INVALID_PARAMETER);
+
+ if (variable_name[0]) {
+ /* check null-terminated string */
+ for (i = 0; i < *variable_name_size; i++)
+ if (!variable_name[i])
+ break;
+ if (i >= *variable_name_size)
+ return EFI_EXIT(EFI_INVALID_PARAMETER);
+
+ /* search for the last-returned variable */
+ ret = efi_to_native(&native_name, variable_name, vendor);
+ if (ret)
+ return EFI_EXIT(ret);
+
+ name_len = strlen(native_name);
+ for (variable = efi_variables_list; variable && *variable;) {
+ if (!strncmp(variable, native_name, name_len) &&
+ variable[name_len] == '=')
+ break;
+
+ variable = strchr(variable, '\n');
+ if (variable)
+ variable++;
+ }
+
+ free(native_name);
+ if (!(variable && *variable))
+ return EFI_EXIT(EFI_INVALID_PARAMETER);
+
+ /* next variable */
+ variable = strchr(variable, '\n');
+ if (variable)
+ variable++;
+ if (!(variable && *variable))
+ return EFI_EXIT(EFI_NOT_FOUND);
+ } else {
+ /*
+ *new search: free a list used in the previous search
+ */
+ free(efi_variables_list);
+ efi_variables_list = NULL;
+ efi_cur_variable = NULL;
+
+ snprintf(regex, 256, "efi_.*-.*-.*-.*-.*_.*");
+ list_len = hexport_r(&env_htab, '\n',
+ H_MATCH_REGEX | H_MATCH_KEY,
+ &efi_variables_list, 0, 1, regexlist);
+ /* 1 indicates that no match was found */
+ if (list_len <= 1)
+ return EFI_EXIT(EFI_NOT_FOUND);
+
+ variable = efi_variables_list;
+ }
+
+ ret = parse_uboot_variable(variable, variable_name_size, variable_name,
+ vendor, &attributes);
+
+ return EFI_EXIT(ret);
}
-/* http://wiki.phoenix.com/wiki/index.php/EFI_RUNTIME_SERVICES#SetVariable.28.29 */
-efi_status_t EFIAPI efi_set_variable(u16 *variable_name, efi_guid_t *vendor,
- u32 attributes, efi_uintn_t data_size,
- void *data)
+/**
+ * efi_efi_set_variable() - set value of a UEFI variable
+ *
+ * This function implements the SetVariable runtime service.
+ *
+ * See the Unified Extensible Firmware Interface (UEFI) specification for
+ * details.
+ *
+ * @variable_name: name of the variable
+ * @vendor: vendor GUID
+ * @attributes: attributes of the variable
+ * @data_size: size of the buffer with the variable value
+ * @data: buffer with the variable value
+ * Return: status code
+ */
+efi_status_t EFIAPI efi_set_variable(u16 *variable_name,
+ const efi_guid_t *vendor, u32 attributes,
+ efi_uintn_t data_size, const void *data)
{
char *native_name = NULL, *val = NULL, *s;
efi_status_t ret = EFI_SUCCESS;
@@ -301,7 +460,10 @@ efi_status_t EFIAPI efi_set_variable(u16 *variable_name, efi_guid_t *vendor,
s = val;
- /* store attributes: */
+ /*
+ * store attributes
+ * TODO: several attributes are not supported
+ */
attributes &= (EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS);
s += sprintf(s, "{");
while (attributes) {
@@ -320,7 +482,7 @@ efi_status_t EFIAPI efi_set_variable(u16 *variable_name, efi_guid_t *vendor,
/* store payload: */
s += sprintf(s, "(blob)");
- s = mem2hex(s, data, data_size);
+ s = bin2hex(s, data, data_size);
*s = '\0';
debug("%s: setting: %s=%s\n", __func__, native_name, val);
diff --git a/lib/efi_loader/helloworld.c b/lib/efi_loader/helloworld.c
index 2905479e65..426f276361 100644
--- a/lib/efi_loader/helloworld.c
+++ b/lib/efi_loader/helloworld.c
@@ -18,30 +18,6 @@ static const efi_guid_t acpi_guid = EFI_ACPI_TABLE_GUID;
static const efi_guid_t smbios_guid = SMBIOS_TABLE_GUID;
/**
- * hw_memcmp() - compare memory areas
- *
- * @buf1: pointer to first area
- * @buf2: pointer to second area
- * @length: number of bytes to compare
- * Return: 0 if both memory areas are the same, otherwise the sign of the
- * result value is the same as the sign of ghe difference between
- * the first differing pair of bytes taken as u8.
- */
-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;
-}
-
-/**
* efi_main() - entry point of the EFI application.
*
* @handle: handle of the loaded image
@@ -88,16 +64,16 @@ efi_status_t EFIAPI efi_main(efi_handle_t handle,
}
/* Find configuration tables */
for (i = 0; i < systable->nr_tables; ++i) {
- if (!hw_memcmp(&systable->tables[i].guid, &fdt_guid,
- sizeof(efi_guid_t)))
+ if (!memcmp(&systable->tables[i].guid, &fdt_guid,
+ sizeof(efi_guid_t)))
con_out->output_string
(con_out, L"Have device tree\r\n");
- if (!hw_memcmp(&systable->tables[i].guid, &acpi_guid,
- sizeof(efi_guid_t)))
+ if (!memcmp(&systable->tables[i].guid, &acpi_guid,
+ sizeof(efi_guid_t)))
con_out->output_string
(con_out, L"Have ACPI 2.0 table\r\n");
- if (!hw_memcmp(&systable->tables[i].guid, &smbios_guid,
- sizeof(efi_guid_t)))
+ if (!memcmp(&systable->tables[i].guid, &smbios_guid,
+ sizeof(efi_guid_t)))
con_out->output_string
(con_out, L"Have SMBIOS table\r\n");
}
diff --git a/lib/efi_selftest/Makefile b/lib/efi_selftest/Makefile
index 743b482044..7f4eafb2fe 100644
--- a/lib/efi_selftest/Makefile
+++ b/lib/efi_selftest/Makefile
@@ -6,9 +6,9 @@
# object inclusion implicitly depends on it
CFLAGS_efi_selftest_miniapp_exit.o := $(CFLAGS_EFI) -Os -ffreestanding
-CFLAGS_REMOVE_efi_selftest_miniapp_exit.o := $(CFLAGS_NON_EFI) -Os
+CFLAGS_REMOVE_efi_selftest_miniapp_exit.o := $(CFLAGS_NON_EFI)
CFLAGS_efi_selftest_miniapp_return.o := $(CFLAGS_EFI) -Os -ffreestanding
-CFLAGS_REMOVE_efi_selftest_miniapp_return.o := $(CFLAGS_NON_EFI) -Os
+CFLAGS_REMOVE_efi_selftest_miniapp_return.o := $(CFLAGS_NON_EFI)
obj-y += \
efi_selftest.o \
@@ -40,14 +40,15 @@ efi_selftest_variables.o \
efi_selftest_watchdog.o
obj-$(CONFIG_CPU_V7) += efi_selftest_unaligned.o
+obj-$(CONFIG_EFI_LOADER_HII) += efi_selftest_hii.o
ifeq ($(CONFIG_BLK)$(CONFIG_PARTITIONS),yy)
obj-y += efi_selftest_block_device.o
endif
-# TODO: As of v2018.01 the relocation code for the EFI application cannot
-# be built on x86_64.
-ifeq ($(CONFIG_X86_64)$(CONFIG_SANDBOX),)
+# TODO: As of v2019.01 the relocation code for the EFI application cannot
+# be built on ARMv7-M, Sandbox, and x86_64.
+ifeq ($(CONFIG_SANDBOX)$(CONFIG_CPU_V7M)$(CONFIG_X86_64),)
obj-y += \
efi_selftest_startimage_exit.o \
diff --git a/lib/efi_selftest/efi_selftest_block_device.c b/lib/efi_selftest/efi_selftest_block_device.c
index f038da9f19..1cdd8307f4 100644
--- a/lib/efi_selftest/efi_selftest_block_device.c
+++ b/lib/efi_selftest/efi_selftest_block_device.c
@@ -387,7 +387,7 @@ static int execute(void)
}
/* Read file */
- ret = root->open(root, &file, (s16 *)L"hello.txt", EFI_FILE_MODE_READ,
+ ret = root->open(root, &file, L"hello.txt", EFI_FILE_MODE_READ,
0);
if (ret != EFI_SUCCESS) {
efi_st_error("Failed to open file\n");
@@ -431,7 +431,7 @@ static int execute(void)
#ifdef CONFIG_FAT_WRITE
/* Write file */
- ret = root->open(root, &file, (s16 *)L"u-boot.txt", EFI_FILE_MODE_READ |
+ ret = root->open(root, &file, L"u-boot.txt", EFI_FILE_MODE_READ |
EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE, 0);
if (ret != EFI_SUCCESS) {
efi_st_error("Failed to open file\n");
@@ -463,7 +463,7 @@ static int execute(void)
/* Verify file */
boottime->set_mem(buf, sizeof(buf), 0);
- ret = root->open(root, &file, (s16 *)L"u-boot.txt", EFI_FILE_MODE_READ,
+ ret = root->open(root, &file, L"u-boot.txt", EFI_FILE_MODE_READ,
0);
if (ret != EFI_SUCCESS) {
efi_st_error("Failed to open file\n");
diff --git a/lib/efi_selftest/efi_selftest_events.c b/lib/efi_selftest/efi_selftest_events.c
index ed99a53804..1077cbdf9e 100644
--- a/lib/efi_selftest/efi_selftest_events.c
+++ b/lib/efi_selftest/efi_selftest_events.c
@@ -147,20 +147,20 @@ static int execute(void)
return EFI_ST_FAILURE;
}
ret = boottime->set_timer(event_notify, EFI_TIMER_STOP, 0);
- if (index != 0) {
+ if (ret != EFI_SUCCESS) {
efi_st_error("Could not cancel timer\n");
return EFI_ST_FAILURE;
}
/* Set 10 ms timer */
timer_ticks = 0;
ret = boottime->set_timer(event_notify, EFI_TIMER_RELATIVE, 100000);
- if (index != 0) {
+ if (ret != EFI_SUCCESS) {
efi_st_error("Could not set timer\n");
return EFI_ST_FAILURE;
}
/* Set 100 ms timer */
ret = boottime->set_timer(event_wait, EFI_TIMER_PERIODIC, 1000000);
- if (index != 0) {
+ if (ret != EFI_SUCCESS) {
efi_st_error("Could not set timer\n");
return EFI_ST_FAILURE;
}
diff --git a/lib/efi_selftest/efi_selftest_hii.c b/lib/efi_selftest/efi_selftest_hii.c
new file mode 100644
index 0000000000..e38af7dbf8
--- /dev/null
+++ b/lib/efi_selftest/efi_selftest_hii.c
@@ -0,0 +1,1035 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * efi_selftest_hii
+ *
+ * Copyright (c) 2018 AKASHI Takahiro, Linaro Limited
+ *
+ * Test HII database protocols
+ */
+
+#include <efi_selftest.h>
+#include <malloc.h>
+#include "efi_selftest_hii_data.c"
+
+#define PRINT_TESTNAME efi_st_printf("%s:\n", __func__)
+
+static struct efi_boot_services *boottime;
+
+static const efi_guid_t hii_database_protocol_guid =
+ EFI_HII_DATABASE_PROTOCOL_GUID;
+static const efi_guid_t hii_string_protocol_guid =
+ EFI_HII_STRING_PROTOCOL_GUID;
+
+static struct efi_hii_database_protocol *hii_database_protocol;
+static struct efi_hii_string_protocol *hii_string_protocol;
+
+/*
+ * 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;
+
+ boottime = systable->boottime;
+
+ /* HII database protocol */
+ ret = boottime->locate_protocol(&hii_database_protocol_guid, NULL,
+ (void **)&hii_database_protocol);
+ if (ret != EFI_SUCCESS) {
+ hii_database_protocol = NULL;
+ efi_st_error("HII database protocol is not available.\n");
+ return EFI_ST_FAILURE;
+ }
+
+ /* HII string protocol */
+ ret = boottime->locate_protocol(&hii_string_protocol_guid, NULL,
+ (void **)&hii_string_protocol);
+ if (ret != EFI_SUCCESS) {
+ hii_string_protocol = NULL;
+ efi_st_error("HII string protocol is not available.\n");
+ return EFI_ST_FAILURE;
+ }
+
+ return EFI_ST_SUCCESS;
+}
+
+/*
+ * HII database protocol tests
+ */
+
+/**
+ * test_hii_database_new_package_list() - test creation and removal of
+ * package list
+ *
+ * This test adds a new package list and then tries to remove it using
+ * the provided handle.
+ *
+ * @Return: status code
+ */
+static int test_hii_database_new_package_list(void)
+{
+ efi_hii_handle_t handle;
+ efi_status_t ret;
+
+ PRINT_TESTNAME;
+ ret = hii_database_protocol->new_package_list(hii_database_protocol,
+ (struct efi_hii_package_list_header *)packagelist1,
+ NULL, &handle);
+ if (ret != EFI_SUCCESS || !handle) {
+ efi_st_error("new_package_list returned %u\n",
+ (unsigned int)ret);
+ return EFI_ST_FAILURE;
+ }
+
+ ret = hii_database_protocol->remove_package_list(hii_database_protocol,
+ handle);
+ if (ret != EFI_SUCCESS) {
+ efi_st_error("remove_package_list returned %u\n",
+ (unsigned int)ret);
+ return EFI_ST_FAILURE;
+ }
+
+ return EFI_ST_SUCCESS;
+}
+
+/**
+ * test_hii_database_update_package_list() - test update of package list
+ *
+ * This test adds a new package list and then tries to update it using
+ * another package list.
+ *
+ * @Return: status code
+ */
+static int test_hii_database_update_package_list(void)
+{
+ efi_hii_handle_t handle = NULL;
+ efi_status_t ret;
+ int result = EFI_ST_FAILURE;
+
+ PRINT_TESTNAME;
+ ret = hii_database_protocol->new_package_list(hii_database_protocol,
+ (struct efi_hii_package_list_header *)packagelist1,
+ NULL, &handle);
+ if (ret != EFI_SUCCESS || !handle) {
+ efi_st_error("new_package_list returned %u\n",
+ (unsigned int)ret);
+ return EFI_ST_FAILURE;
+ }
+
+ ret = hii_database_protocol->update_package_list(hii_database_protocol,
+ handle,
+ (struct efi_hii_package_list_header *)packagelist2);
+ if (ret != EFI_SUCCESS || !handle) {
+ efi_st_error("new_package_list returned %u\n",
+ (unsigned int)ret);
+ goto out;
+ }
+
+ result = EFI_ST_SUCCESS;
+
+out:
+ if (handle) {
+ ret = hii_database_protocol->remove_package_list(
+ hii_database_protocol, handle);
+ if (ret != EFI_SUCCESS) {
+ efi_st_error("remove_package_list returned %u\n",
+ (unsigned int)ret);
+ return EFI_ST_FAILURE;
+ }
+ }
+
+ return result;
+}
+
+/**
+ * test_hii_database_list_package_lists() - test listing of package lists
+ *
+ * This test adds two package lists and then tries to enumerate them
+ * against different package types. We will get an array of handles.
+ *
+ * @Return: status code
+ */
+static int test_hii_database_list_package_lists(void)
+{
+ efi_hii_handle_t handle1 = NULL, handle2 = NULL, *handles;
+ efi_uintn_t handles_size;
+ efi_status_t ret;
+ int result = EFI_ST_FAILURE;
+
+ PRINT_TESTNAME;
+ ret = hii_database_protocol->new_package_list(hii_database_protocol,
+ (struct efi_hii_package_list_header *)packagelist1,
+ NULL, &handle1);
+ if (ret != EFI_SUCCESS || !handle1) {
+ efi_st_error("new_package_list returned %u\n",
+ (unsigned int)ret);
+ goto out;
+ }
+
+ ret = hii_database_protocol->new_package_list(hii_database_protocol,
+ (struct efi_hii_package_list_header *)packagelist2,
+ NULL, &handle2);
+ if (ret != EFI_SUCCESS || !handle2) {
+ efi_st_error("new_package_list returned %u\n",
+ (unsigned int)ret);
+ goto out;
+ }
+
+ /* TYPE_ALL */
+ handles = NULL;
+ handles_size = 0;
+ ret = hii_database_protocol->list_package_lists(hii_database_protocol,
+ EFI_HII_PACKAGE_TYPE_ALL, NULL,
+ &handles_size, handles);
+ if (ret != EFI_BUFFER_TOO_SMALL) {
+ efi_st_error("list_package_lists returned %u\n",
+ (unsigned int)ret);
+ goto out;
+ }
+ handles = malloc(handles_size);
+ if (!handles) {
+ efi_st_error("malloc failed\n");
+ goto out;
+ }
+ ret = hii_database_protocol->list_package_lists(hii_database_protocol,
+ EFI_HII_PACKAGE_TYPE_ALL, NULL,
+ &handles_size, handles);
+ if (ret != EFI_SUCCESS) {
+ efi_st_error("list_package_lists returned %u\n",
+ (unsigned int)ret);
+ goto out;
+ }
+ free(handles);
+
+ /* STRINGS */
+ handles = NULL;
+ handles_size = 0;
+ ret = hii_database_protocol->list_package_lists(hii_database_protocol,
+ EFI_HII_PACKAGE_STRINGS, NULL,
+ &handles_size, handles);
+ if (ret != EFI_BUFFER_TOO_SMALL) {
+ efi_st_error("list_package_lists returned %u\n",
+ (unsigned int)ret);
+ ret = EFI_ST_FAILURE;
+ goto out;
+ }
+ handles = malloc(handles_size);
+ if (!handles) {
+ efi_st_error("malloc failed\n");
+ ret = EFI_ST_FAILURE;
+ goto out;
+ }
+ ret = hii_database_protocol->list_package_lists(hii_database_protocol,
+ EFI_HII_PACKAGE_STRINGS, NULL,
+ &handles_size, handles);
+ if (ret != EFI_SUCCESS) {
+ efi_st_error("list_package_lists returned %u\n",
+ (unsigned int)ret);
+ ret = EFI_ST_FAILURE;
+ goto out;
+ }
+ free(handles);
+
+ /* GUID */
+ handles = NULL;
+ handles_size = 0;
+ ret = hii_database_protocol->list_package_lists(hii_database_protocol,
+ EFI_HII_PACKAGE_TYPE_GUID, &package_guid,
+ &handles_size, handles);
+ if (ret != EFI_BUFFER_TOO_SMALL) {
+ efi_st_error("list_package_lists returned %u\n",
+ (unsigned int)ret);
+ ret = EFI_ST_FAILURE;
+ goto out;
+ }
+ handles = malloc(handles_size);
+ if (!handles) {
+ efi_st_error("malloc failed\n");
+ ret = EFI_ST_FAILURE;
+ goto out;
+ }
+ ret = hii_database_protocol->list_package_lists(hii_database_protocol,
+ EFI_HII_PACKAGE_TYPE_GUID, &package_guid,
+ &handles_size, handles);
+ if (ret != EFI_SUCCESS) {
+ efi_st_error("list_package_lists returned %u\n",
+ (unsigned int)ret);
+ ret = EFI_ST_FAILURE;
+ goto out;
+ }
+ free(handles);
+
+ /* KEYBOARD_LAYOUT */
+ handles = NULL;
+ handles_size = 0;
+ ret = hii_database_protocol->list_package_lists(hii_database_protocol,
+ EFI_HII_PACKAGE_KEYBOARD_LAYOUT, NULL,
+ &handles_size, handles);
+ if (ret != EFI_BUFFER_TOO_SMALL) {
+ efi_st_error("list_package_lists returned %u\n",
+ (unsigned int)ret);
+ ret = EFI_ST_FAILURE;
+ goto out;
+ }
+ handles = malloc(handles_size);
+ if (!handles) {
+ efi_st_error("malloc failed\n");
+ ret = EFI_ST_FAILURE;
+ goto out;
+ }
+ ret = hii_database_protocol->list_package_lists(hii_database_protocol,
+ EFI_HII_PACKAGE_KEYBOARD_LAYOUT, NULL,
+ &handles_size, handles);
+ if (ret != EFI_SUCCESS) {
+ efi_st_error("list_package_lists returned %u\n",
+ (unsigned int)ret);
+ ret = EFI_ST_FAILURE;
+ goto out;
+ }
+ free(handles);
+
+ result = EFI_ST_SUCCESS;
+
+out:
+ if (handle1) {
+ ret = hii_database_protocol->remove_package_list(
+ hii_database_protocol, handle1);
+ if (ret != EFI_SUCCESS)
+ efi_st_error("remove_package_list returned %u\n",
+ (unsigned int)ret);
+ }
+ if (handle2) {
+ ret = hii_database_protocol->remove_package_list(
+ hii_database_protocol, handle2);
+ if (ret != EFI_SUCCESS)
+ efi_st_error("remove_package_list returned %u\n",
+ (unsigned int)ret);
+ }
+
+ return result;
+}
+
+/**
+ * test_hii_database_export_package_lists() - test export of package lists
+ *
+ * @Return: status code
+ */
+static int test_hii_database_export_package_lists(void)
+{
+ PRINT_TESTNAME;
+ /* export_package_lists() not implemented yet */
+ return EFI_ST_SUCCESS;
+}
+
+/**
+ * test_hii_database_register_package_notify() - test registration of
+ * notification function
+ *
+ * @Return: status code
+ */
+static int test_hii_database_register_package_notify(void)
+{
+ PRINT_TESTNAME;
+ /* register_package_notify() not implemented yet */
+ return EFI_ST_SUCCESS;
+}
+
+/**
+ * test_hii_database_unregister_package_notify() - test removal of
+ * notification function
+ *
+ * @Return: status code
+ */
+static int test_hii_database_unregister_package_notify(void)
+{
+ PRINT_TESTNAME;
+ /* unregsiter_package_notify() not implemented yet */
+ return EFI_ST_SUCCESS;
+}
+
+/**
+ * test_hii_database_find_keyboard_layouts() - test listing of
+ * all the keyboard layouts in the system
+ *
+ * This test adds two package lists, each of which has two keyboard layouts
+ * and then tries to enumerate them. We will get an array of handles.
+ *
+ * @Return: status code
+ */
+static int test_hii_database_find_keyboard_layouts(void)
+{
+ efi_hii_handle_t handle1 = NULL, handle2 = NULL;
+ efi_guid_t *guids;
+ u16 guids_size;
+ efi_status_t ret;
+ int result = EFI_ST_FAILURE;
+
+ PRINT_TESTNAME;
+ ret = hii_database_protocol->new_package_list(hii_database_protocol,
+ (struct efi_hii_package_list_header *)packagelist1,
+ NULL, &handle1);
+ if (ret != EFI_SUCCESS || !handle1) {
+ efi_st_error("new_package_list returned %u\n",
+ (unsigned int)ret);
+ goto out;
+ }
+
+ ret = hii_database_protocol->new_package_list(hii_database_protocol,
+ (struct efi_hii_package_list_header *)packagelist2,
+ NULL, &handle2);
+ if (ret != EFI_SUCCESS || !handle2) {
+ efi_st_error("new_package_list returned %u\n",
+ (unsigned int)ret);
+ goto out;
+ }
+
+ guids = NULL;
+ guids_size = 0;
+ ret = hii_database_protocol->find_keyboard_layouts(
+ hii_database_protocol, &guids_size, guids);
+ if (ret != EFI_BUFFER_TOO_SMALL) {
+ efi_st_error("find_keyboard_layouts returned %u\n",
+ (unsigned int)ret);
+ goto out;
+ }
+ guids = malloc(guids_size);
+ if (!guids) {
+ efi_st_error("malloc failed\n");
+ goto out;
+ }
+ ret = hii_database_protocol->find_keyboard_layouts(
+ hii_database_protocol, &guids_size, guids);
+ if (ret != EFI_SUCCESS) {
+ efi_st_error("find_keyboard_layouts returned %u\n",
+ (unsigned int)ret);
+ goto out;
+ }
+ free(guids);
+
+ result = EFI_ST_SUCCESS;
+
+out:
+ if (handle1) {
+ ret = hii_database_protocol->remove_package_list(
+ hii_database_protocol, handle1);
+ if (ret != EFI_SUCCESS)
+ efi_st_error("remove_package_list returned %u\n",
+ (unsigned int)ret);
+ }
+ if (handle2) {
+ ret = hii_database_protocol->remove_package_list(
+ hii_database_protocol, handle2);
+ if (ret != EFI_SUCCESS)
+ efi_st_error("remove_package_list returned %u\n",
+ (unsigned int)ret);
+ }
+
+ return result;
+}
+
+/**
+ * test_hii_database_get_keyboard_layout() - test retrieval of keyboard layout
+ *
+ * This test adds two package lists, each of which has two keyboard layouts
+ * and then tries to get a handle to keyboard layout with a specific guid
+ * and the current one.
+ *
+ * @Return: status code
+ */
+static int test_hii_database_get_keyboard_layout(void)
+{
+ efi_hii_handle_t handle1 = NULL, handle2 = NULL;
+ struct efi_hii_keyboard_layout *kb_layout;
+ u16 kb_layout_size;
+ efi_status_t ret;
+ int result = EFI_ST_FAILURE;
+
+ PRINT_TESTNAME;
+ ret = hii_database_protocol->new_package_list(hii_database_protocol,
+ (struct efi_hii_package_list_header *)packagelist1,
+ NULL, &handle1);
+ if (ret != EFI_SUCCESS || !handle1) {
+ efi_st_error("new_package_list returned %u\n",
+ (unsigned int)ret);
+ goto out;
+ }
+
+ ret = hii_database_protocol->new_package_list(hii_database_protocol,
+ (struct efi_hii_package_list_header *)packagelist2,
+ NULL, &handle2);
+ if (ret != EFI_SUCCESS || !handle2) {
+ efi_st_error("new_package_list returned %u\n",
+ (unsigned int)ret);
+ goto out;
+ }
+
+ /* specific keyboard_layout(guid11) */
+ kb_layout = NULL;
+ kb_layout_size = 0;
+ ret = hii_database_protocol->get_keyboard_layout(hii_database_protocol,
+ &kb_layout_guid11, &kb_layout_size, kb_layout);
+ if (ret != EFI_BUFFER_TOO_SMALL) {
+ efi_st_error("get_keyboard_layout returned %u\n",
+ (unsigned int)ret);
+ goto out;
+ }
+ kb_layout = malloc(kb_layout_size);
+ if (!kb_layout) {
+ efi_st_error("malloc failed\n");
+ goto out;
+ }
+ ret = hii_database_protocol->get_keyboard_layout(hii_database_protocol,
+ &kb_layout_guid11, &kb_layout_size, kb_layout);
+ if (ret != EFI_SUCCESS) {
+ efi_st_error("get_keyboard_layout returned %u\n",
+ (unsigned int)ret);
+ goto out;
+ }
+ free(kb_layout);
+
+ /* current */
+ kb_layout = NULL;
+ kb_layout_size = 0;
+ ret = hii_database_protocol->get_keyboard_layout(hii_database_protocol,
+ NULL, &kb_layout_size, kb_layout);
+ if (ret != EFI_INVALID_PARAMETER) {
+ efi_st_error("get_keyboard_layout returned %u\n",
+ (unsigned int)ret);
+ goto out;
+ }
+
+ result = EFI_ST_SUCCESS;
+
+out:
+ if (handle1) {
+ ret = hii_database_protocol->remove_package_list(
+ hii_database_protocol, handle1);
+ if (ret != EFI_SUCCESS)
+ efi_st_error("remove_package_list returned %u\n",
+ (unsigned int)ret);
+ }
+ if (handle2) {
+ ret = hii_database_protocol->remove_package_list(
+ hii_database_protocol, handle2);
+ if (ret != EFI_SUCCESS)
+ efi_st_error("remove_package_list returned %u\n",
+ (unsigned int)ret);
+ }
+
+ return result;
+}
+
+/**
+ * test_hii_database_set_keyboard_layout() - test change of
+ * current keyboard layout
+ *
+ * @Return: status code
+ */
+static int test_hii_database_set_keyboard_layout(void)
+{
+ PRINT_TESTNAME;
+ /* set_keyboard_layout() not implemented yet */
+ return EFI_ST_SUCCESS;
+}
+
+/**
+ * test_hii_database_get_package_list_handle() - test retrieval of
+ * driver associated with a package list
+ *
+ * This test adds a package list, and then tries to get a handle to driver
+ * which is associated with a package list.
+ *
+ * @Return: status code
+ */
+static int test_hii_database_get_package_list_handle(void)
+{
+ efi_hii_handle_t handle = NULL;
+ efi_handle_t driver_handle;
+ efi_status_t ret;
+ int result = EFI_ST_FAILURE;
+
+ PRINT_TESTNAME;
+ driver_handle = (efi_handle_t)0x12345678; /* dummy */
+ ret = hii_database_protocol->new_package_list(hii_database_protocol,
+ (struct efi_hii_package_list_header *)packagelist1,
+ driver_handle, &handle);
+ if (ret != EFI_SUCCESS || !handle) {
+ efi_st_error("new_package_list returned %u\n",
+ (unsigned int)ret);
+ return EFI_ST_FAILURE;
+ }
+
+ driver_handle = NULL;
+ ret = hii_database_protocol->get_package_list_handle(
+ hii_database_protocol, handle, &driver_handle);
+ if (ret != EFI_SUCCESS || driver_handle != (efi_handle_t)0x12345678) {
+ efi_st_error("get_package_list_handle returned %u, driver:%p\n",
+ (unsigned int)ret, driver_handle);
+ goto out;
+ }
+
+ result = EFI_ST_SUCCESS;
+
+out:
+ if (handle) {
+ ret = hii_database_protocol->remove_package_list(
+ hii_database_protocol, handle);
+ if (ret != EFI_SUCCESS) {
+ efi_st_error("remove_package_list returned %u\n",
+ (unsigned int)ret);
+ return EFI_ST_FAILURE;
+ }
+ }
+
+ return result;
+}
+
+static int test_hii_database_protocol(void)
+{
+ int ret;
+
+ ret = test_hii_database_new_package_list();
+ if (ret != EFI_ST_SUCCESS)
+ return EFI_ST_FAILURE;
+
+ ret = test_hii_database_update_package_list();
+ if (ret != EFI_ST_SUCCESS)
+ return EFI_ST_FAILURE;
+
+ ret = test_hii_database_list_package_lists();
+ if (ret != EFI_ST_SUCCESS)
+ return EFI_ST_FAILURE;
+
+ ret = test_hii_database_export_package_lists();
+ if (ret != EFI_ST_SUCCESS)
+ return EFI_ST_FAILURE;
+
+ ret = test_hii_database_register_package_notify();
+ if (ret != EFI_ST_SUCCESS)
+ return EFI_ST_FAILURE;
+
+ ret = test_hii_database_unregister_package_notify();
+ if (ret != EFI_ST_SUCCESS)
+ return EFI_ST_FAILURE;
+
+ ret = test_hii_database_find_keyboard_layouts();
+ if (ret != EFI_ST_SUCCESS)
+ return EFI_ST_FAILURE;
+
+ ret = test_hii_database_get_keyboard_layout();
+ if (ret != EFI_ST_SUCCESS)
+ return EFI_ST_FAILURE;
+
+ ret = test_hii_database_set_keyboard_layout();
+ if (ret != EFI_ST_SUCCESS)
+ return EFI_ST_FAILURE;
+
+ ret = test_hii_database_get_package_list_handle();
+ if (ret != EFI_ST_SUCCESS)
+ return EFI_ST_FAILURE;
+
+ return EFI_ST_SUCCESS;
+}
+
+/*
+ * HII string protocol tests
+ */
+
+/**
+ * test_hii_string_new_string() - test creation of a new string entry
+ *
+ * This test adds a package list, and then tries to add a new string
+ * entry for a specific language.
+ *
+ * @Return: status code
+ */
+static int test_hii_string_new_string(void)
+{
+ efi_hii_handle_t handle = NULL;
+ efi_string_id_t id;
+ efi_status_t ret;
+ int result = EFI_ST_FAILURE;
+
+ PRINT_TESTNAME;
+ ret = hii_database_protocol->new_package_list(hii_database_protocol,
+ (struct efi_hii_package_list_header *)packagelist1,
+ NULL, &handle);
+ if (ret != EFI_SUCCESS || !handle) {
+ efi_st_error("new_package_list returned %u\n",
+ (unsigned int)ret);
+ return EFI_ST_FAILURE;
+ }
+
+ ret = hii_string_protocol->new_string(hii_string_protocol, handle,
+ &id, (u8 *)"en-US",
+ L"Japanese", L"Japanese", NULL);
+ if (ret != EFI_SUCCESS) {
+ efi_st_error("new_string returned %u\n",
+ (unsigned int)ret);
+ goto out;
+ }
+ efi_st_printf("new string id is %u\n", id);
+
+ result = EFI_ST_SUCCESS;
+
+out:
+ if (handle) {
+ ret = hii_database_protocol->remove_package_list(
+ hii_database_protocol, handle);
+ if (ret != EFI_SUCCESS) {
+ efi_st_error("remove_package_list returned %u\n",
+ (unsigned int)ret);
+ return EFI_ST_FAILURE;
+ }
+ }
+
+ return result;
+}
+
+/**
+ * test_hii_string_get_string() - test retrieval of a string entry
+ *
+ * This test adds a package list, create a new string entry and then tries
+ * to get it with its string id.
+ *
+ * @Return: status code
+ */
+static int test_hii_string_get_string(void)
+{
+ efi_hii_handle_t handle = NULL;
+ efi_string_id_t id;
+ efi_string_t string;
+ efi_uintn_t string_len;
+ efi_status_t ret;
+ int result = EFI_ST_FAILURE;
+
+ PRINT_TESTNAME;
+ ret = hii_database_protocol->new_package_list(hii_database_protocol,
+ (struct efi_hii_package_list_header *)packagelist1,
+ NULL, &handle);
+ if (ret != EFI_SUCCESS || !handle) {
+ efi_st_error("new_package_list returned %u\n",
+ (unsigned int)ret);
+ return EFI_ST_FAILURE;
+ }
+
+ ret = hii_string_protocol->new_string(hii_string_protocol, handle,
+ &id, (u8 *)"en-US",
+ L"Japanese", L"Japanese", NULL);
+ if (ret != EFI_SUCCESS) {
+ efi_st_error("new_string returned %u\n",
+ (unsigned int)ret);
+ goto out;
+ }
+
+ string = NULL;
+ string_len = 0;
+ ret = hii_string_protocol->get_string(hii_string_protocol,
+ (u8 *)"en-US", handle, id, string, &string_len, NULL);
+ if (ret != EFI_BUFFER_TOO_SMALL) {
+ efi_st_error("get_string returned %u\n",
+ (unsigned int)ret);
+ goto out;
+ }
+ string_len += sizeof(u16);
+ string = malloc(string_len);
+ if (!string) {
+ efi_st_error("malloc failed\n");
+ goto out;
+ }
+ ret = hii_string_protocol->get_string(hii_string_protocol,
+ (u8 *)"en-US", handle, id, string, &string_len, NULL);
+ if (ret != EFI_SUCCESS) {
+ efi_st_error("get_string returned %u\n",
+ (unsigned int)ret);
+ goto out;
+ }
+
+#if 1
+ u16 *c1, *c2;
+
+ for (c1 = string, c2 = L"Japanese"; *c1 == *c2; c1++, c2++)
+ ;
+ if (!*c1 && !*c2)
+ result = EFI_ST_SUCCESS;
+ else
+ result = EFI_ST_FAILURE;
+#else
+ /* TODO: %ls */
+ efi_st_printf("got string is %s (can be wrong)\n", string);
+#endif
+
+ result = EFI_ST_SUCCESS;
+
+out:
+ if (handle) {
+ ret = hii_database_protocol->remove_package_list(
+ hii_database_protocol, handle);
+ if (ret != EFI_SUCCESS) {
+ efi_st_error("remove_package_list returned %u\n",
+ (unsigned int)ret);
+ return EFI_ST_FAILURE;
+ }
+ }
+
+ return result;
+}
+
+/**
+ * test_hii_string_set_string() - test change of a string entry
+ *
+ * This test adds a package list, create a new string entry and then tries
+ * to modify it.
+ *
+ * @Return: status code
+ */
+static int test_hii_string_set_string(void)
+{
+ efi_hii_handle_t handle = NULL;
+ efi_string_id_t id;
+ efi_status_t ret;
+ int result = EFI_ST_FAILURE;
+
+ PRINT_TESTNAME;
+ ret = hii_database_protocol->new_package_list(hii_database_protocol,
+ (struct efi_hii_package_list_header *)packagelist1,
+ NULL, &handle);
+ if (ret != EFI_SUCCESS || !handle) {
+ efi_st_error("new_package_list returned %u\n",
+ (unsigned int)ret);
+ return EFI_ST_FAILURE;
+ }
+
+ ret = hii_string_protocol->new_string(hii_string_protocol, handle,
+ &id, (u8 *)"en-US",
+ L"Japanese", L"Japanese", NULL);
+ if (ret != EFI_SUCCESS) {
+ efi_st_error("new_string returned %u\n",
+ (unsigned int)ret);
+ goto out;
+ }
+
+ ret = hii_string_protocol->set_string(hii_string_protocol, handle,
+ id, (u8 *)"en-US",
+ L"Nihongo", NULL);
+ if (ret != EFI_SUCCESS) {
+ efi_st_error("set_string returned %u\n",
+ (unsigned int)ret);
+ goto out;
+ }
+
+ result = EFI_ST_SUCCESS;
+
+out:
+ if (handle) {
+ ret = hii_database_protocol->remove_package_list(
+ hii_database_protocol, handle);
+ if (ret != EFI_SUCCESS) {
+ efi_st_error("remove_package_list returned %u\n",
+ (unsigned int)ret);
+ return EFI_ST_FAILURE;
+ }
+ }
+
+ return result;
+}
+
+/**
+ * test_hii_string_get_languages() - test listing of languages
+ *
+ * This test adds a package list, and then tries to enumerate languages
+ * in it. We will get an string of language names.
+ *
+ * @Return: status code
+ */
+static int test_hii_string_get_languages(void)
+{
+ efi_hii_handle_t handle = NULL;
+ u8 *languages;
+ efi_uintn_t languages_len;
+ efi_status_t ret;
+ int result = EFI_ST_FAILURE;
+
+ PRINT_TESTNAME;
+ ret = hii_database_protocol->new_package_list(hii_database_protocol,
+ (struct efi_hii_package_list_header *)packagelist1,
+ NULL, &handle);
+ if (ret != EFI_SUCCESS || !handle) {
+ efi_st_error("new_package_list returned %u\n",
+ (unsigned int)ret);
+ return EFI_ST_FAILURE;
+ }
+
+ languages = NULL;
+ languages_len = 0;
+ ret = hii_string_protocol->get_languages(hii_string_protocol, handle,
+ languages, &languages_len);
+ if (ret != EFI_BUFFER_TOO_SMALL) {
+ efi_st_error("get_languages returned %u\n",
+ (unsigned int)ret);
+ goto out;
+ }
+ languages = malloc(languages_len);
+ if (!languages) {
+ efi_st_error("malloc failed\n");
+ goto out;
+ }
+ ret = hii_string_protocol->get_languages(hii_string_protocol, handle,
+ languages, &languages_len);
+ if (ret != EFI_SUCCESS) {
+ efi_st_error("get_languages returned %u\n",
+ (unsigned int)ret);
+ goto out;
+ }
+
+ efi_st_printf("got languages are %s\n", languages);
+
+ result = EFI_ST_SUCCESS;
+
+out:
+ if (handle) {
+ ret = hii_database_protocol->remove_package_list(
+ hii_database_protocol, handle);
+ if (ret != EFI_SUCCESS) {
+ efi_st_error("remove_package_list returned %u\n",
+ (unsigned int)ret);
+ return EFI_ST_FAILURE;
+ }
+ }
+
+ return result;
+}
+
+/**
+ * test_hii_string_get_secondary_languages() - test listing of secondary
+ * languages
+ *
+ * This test adds a package list, and then tries to enumerate secondary
+ * languages with a specific language. We will get an string of language names.
+ *
+ * @Return: status code
+ */
+static int test_hii_string_get_secondary_languages(void)
+{
+ efi_hii_handle_t handle = NULL;
+ u8 *languages;
+ efi_uintn_t languages_len;
+ efi_status_t ret;
+ int result = EFI_ST_FAILURE;
+
+ PRINT_TESTNAME;
+ ret = hii_database_protocol->new_package_list(hii_database_protocol,
+ (struct efi_hii_package_list_header *)packagelist1,
+ NULL, &handle);
+ if (ret != EFI_SUCCESS || !handle) {
+ efi_st_error("new_package_list returned %u\n",
+ (unsigned int)ret);
+ return EFI_ST_FAILURE;
+ }
+
+ languages = NULL;
+ languages_len = 0;
+ ret = hii_string_protocol->get_secondary_languages(hii_string_protocol,
+ handle, (u8 *)"en-US", languages, &languages_len);
+ if (ret == EFI_NOT_FOUND) {
+ efi_st_printf("no secondary languages\n");
+ result = EFI_ST_SUCCESS;
+ goto out;
+ }
+ if (ret != EFI_BUFFER_TOO_SMALL) {
+ efi_st_error("get_secondary_languages returned %u\n",
+ (unsigned int)ret);
+ goto out;
+ }
+ languages = malloc(languages_len);
+ if (!languages) {
+ efi_st_error("malloc failed\n");
+ goto out;
+ }
+ ret = hii_string_protocol->get_secondary_languages(hii_string_protocol,
+ handle, (u8 *)"en-US", languages, &languages_len);
+ if (ret != EFI_SUCCESS) {
+ efi_st_error("get_secondary_languages returned %u\n",
+ (unsigned int)ret);
+ goto out;
+ }
+
+ efi_st_printf("got secondary languages are %s\n", languages);
+
+ result = EFI_ST_SUCCESS;
+
+out:
+ if (handle) {
+ ret = hii_database_protocol->remove_package_list(
+ hii_database_protocol, handle);
+ if (ret != EFI_SUCCESS) {
+ efi_st_error("remove_package_list returned %u\n",
+ (unsigned int)ret);
+ return EFI_ST_FAILURE;
+ }
+ }
+
+ return result;
+}
+
+static int test_hii_string_protocol(void)
+{
+ int ret;
+
+ ret = test_hii_string_new_string();
+ if (ret != EFI_ST_SUCCESS)
+ return EFI_ST_FAILURE;
+
+ ret = test_hii_string_get_string();
+ if (ret != EFI_ST_SUCCESS)
+ return EFI_ST_FAILURE;
+
+ ret = test_hii_string_set_string();
+ if (ret != EFI_ST_SUCCESS)
+ return EFI_ST_FAILURE;
+
+ ret = test_hii_string_get_languages();
+ if (ret != EFI_ST_SUCCESS)
+ return EFI_ST_FAILURE;
+
+ ret = test_hii_string_get_secondary_languages();
+ if (ret != EFI_ST_SUCCESS)
+ return EFI_ST_FAILURE;
+
+ return EFI_ST_SUCCESS;
+}
+
+/*
+ * Execute unit test.
+ *
+ * @return: EFI_ST_SUCCESS for success, EFI_ST_FAILURE for failure
+ */
+static int execute(void)
+{
+ int ret;
+
+ /* HII database protocol */
+ ret = test_hii_database_protocol();
+ if (ret != EFI_ST_SUCCESS)
+ return EFI_ST_FAILURE;
+
+ /* HII string protocol */
+ ret = test_hii_string_protocol();
+ if (ret != EFI_ST_SUCCESS)
+ return EFI_ST_FAILURE;
+
+ return EFI_ST_SUCCESS;
+}
+
+EFI_UNIT_TEST(hii) = {
+ .name = "HII database protocols",
+ .phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
+ .setup = setup,
+ .execute = execute,
+};
diff --git a/lib/efi_selftest/efi_selftest_hii_data.c b/lib/efi_selftest/efi_selftest_hii_data.c
new file mode 100644
index 0000000000..d19f0682af
--- /dev/null
+++ b/lib/efi_selftest/efi_selftest_hii_data.c
@@ -0,0 +1,453 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * This file's test data is derived from UEFI SCT.
+ * The original copyright is attached below.
+ */
+
+/*
+ * Copyright 2006 - 2016 Unified EFI, Inc.<BR>
+ * Copyright (c) 2010 - 2016, Intel Corporation. All rights reserved.<BR>
+ *
+ * This program and the accompanying materials
+ * are licensed and made available under the terms and conditions of the BSD
+ * License which accompanies this distribution. The full text of the license
+ * may be found at
+ * http://opensource.org/licenses/bsd-license.php
+ *
+ * THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+ */
+
+#include <efi.h>
+
+#ifdef NOT_USED
+/*
+ * TODO: These macro's are not used as they appear only in
+ * "#ifdef NOT_USED" clauses. In the future, define them elsewhere.
+ */
+
+/* HII form */
+#define EFI_IFR_AND_OP 0x15
+#define EFI_IFR_END_OP 0x29
+#define EFI_IFR_BITWISE_AND_OP 0x35
+
+/* HII image */
+#define EFI_HII_IIBT_END 0x00
+#define EFI_HII_IIBT_IMAGE_1BIT 0x10
+#endif
+
+/* HII keyboard layout */
+#define EFI_NULL_MODIFIER 0x0000
+
+u8 packagelist1[] = {
+ // EFI_HII_PACKAGE_LIST_HEADER, length = 20
+ // SimpleFont, Font, GUID, Form, String, Image, DevicePath,
+ // (74) (110) 20 (8) 78 (67) (8)
+ // KeyboardLayout, End
+ // 192 4
+
+ 0x89, 0xcd, 0xab, 0x03, 0xf4, 0x03, 0x44, 0x70,
+ 0x81, 0xde, 0x99, 0xb1, 0x81, 0x20, 0xf7, 0x68, //16: guid
+ 0x3a, 0x01, 0x00, 0x00, // 4: total 314(0x13a)
+#ifdef NOT_USED /* TODO: simple font package not implemented yet */
+ //
+ // Simple Font Package 1, length = 74
+ //
+ 0x4A, 0x00, 0x00,
+ EFI_HII_PACKAGE_SIMPLE_FONTS,
+ 1, 0,
+ 1, 0,
+ 0x55, 0x0, 0x1,
+ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+ 0x77, 0x0, 0x2,
+ 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+ 3, 4, 5,
+ 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 0, 0, 0,
+ //
+ // Font Package 1, length = 110
+ //
+ 0x6e, 0x00, 0x00, // 3
+ EFI_HII_PACKAGE_FONTS, // 1
+ 0x5c, 0x00, 0x00, 0x00, // 4: size of header
+ 0x5c, 0x00, 0x00, 0x00, // 4: offset
+ 0xf1, 0x00, 0xf2, 0x00, 0xf3, 0x00, 0xf4, 0x00,
+ 0xf5, 0x00, 0xec, 0xec, //10+2(pads)
+ 0xff, 0x33, 0xff, 0x44, // 4: font style
+ 0x77, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x52, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, //64
+ //
+ // Glyph block 1, length = 18
+ //
+ EFI_HII_GIBT_GLYPH_DEFAULT, // 1
+ 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x99,
+ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, //16: BitMapData
+ EFI_HII_GIBT_END, // 1
+#endif
+ //
+ // Guid Package 1, length = 20
+ //
+ 0x14, 0x00, 0x00, // 3
+ EFI_HII_PACKAGE_TYPE_GUID, // 1
+ 0x5a, 0xc9, 0x87, 0x03, 0x3, 0xd7, 0x46, 0x23,
+ 0xb2, 0xab, 0xd0, 0xc7, 0xdd, 0x90, 0x44, 0xf8, //16: guid
+#ifdef NOT_USED /* TODO: form package not implemented yet */
+ //
+ // EFI_HII_PACKAGE_FORMS, length = 8
+ //
+ 0x08, 0x00, 0x00, // 3
+ EFI_HII_PACKAGE_FORMS, // 1
+ //
+ // Opcode 1, length = 4
+ //
+ EFI_IFR_AND_OP,
+ 0x82,
+ EFI_IFR_END_OP,
+ 0x02,
+ //
+#endif
+ // EFI_HII_PACKAGE_STRINGS, length = 78
+ //
+ 0x4e, 0x00, 0x00, // 3: length(header)
+ EFI_HII_PACKAGE_STRINGS, // 1: type(header)
+ 0x3c, 0x00, 0x00, 0x00, // 4: header_size
+ 0x3c, 0x00, 0x00, 0x00, // 4: string_offset
+ 0x00, 0x00, 0x11, 0x22, 0x44, 0x55, 0x77, 0x89, //32: language_window
+ 0x11, 0x00, 0x11, 0x22, 0x44, 0x55, 0x87, 0x89,
+ 0x22, 0x00, 0x11, 0x22, 0x44, 0x55, 0x77, 0x89,
+ 0x33, 0x00, 0x11, 0x22, 0x44, 0x55, 0x77, 0x89,
+ 0x01, 0x00, // 2: language name
+ 0x65, 0x6e, 0x2d, 0x55, 0x53, 0x3b, 0x7a, 0x68, //14: language
+ 0x2d, 0x48, 0x61, 0x6e, 0x74, 0x00, // "en-US;zh-Hant"
+ EFI_HII_SIBT_STRING_UCS2, // 1
+ 0x45, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x6C, 0x00,
+ 0x69, 0x00, 0x73, 0x00, 0x68, 0x00, 0x00, 0x00, //16: "English"
+ EFI_HII_SIBT_END, // 1
+#ifdef NOT_USED /* TODO: image package not implemented yet */
+ //
+ // EFI_HII_PACKAGE_IMAGES, length = 67
+ //
+ 0x43, 0x00, 0x00, // 3
+ EFI_HII_PACKAGE_IMAGES, // 1
+ 0x0c, 0x00, 0x00, 0x00, // 4: image info offset
+ 0x39, 0x00, 0x00, 0x00, // 4: palette info offset
+ EFI_HII_IIBT_IMAGE_1BIT, // 1
+ 0x01,
+ 0x0b, 0x00,
+ 0x13, 0x00,
+ 0x80, 0x00,
+ 0xc0, 0x00,
+ 0xe0, 0x00,
+ 0xf0, 0x00,
+ 0xf8, 0x00,
+ 0xfc, 0x00,
+ 0xfe, 0x00,
+ 0xff, 0x00,
+ 0xff, 0x80,
+ 0xff, 0xc0,
+ 0xff, 0xe0,
+ 0xfe, 0x00,
+ 0xef, 0x00,
+ 0xcf, 0x00,
+ 0x87, 0x80,
+ 0x07, 0x80,
+ 0x03, 0xc0,
+ 0x03, 0xc0,
+ 0x01, 0x80, //43
+ EFI_HII_IIBT_END, // 1
+ 0x01, 0x00,
+ 0x06, 0x00,
+ 0x00, 0x00, 0x00,
+ 0xFF, 0xFF, 0xFF, //10
+ //
+ // EFI_HII_PACKAGE_DEVICE_PATH, length = 8
+ //
+ 0x08, 0x00, 0x00, // 3
+ EFI_HII_PACKAGE_DEVICE_PATH, // 1
+ 0x01, 0x23, 0x45, 0x66, // 4: dummy device path protocol
+ // instance address
+#endif
+ //
+ // Keyboard layout package 1, length = 192
+ 0xc0, 0x00, 0x00, // 3: length(header)
+ EFI_HII_PACKAGE_KEYBOARD_LAYOUT, // 1: type(header)
+ 0x02, 0x00, // 2: LayoutCount
+ //
+ // Layout 1, length = 93
+ //
+ 0x5d, 0x00, // 2: layout_length
+ 0x95, 0xe4, 0x40, 0x8d, 0xaa, 0xe2, 0x6f, 0x4c,
+ 0x89, 0x70, 0x68, 0x85, 0x09, 0xee, 0xc7, 0xd2, //16: guid
+ 0x37, 0x00, 0x00, 0x00, // 4: layout_descriptor_
+ // string_offset
+ 0x02, // 1: descriptor_count
+ //
+ // Descriptor 1, length = 16
+ //
+ 49, 0x00, 0x00, 0x00, // 4: key (EfiKeyD1)
+ 'q', 0x00, // 2: unicode
+ 'Q', 0x00, // 2: shifted_unicode
+ 0x00, 0x00, // 2: alt_gr_unicode
+ 0x00, 0x00, // 2: shifted_alt_gr_unicode
+ EFI_NULL_MODIFIER, 0x00, // 2: modifier
+ 0x03, 0x00, // 2: affected_attribute
+ //
+ // Descriptor 2, length = 16
+ //
+ 50, 0x00, 0x00, 0x00, // 4: key (EfiKeyD2)
+ 'w', 0x00, // 2: unicode
+ 'W', 0x00, // 2: shifted_unicode
+ 0x00, 0x00, // 2: alt_gr_unicode
+ 0x00, 0x00, // 2: shifted_alt_gr_unicode
+ EFI_NULL_MODIFIER, 0x00, // 2: modifier
+ 0x3, 0x0, // 2: affected_attribute
+ //
+ // EFI_DESCRIPTOR_STRING_BUNDLE, length = 38
+ //
+ 0x01, 0x00, // 2: DescriptionCount
+ 'e', 0x0, 'n', 0x0, '-', 0x0, 'U', 0x0, 'S', 0x0,
+ //10: RFC3066 language code
+ ' ', 0x0, // 2: Space
+ 'S', 0x0, 'i', 0x0, 'm', 0x0, 'p', 0x0, 'l', 0x0, 'e', 0x0,
+ '1', 0x0, 'o', 0x0, 'n', 0x0, 'l', 0x0, 'y', 0x0, '\0', 0x0,
+ //24: DescriptionString
+ //
+ // Layout 2, length = 93
+ //
+ 0x5d, 0x00, // 2: layout_length
+ 0x3e, 0x0b, 0xe6, 0x2a, 0xd6, 0xb9, 0xd8, 0x49,
+ 0x9a, 0x16, 0xc2, 0x48, 0xf1, 0xeb, 0xa8, 0xdb, //16: guid
+ 0x37, 0x00, 0x00, 0x00, // 4: layout_descriptor_
+ // string_offset
+ 0x02, // 1 Descriptor count
+ //
+ // Descriptor 1, length = 16
+ //
+ 51, 0x0, 0x0, 0x0, // 4: key (EfiKeyD3)
+ 'e', 0x00, // 2: unicode
+ 'E', 0x00, // 2: shifted_unicode
+ 0x00, 0x00, // 2: alt_gr_unicode
+ 0x00, 0x00, // 2: shifted_alt_gr_unicode
+ EFI_NULL_MODIFIER, 0x0, // 2: modifier
+ 0x3, 0x0, // 2: affected_attribute
+ //
+ // Descriptor 2, length = 16
+ //
+ 52, 0x0, 0x0, 0x0, // 4: key (EfiKeyD4)
+ 'r', 0x00, // 2: unicode
+ 'R', 0x00, // 2: shifted_unicode
+ 0x00, 0x00, // 2: alt_gr_unicode
+ 0x00, 0x00, // 2: shifted_alt_gr_unicode
+ EFI_NULL_MODIFIER, 0x0, // 2: modifier
+ 0x3, 0x0, // 2: affected_attribute
+ //
+ // EFI_DESCRIPTOR_STRING_BUNDLE, length = 38
+ //
+ 0x01, 0x00, // 2: DescriptionCount
+ 'e', 0x0, 'n', 0x0, '-', 0x0, 'U', 0x0, 'S', 0x0,
+ //10: RFC3066 language code
+ ' ', 0x0, // 2: Space
+ 'S', 0x0, 'i', 0x0, 'm', 0x0, 'p', 0x0, 'l', 0x0, 'e', 0x0,
+ '2', 0x0, 'o', 0x0, 'n', 0x0, 'l', 0x0, 'y', 0x0, '\0', 0x0,
+ //24: DescriptionString
+ //
+ // End of package list, length = 4
+ //
+ 0x4, 0x00, 0x00,
+ EFI_HII_PACKAGE_END
+};
+
+u8 packagelist2[] = {
+ // EFI_HII_PACKAGE_LIST_HEADER, length = 20
+ // SimpleFont, Font, GUID, KeyboardLayout, Form, End
+ // (74) (122) 20 192 (8) 4
+ 0xd3, 0xde, 0x85, 0x86, 0xce, 0x1b, 0xf3, 0x43,
+ 0xa2, 0x0c, 0xa3, 0x06, 0xec, 0x69, 0x72, 0xdd, //16
+ 0xec, 0x00, 0x00, 0x00, // 4: total 236(0xec)
+
+#ifdef NOT_USED /* TODO: simple font package not implemented yet */
+ //
+ // Simple Font Package 2, length = 74
+ //
+ 0x4A, 0x00, 0x00, // 3
+ EFI_HII_PACKAGE_SIMPLE_FONTS, // 1
+ 1, 0, // 2
+ 1, 0, // 2
+ 0x33, 0x0, 0, 1, 2, 3, 4, 5, 0, 7, 8, 9,
+ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, //22
+ 0x44, 0x0, 0x2, 2, 3, 4, 5, 6, 0, 8, 9,
+ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, //22
+ 3, 4, 5, 6, 7, 8, 9, 10, 11, 9, 13,
+ 14, 15, 16, 17, 18, 19, 20, 21, 0, 0, 0, //22
+ //
+ // Font Package 2, length = 122
+ //
+ 0x7A, 0x00, 0x00, // 3
+ EFI_HII_PACKAGE_FONTS, // 1
+ 0x5C, 0x00, 0x00, 0x00, // 4: size of header
+ 0x5C, 0x00, 0x00, 0x00, // 4: dummy offset
+ 0xf1, 0x00, 0xf2, 0x00, 0xf3, 0x00, 0xf4, 0x00,
+ 0xf5, 0x00, 0xec, 0xec, //10+2(pads)
+ 0xff, 0x11, 0xff, 0x22, // 4: font style
+ 0x99, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x52, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, //64
+ //
+ // Glyph block 1, length = 30
+ //
+ EFI_HII_GIBT_GLYPH, // 1
+ 0xf1, 0x00, 0xf2, 0x00, 0xf3, 0x00, 0xf4, 0x00,
+ 0xf5, 0x00, //10
+ 0xff, 0x01, // 2
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, //16: BitMapData
+ EFI_HII_GIBT_END, // 1
+#endif
+ //
+ // Guid Package 1, length = 20
+ //
+ 0x14, 0x00, 0x00, // 3
+ EFI_HII_PACKAGE_TYPE_GUID, // 1
+ 0x5a, 0xc9, 0x87, 0x03, 0x3, 0xd7, 0x46, 0x23,
+ 0xb2, 0xab, 0xd0, 0xc7, 0xdd, 0x90, 0x44, 0xf8, //16: guid
+ //
+ // Keyboard layout package 2, length = 192
+ 0xc0, 0x00, 0x00, // 3
+ EFI_HII_PACKAGE_KEYBOARD_LAYOUT, // 1
+ 0x02, 0x00, //0xec, 0xec, // 2: LayoutCount
+ //
+ // Layout 1, length = 93
+ //
+ 0x5d, 0x00, // 2: layout_length
+ 0x1f, 0x6a, 0xf5, 0xe0, 0x6b, 0xdf, 0x7e, 0x4a,
+ 0xa3, 0x9a, 0xe7, 0xa5, 0x19, 0x15, 0x45, 0xd6,//16: guid
+ 0x37, 0x00, 0x00, 0x00, // 4: layout_descriptor
+ // string offset
+ 0x02, // 1: descriptor_count
+ //
+ // Descriptor 1, length = 16
+ //
+ 32, 0x00, 0x00, 0x00, // 4: key (EfiKeyC1)
+ 'a', 0x00, // 2: unicode
+ 'A', 0x00, // 2: shifted_unicode
+ 0x00, 0x00, // 2: alt_gr_unicode
+ 0x00, 0x00, // 2: shifted_alt_gr_unic
+ EFI_NULL_MODIFIER, 0x00, // 2: modifier
+ 0x03, 0x00, // 2: affected_attribute
+ //
+ // Descriptor 2, length = 16
+ //
+ 33 /*EfiKeyC2*/, 0x00, 0x00, 0x00,
+ 's', 0x00,
+ 'S', 0x00,
+ 0x00, 0x00,
+ 0x00, 0x00,
+ EFI_NULL_MODIFIER, 0x00,
+ 0x3, 0x0,
+ //
+ // EFI_DESCRIPTOR_STRING_BUNDLE, length = 38
+ //
+ 0x01, 0x00, // 2: DescriptionCount
+ 'e', 0x0, 'n', 0x0, '-', 0x0, 'U', 0x0, 'S', 0x0,
+ //10: RFC3066 language code
+ ' ', 0x0, // 2: Space
+ 'S', 0x0, 'i', 0x0, 'm', 0x0, 'p', 0x0, 'l', 0x0, 'e', 0x0,
+ '3', 0x0, 'o', 0x0, 'n', 0x0, 'l', 0x0, 'y', 0x0, '\0', 0x0,
+ //24: DescriptionString
+ //
+ // Layout 2, length = 93
+ //
+ 0x5d, 0x00, // 2: layout_length
+ 0xc9, 0x6a, 0xbe, 0x47, 0xcc, 0x54, 0xf9, 0x46,
+ 0xa2, 0x62, 0xd5, 0x3b, 0x25, 0x6a, 0xc, 0x34, //16: guid
+ 0x37, 0x00, 0x00, 0x00, // 4: layout_descriptor
+ // string_offset
+ 0x02, // 1: descriptor_count
+ //
+ // Descriptor 1, length = 16
+ //
+ 34 /*EfiKeyC3*/, 0x0, 0x0, 0x0,
+ 'd', 0x00,
+ 'D', 0x00,
+ 0x00, 0x00,
+ 0x00, 0x00,
+ EFI_NULL_MODIFIER, 0x0,
+ 0x3, 0x0,
+ //
+ // Descriptor 2, length = 16
+ //
+ 35 /*EfiKeyC4*/, 0x0, 0x0, 0x0,
+ 'e', 0x00,
+ 'E', 0x00,
+ 0x00, 0x00,
+ 0x00, 0x00,
+ EFI_NULL_MODIFIER, 0x0,
+ 0x3, 0x0,
+ //
+ // EFI_DESCRIPTOR_STRING_BUNDLE, length = 38
+ //
+ 0x01, 0x00, // 2: DescriptionCount
+ 'e', 0x0, 'n', 0x0, '-', 0x0, 'U', 0x0, 'S', 0x0,
+ //10: RFC3066 language code
+ ' ', 0x0, // 2: Space
+ 'S', 0x0, 'i', 0x0, 'm', 0x0, 'p', 0x0, 'l', 0x0, 'e', 0x0,
+ '4', 0x0, 'o', 0x0, 'n', 0x0, 'l', 0x0, 'y', 0x0, '\0', 0x0,
+ //24: DescriptionString
+#ifdef NOT_USED /* TODO: form package not implemented yet */
+ //
+ // EFI_HII_PACKAGE_FORMS, length = 8
+ //
+ 0x08, 0x00, 0x00, // 3
+ EFI_HII_PACKAGE_FORMS, // 1
+ //
+ // Opcode 1
+ //
+ EFI_IFR_BITWISE_AND_OP, // 1
+ 0x02, // 1
+ EFI_IFR_END_OP, // 1
+ 0x02, // 1
+#endif
+ //
+ // End of package list, length = 4
+ //
+ 0x4, 0x00, 0x00, // 3
+ EFI_HII_PACKAGE_END // 1
+};
+
+efi_guid_t packagelist_guid1 =
+ EFI_GUID(0x03abcd89, 0x03f4, 0x7044,
+ 0x81, 0xde, 0x99, 0xb1, 0x81, 0x20, 0xf7, 0x68);
+
+efi_guid_t packagelist_guid2 =
+ EFI_GUID(0x8685ded3, 0x1bce, 0x43f3,
+ 0xa2, 0x0c, 0xa3, 0x06, 0xec, 0x69, 0x72, 0xdd);
+
+efi_guid_t kb_layout_guid11 =
+ EFI_GUID(0x8d40e495, 0xe2aa, 0x4c6f,
+ 0x89, 0x70, 0x68, 0x85, 0x09, 0xee, 0xc7, 0xd2);
+
+efi_guid_t kb_layout_guid12 =
+ EFI_GUID(0x2ae60b3e, 0xb9d6, 0x49d8,
+ 0x9a, 0x16, 0xc2, 0x48, 0xf1, 0xeb, 0xa8, 0xdb);
+
+efi_guid_t kb_layout_guid21 =
+ EFI_GUID(0xe0f56a1f, 0xdf6b, 0x4a7e,
+ 0xa3, 0x9a, 0xe7, 0xa5, 0x19, 0x15, 0x45, 0xd6);
+
+efi_guid_t kb_layout_guid22 =
+ EFI_GUID(0x47be6ac9, 0x54cc, 0x46f9,
+ 0xa2, 0x62, 0xd5, 0x3b, 0x25, 0x6a, 0x0c, 0x34);
+
+efi_guid_t package_guid =
+ EFI_GUID(0x0387c95a, 0xd703, 0x2346,
+ 0xb2, 0xab, 0xd0, 0xc7, 0xdd, 0x90, 0x44, 0xf8);
diff --git a/lib/efi_selftest/efi_selftest_snp.c b/lib/efi_selftest/efi_selftest_snp.c
index e10a34ba64..f1e23c4921 100644
--- a/lib/efi_selftest/efi_selftest_snp.c
+++ b/lib/efi_selftest/efi_selftest_snp.c
@@ -427,4 +427,12 @@ EFI_UNIT_TEST(snp) = {
.setup = setup,
.execute = execute,
.teardown = teardown,
+#ifdef CONFIG_SANDBOX
+ /*
+ * Running this test on the sandbox requires setting environment
+ * variable ethact to a network interface connected to a DHCP server and
+ * ethrotate to 'no'.
+ */
+ .on_request = true,
+#endif
};
diff --git a/lib/efi_selftest/efi_selftest_tpl.c b/lib/efi_selftest/efi_selftest_tpl.c
index 97d256abe4..70a355eae6 100644
--- a/lib/efi_selftest/efi_selftest_tpl.c
+++ b/lib/efi_selftest/efi_selftest_tpl.c
@@ -151,7 +151,7 @@ static int execute(void)
return EFI_ST_FAILURE;
}
ret = boottime->set_timer(event_notify, EFI_TIMER_STOP, 0);
- if (index != 0) {
+ if (ret != EFI_SUCCESS) {
efi_st_error("Could not cancel timer\n");
return EFI_ST_FAILURE;
}
@@ -164,7 +164,7 @@ static int execute(void)
/* Set 10 ms timer */
notification_count = 0;
ret = boottime->set_timer(event_notify, EFI_TIMER_PERIODIC, 100000);
- if (index != 0) {
+ if (ret != EFI_SUCCESS) {
efi_st_error("Could not set timer\n");
return EFI_ST_FAILURE;
}
diff --git a/lib/efi_selftest/efi_selftest_variables.c b/lib/efi_selftest/efi_selftest_variables.c
index e4c389a872..47a8e7fb95 100644
--- a/lib/efi_selftest/efi_selftest_variables.c
+++ b/lib/efi_selftest/efi_selftest_variables.c
@@ -15,10 +15,10 @@
static struct efi_boot_services *boottime;
static struct efi_runtime_services *runtime;
-static efi_guid_t guid_vendor0 =
+static const efi_guid_t guid_vendor0 =
EFI_GUID(0x67029eb5, 0x0af2, 0xf6b1,
0xda, 0x53, 0xfc, 0xb5, 0x66, 0xdd, 0x1c, 0xe6);
-static efi_guid_t guid_vendor1 =
+static const efi_guid_t guid_vendor1 =
EFI_GUID(0xff629290, 0x1fc1, 0xd73f,
0x8f, 0xb1, 0x32, 0xf9, 0x0c, 0xa0, 0x42, 0xea);
@@ -141,19 +141,22 @@ static int execute(void)
if (ret == EFI_NOT_FOUND)
break;
if (ret != EFI_SUCCESS) {
- efi_st_todo("GetNextVariableName failed\n");
- break;
+ efi_st_error("GetNextVariableName failed (%u)\n",
+ (unsigned int)ret);
+ return EFI_ST_FAILURE;
}
if (!efi_st_memcmp(&guid, &guid_vendor0, sizeof(efi_guid_t)) &&
!efi_st_strcmp_16_8(varname, "efi_st_var0"))
- flag |= 2;
+ flag |= 1;
if (!efi_st_memcmp(&guid, &guid_vendor1, sizeof(efi_guid_t)) &&
!efi_st_strcmp_16_8(varname, "efi_st_var1"))
flag |= 2;
}
- if (flag != 3)
- efi_st_todo(
+ if (flag != 3) {
+ efi_st_error(
"GetNextVariableName did not return all variables\n");
+ return EFI_ST_FAILURE;
+ }
/* Delete variable 1 */
ret = runtime->set_variable(L"efi_st_var1", &guid_vendor1,
0, 0, NULL);
diff --git a/lib/fdtdec.c b/lib/fdtdec.c
index fd0ad6ea84..09a7e133a5 100644
--- a/lib/fdtdec.c
+++ b/lib/fdtdec.c
@@ -542,6 +542,39 @@ int fdtdec_get_alias_seq(const void *blob, const char *base, int offset,
return -ENOENT;
}
+int fdtdec_get_alias_highest_id(const void *blob, const char *base)
+{
+ int base_len = strlen(base);
+ int prop_offset;
+ int aliases;
+ int max = -1;
+
+ debug("Looking for highest alias id for '%s'\n", base);
+
+ aliases = fdt_path_offset(blob, "/aliases");
+ for (prop_offset = fdt_first_property_offset(blob, aliases);
+ prop_offset > 0;
+ prop_offset = fdt_next_property_offset(blob, prop_offset)) {
+ const char *prop;
+ const char *name;
+ int len, val;
+
+ prop = fdt_getprop_by_offset(blob, prop_offset, &name, &len);
+ debug(" - %s, %s\n", name, prop);
+ if (*prop != '/' || prop[len - 1] ||
+ strncmp(name, base, base_len))
+ continue;
+
+ val = trailing_strtol(name);
+ if (val > max) {
+ debug("Found seq %d\n", val);
+ max = val;
+ }
+ }
+
+ return max;
+}
+
const char *fdtdec_get_chosen_prop(const void *blob, const char *name)
{
int chosen_node;
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 4213441fbf..de5db1aa5c 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -279,13 +279,17 @@ static char *string(char *buf, char *end, char *s, int field_width,
static char *string16(char *buf, char *end, u16 *s, int field_width,
int precision, int flags)
{
- u16 *str = s ? s : L"<NULL>";
- ssize_t len = utf16_strnlen(str, precision);
+ const u16 *str = s ? s : L"<NULL>";
+ ssize_t i, len = utf16_strnlen(str, precision);
if (!(flags & LEFT))
for (; len < field_width; --field_width)
ADDCH(buf, ' ');
- utf16_utf8_strncpy(&buf, str, len);
+ for (i = 0; i < len && buf + utf16_utf8_strnlen(str, 1) <= end; ++i) {
+ s32 s = utf16_get(&str);
+
+ utf8_put(s, &buf);
+ }
for (; len < field_width; --field_width)
ADDCH(buf, ' ');
return buf;
generated by cgit (git 2.34.1) at 2025-01-27 08:50:43 +0000