Add Firmware Image Package (FIP) driver
The Firmware Image Package (FIP) driver allows for data to be loaded
from a FIP on platform storage. The FVP supports loading bootloader
images from a FIP located in NOR FLASH.
The implemented FVP policy states that bootloader images will be
loaded from a FIP in NOR FLASH if available and fall back to loading
individual images from semi-hosting.
NOTE:
- BL3-3(e.g. UEFI) is loaded into DRAM and needs to be configured
to run from the BL33_BASE address. This is currently set to
DRAM_BASE+128MB for the FVP.
Change-Id: I2e4821748e3376b5f9e467cf3ec09509e43579a0
diff --git a/drivers/io/io_fip.c b/drivers/io/io_fip.c
new file mode 100644
index 0000000..6a7f123
--- /dev/null
+++ b/drivers/io/io_fip.c
@@ -0,0 +1,409 @@
+/*
+ * Copyright (c) 2014, ARM Limited and Contributors. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * Neither the name of ARM nor the names of its contributors may be used
+ * to endorse or promote products derived from this software without specific
+ * prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdint.h>
+#include <uuid.h>
+#include <errno.h>
+#include <string.h>
+#include <assert.h>
+#include "platform.h"
+#include "firmware_image_package.h"
+#include "io_storage.h"
+#include "io_driver.h"
+#include "io_fip.h"
+#include "debug.h"
+
+/* Useful for printing UUIDs when debugging.*/
+#define PRINT_UUID2(x) \
+ "%08x-%04hx-%04hx-%02hhx%02hhx-%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx", \
+ x.time_low, x.time_mid, x.time_hi_and_version, \
+ x.clock_seq_hi_and_reserved, x.clock_seq_low, \
+ x.node[0], x.node[1], x.node[2], x.node[3], \
+ x.node[4], x.node[5]
+
+typedef struct {
+ const char *name;
+ const uuid_t uuid;
+} plat_fip_name_uuid;
+
+typedef struct {
+ /* Put file_pos above the struct to allow {0} on static init.
+ * It is a workaround for a known bug in GCC
+ * http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53119
+ */
+ unsigned int file_pos;
+ fip_toc_entry entry;
+} file_state;
+
+static plat_fip_name_uuid name_uuid[] = {
+ {BL2_IMAGE_NAME, UUID_TRUSTED_BOOT_FIRMWARE_BL2},
+ {BL31_IMAGE_NAME, UUID_EL3_RUNTIME_FIRMWARE_BL31},
+ {BL32_IMAGE_NAME, UUID_SECURE_PAYLOAD_BL32},
+ {BL33_IMAGE_NAME, UUID_NON_TRUSTED_FIRMWARE_BL33},
+ {NULL, {0} }
+};
+
+static const uuid_t uuid_null = {0};
+static file_state current_file = {0};
+static io_dev_handle backend_dev_handle;
+static void *backend_image_spec;
+
+
+/* Firmware Image Package driver functions */
+static int fip_dev_open(void *spec, struct io_dev_info **dev_info);
+static int fip_file_open(struct io_dev_info *dev_info, const void *spec,
+ struct io_entity *entity);
+static int fip_file_len(struct io_entity *entity, size_t *length);
+static int fip_file_read(struct io_entity *entity, void *buffer, size_t length,
+ size_t *length_read);
+static int fip_file_close(struct io_entity *entity);
+static int fip_dev_init(struct io_dev_info *dev_info, const void *init_params);
+static int fip_dev_close(struct io_dev_info *dev_info);
+
+
+static inline int copy_uuid(uuid_t *dst, const uuid_t *src)
+{
+ memcpy(dst, src, sizeof(uuid_t));
+ return 0;
+}
+
+
+/* Return 0 for equal uuids. */
+static inline int compare_uuids(const uuid_t *uuid1, const uuid_t *uuid2)
+{
+ return memcmp(uuid1, uuid2, sizeof(uuid_t));
+}
+
+
+/* TODO: We could check version numbers or do a package checksum? */
+static inline int is_valid_header(fip_toc_header *header)
+{
+ if ((header->name == TOC_HEADER_NAME) && (header->serial_number != 0)) {
+ return 1;
+ } else {
+ return 0;
+ }
+}
+
+
+static int file_to_uuid(const char *filename, uuid_t *uuid)
+{
+ int i;
+ int status = -EINVAL;
+
+ for (i = 0; i < (sizeof(name_uuid)/sizeof(plat_fip_name_uuid)); i++) {
+ if (strcmp(filename, name_uuid[i].name) == 0) {
+ copy_uuid(uuid, &name_uuid[i].uuid);
+ status = 0;
+ break;
+ }
+ }
+ return status;
+}
+
+
+/* Identify the device type as a virtual driver */
+io_type device_type_fip(void)
+{
+ return IO_TYPE_FIRMWARE_IMAGE_PACKAGE;
+}
+
+
+static struct io_dev_connector fip_dev_connector = {
+ .dev_open = fip_dev_open
+};
+
+
+static struct io_dev_funcs fip_dev_funcs = {
+ .type = device_type_fip,
+ .open = fip_file_open,
+ .seek = NULL,
+ .size = fip_file_len,
+ .read = fip_file_read,
+ .write = NULL,
+ .close = fip_file_close,
+ .dev_init = fip_dev_init,
+ .dev_close = fip_dev_close,
+};
+
+
+static struct io_dev_info fip_dev_info = {
+ .funcs = &fip_dev_funcs,
+ .info = (uintptr_t)NULL
+};
+
+
+/* Open a connection to the FIP device */
+static int fip_dev_open(void *spec __attribute__((unused)),
+ struct io_dev_info **dev_info)
+{
+ assert(dev_info != NULL);
+ *dev_info = &fip_dev_info;
+
+ return IO_SUCCESS;
+}
+
+
+/* Do some basic package checks. */
+static int fip_dev_init(struct io_dev_info *dev_info, const void *init_params)
+{
+ int result = IO_FAIL;
+ char *image_name = (char *)init_params;
+ io_handle backend_handle;
+ fip_toc_header header;
+ size_t bytes_read;
+
+ /* Obtain a reference to the image by querying the platform layer */
+ result = plat_get_image_source(image_name, &backend_dev_handle,
+ &backend_image_spec);
+ if (result != IO_SUCCESS) {
+ ERROR("Failed to obtain reference to image '%s' (%i)\n",
+ image_name, result);
+ result = IO_FAIL;
+ goto fip_dev_init_exit;
+ }
+
+ /* Attempt to access the FIP image */
+ result = io_open(backend_dev_handle, backend_image_spec,
+ &backend_handle);
+ if (result != IO_SUCCESS) {
+ ERROR("Failed to access image '%s' (%i)\n", image_name, result);
+ result = IO_FAIL;
+ goto fip_dev_init_exit;
+ }
+
+ result = io_read(backend_handle, &header, sizeof(header), &bytes_read);
+ if (result == IO_SUCCESS) {
+ if (!is_valid_header(&header)) {
+ ERROR("Firmware Image Package header check failed.\n");
+ result = IO_FAIL;
+ } else {
+ INFO("FIP header looks OK.\n");
+ }
+ }
+
+ io_close(backend_handle);
+
+ fip_dev_init_exit:
+ return result;
+}
+
+/* Close a connection to the FIP device */
+static int fip_dev_close(struct io_dev_info *dev_info)
+{
+ /* TODO: Consider tracking open files and cleaning them up here */
+
+ /* Clear the backend. */
+ backend_dev_handle = NULL;
+ backend_image_spec = NULL;
+
+ return IO_SUCCESS;
+}
+
+
+/* Open a file for access from package. */
+static int fip_file_open(struct io_dev_info *dev_info, const void *spec,
+ struct io_entity *entity)
+{
+ int result = IO_FAIL;
+ io_handle backend_handle;
+ uuid_t file_uuid;
+ const io_file_spec *file_spec = (io_file_spec *)spec;
+ size_t bytes_read;
+ int found_file = 0;
+
+ assert(file_spec != NULL);
+ assert(entity != NULL);
+
+ /* Can only have one file open at a time for the moment. We need to
+ * track state like file cursor position. We know the header lives at
+ * offset zero, so this entry should never be zero for an active file.
+ * When the system supports dynamic memory allocation we can allow more
+ * than one open file at a time if needed.
+ */
+ if (current_file.entry.offset_address != 0) {
+ ERROR("fip_file_open : Only one open file at a time.\n");
+ return IO_RESOURCES_EXHAUSTED;
+ }
+
+ /* Attempt to access the FIP image */
+ result = io_open(backend_dev_handle, backend_image_spec,
+ &backend_handle);
+ if (result != IO_SUCCESS) {
+ ERROR("Failed to open Firmware Image Package (%i)\n", result);
+ result = IO_FAIL;
+ goto fip_file_open_exit;
+ }
+
+ /* Seek past the FIP header into the Table of Contents */
+ result = io_seek(backend_handle, IO_SEEK_SET, sizeof(fip_toc_header));
+ if (result != IO_SUCCESS) {
+ ERROR("fip_file_open: failed to seek\n");
+ result = IO_FAIL;
+ goto fip_file_open_close;
+ }
+
+ file_to_uuid(file_spec->path, &file_uuid);
+
+ found_file = 0;
+ do {
+ result = io_read(backend_handle, ¤t_file.entry,
+ sizeof(current_file.entry),
+ &bytes_read);
+ if (result == IO_SUCCESS) {
+ if (compare_uuids(¤t_file.entry.uuid,
+ &file_uuid) == 0) {
+ found_file = 1;
+ break;
+ }
+ } else {
+ ERROR("Failed to read FIP (%i)\n", result);
+ goto fip_file_open_close;
+ }
+ } while (compare_uuids(¤t_file.entry.uuid, &uuid_null) != 0);
+
+ if (found_file == 1) {
+ /* All fine. Update entity info with file state and return. Set
+ * the file position to 0. The 'current_file.entry' holds the
+ * base and size of the file.
+ */
+ current_file.file_pos = 0;
+ entity->info = (uintptr_t)¤t_file;
+ } else {
+ /* Did not find the file in the FIP. */
+ result = IO_FAIL;
+ }
+
+ fip_file_open_close:
+ io_close(backend_handle);
+
+ fip_file_open_exit:
+ return result;
+}
+
+
+/* Return the size of a file in package */
+static int fip_file_len(struct io_entity *entity, size_t *length)
+{
+ assert(entity != NULL);
+ assert(length != NULL);
+
+ *length = ((file_state *)entity->info)->entry.size;
+
+ return IO_SUCCESS;
+}
+
+
+/* Read data from a file in package */
+static int fip_file_read(struct io_entity *entity, void *buffer, size_t length,
+ size_t *length_read)
+{
+ int result = IO_FAIL;
+ file_state *fp;
+ size_t file_offset;
+ size_t bytes_read;
+ io_handle backend_handle;
+
+ assert(entity != NULL);
+ assert(buffer != NULL);
+ assert(length_read != NULL);
+ assert((void *)entity->info != NULL);
+
+ /* Open the backend, attempt to access the blob image */
+ result = io_open(backend_dev_handle, backend_image_spec,
+ &backend_handle);
+ if (result != IO_SUCCESS) {
+ ERROR("Failed to open FIP (%i)\n", result);
+ result = IO_FAIL;
+ goto fip_file_read_exit;
+ }
+
+ fp = (file_state *)entity->info;
+
+ /* Seek to the position in the FIP where the payload lives */
+ file_offset = fp->entry.offset_address + fp->file_pos;
+ result = io_seek(backend_handle, IO_SEEK_SET, file_offset);
+ if (result != IO_SUCCESS) {
+ ERROR("fip_file_read: failed to seek\n");
+ result = IO_FAIL;
+ goto fip_file_read_close;
+ }
+
+ result = io_read(backend_handle, buffer, length, &bytes_read);
+ if (result != IO_SUCCESS) {
+ /* We cannot read our data. Fail. */
+ ERROR("Failed to read payload (%i)\n", result);
+ result = IO_FAIL;
+ goto fip_file_read_close;
+ } else {
+ /* Set caller length and new file position. */
+ *length_read = bytes_read;
+ fp->file_pos += bytes_read;
+ }
+
+/* Close the backend. */
+ fip_file_read_close:
+ io_close(backend_handle);
+
+ fip_file_read_exit:
+ return result;
+}
+
+
+/* Close a file in package */
+static int fip_file_close(struct io_entity *entity)
+{
+ /* Clear our current file pointer.
+ * If we had malloc() we would free() here.
+ */
+ if (current_file.entry.offset_address != 0) {
+ memset(¤t_file, 0, sizeof(current_file));
+ }
+
+ /* Clear the Entity info. */
+ entity->info = 0;
+
+ return IO_SUCCESS;
+}
+
+/* Exported functions */
+
+/* Register the Firmware Image Package driver with the IO abstraction */
+int register_io_dev_fip(struct io_dev_connector **dev_con)
+{
+ int result = IO_FAIL;
+ assert(dev_con != NULL);
+
+ result = io_register_device(&fip_dev_info);
+ if (result == IO_SUCCESS)
+ *dev_con = &fip_dev_connector;
+
+ return result;
+}