Merge pull request #49 from danh-arm/dh/remove-non-const-data

Remove variables from .data section
diff --git a/bl31/bl31_main.c b/bl31/bl31_main.c
index cf826d0..01f00f2 100644
--- a/bl31/bl31_main.c
+++ b/bl31/bl31_main.c
@@ -50,7 +50,7 @@
  * Variable to indicate whether next image to execute after BL31 is BL33
  * (non-secure & default) or BL32 (secure).
  ******************************************************************************/
-static uint32_t next_image_type = NON_SECURE;
+static uint32_t next_image_type;
 
 /*******************************************************************************
  * Simple function to initialise all BL31 helper libraries.
@@ -100,6 +100,7 @@
 	assert(cm_get_context(mpidr, NON_SECURE));
 	cm_set_next_eret_context(NON_SECURE);
 	write_vbar_el3((uint64_t) runtime_exceptions);
+	next_image_type = NON_SECURE;
 
 	/*
 	 * All the cold boot actions on the primary cpu are done. We now need to
diff --git a/common/bl_common.c b/common/bl_common.c
index af2b7b7..5361c38 100644
--- a/common/bl_common.c
+++ b/common/bl_common.c
@@ -251,9 +251,9 @@
 /* Generic function to return the size of an image */
 unsigned long image_size(const char *image_name)
 {
-	io_dev_handle dev_handle;
-	io_handle image_handle;
-	void *image_spec;
+	uintptr_t dev_handle;
+	uintptr_t image_handle;
+	uintptr_t image_spec;
 	size_t image_size = 0;
 	int io_result = IO_FAIL;
 
@@ -303,9 +303,9 @@
 			 unsigned int load_type,
 			 unsigned long fixed_addr)
 {
-	io_dev_handle dev_handle;
-	io_handle image_handle;
-	void *image_spec;
+	uintptr_t dev_handle;
+	uintptr_t image_handle;
+	uintptr_t image_spec;
 	unsigned long temp_image_base = 0;
 	unsigned long image_base = 0;
 	long offset = 0;
@@ -504,7 +504,7 @@
 
 	/* We have enough space so load the image now */
 	/* TODO: Consider whether to try to recover/retry a partially successful read */
-	io_result = io_read(image_handle, (void *)image_base, image_size, &bytes_read);
+	io_result = io_read(image_handle, image_base, image_size, &bytes_read);
 	if ((io_result != IO_SUCCESS) || (bytes_read < image_size)) {
 		WARN("Failed to load '%s' file (%i)\n", image_name, io_result);
 		goto fail;
diff --git a/drivers/io/io_fip.c b/drivers/io/io_fip.c
index b2dcfcc..4848a70 100644
--- a/drivers/io/io_fip.c
+++ b/drivers/io/io_fip.c
@@ -62,7 +62,7 @@
 	fip_toc_entry_t entry;
 } file_state_t;
 
-static plat_fip_name_uuid_t name_uuid[] = {
+static const plat_fip_name_uuid_t 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},
@@ -71,19 +71,19 @@
 
 static const uuid_t uuid_null = {0};
 static file_state_t current_file = {0};
-static io_dev_handle backend_dev_handle;
-static void *backend_image_spec;
+static uintptr_t backend_dev_handle;
+static uintptr_t backend_image_spec;
 
 
 /* Firmware Image Package driver functions */
-static int fip_dev_open(void *spec, io_dev_info_t **dev_info);
-static int fip_file_open(io_dev_info_t *dev_info, const void *spec,
+static int fip_dev_open(const uintptr_t dev_spec, io_dev_info_t **dev_info);
+static int fip_file_open(io_dev_info_t *dev_info, const uintptr_t spec,
 			  io_entity_t *entity);
 static int fip_file_len(io_entity_t *entity, size_t *length);
-static int fip_file_read(io_entity_t *entity, void *buffer, size_t length,
+static int fip_file_read(io_entity_t *entity, uintptr_t buffer, size_t length,
 			  size_t *length_read);
 static int fip_file_close(io_entity_t *entity);
-static int fip_dev_init(io_dev_info_t *dev_info, const void *init_params);
+static int fip_dev_init(io_dev_info_t *dev_info, const uintptr_t init_params);
 static int fip_dev_close(io_dev_info_t *dev_info);
 
 
@@ -135,12 +135,12 @@
 }
 
 
-static struct io_dev_connector fip_dev_connector = {
+static const io_dev_connector_t fip_dev_connector = {
 	.dev_open = fip_dev_open
 };
 
 
-static struct io_dev_funcs fip_dev_funcs = {
+static const io_dev_funcs_t fip_dev_funcs = {
 	.type = device_type_fip,
 	.open = fip_file_open,
 	.seek = NULL,
@@ -153,29 +153,30 @@
 };
 
 
-static struct io_dev_info fip_dev_info = {
+/* No state associated with this device so structure can be const */
+static const io_dev_info_t 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)),
+static int fip_dev_open(const uintptr_t dev_spec __attribute__((unused)),
 			 io_dev_info_t **dev_info)
 {
 	assert(dev_info != NULL);
-	*dev_info = &fip_dev_info;
+	*dev_info = (io_dev_info_t *)&fip_dev_info; /* cast away const */
 
 	return IO_SUCCESS;
 }
 
 
 /* Do some basic package checks. */
-static int fip_dev_init(io_dev_info_t *dev_info, const void *init_params)
+static int fip_dev_init(io_dev_info_t *dev_info, const uintptr_t init_params)
 {
 	int result = IO_FAIL;
 	char *image_name = (char *)init_params;
-	io_handle backend_handle;
+	uintptr_t backend_handle;
 	fip_toc_header_t header;
 	size_t bytes_read;
 
@@ -198,7 +199,8 @@
 		goto fip_dev_init_exit;
 	}
 
-	result = io_read(backend_handle, &header, sizeof(header), &bytes_read);
+	result = io_read(backend_handle, (uintptr_t)&header, sizeof(header),
+			&bytes_read);
 	if (result == IO_SUCCESS) {
 		if (!is_valid_header(&header)) {
 			WARN("Firmware Image Package header check failed.\n");
@@ -220,19 +222,19 @@
 	/* TODO: Consider tracking open files and cleaning them up here */
 
 	/* Clear the backend. */
-	backend_dev_handle = NULL;
-	backend_image_spec = NULL;
+	backend_dev_handle = (uintptr_t)NULL;
+	backend_image_spec = (uintptr_t)NULL;
 
 	return IO_SUCCESS;
 }
 
 
 /* Open a file for access from package. */
-static int fip_file_open(io_dev_info_t *dev_info, const void *spec,
+static int fip_file_open(io_dev_info_t *dev_info, const uintptr_t spec,
 			 io_entity_t *entity)
 {
 	int result = IO_FAIL;
-	io_handle backend_handle;
+	uintptr_t backend_handle;
 	uuid_t file_uuid;
 	const io_file_spec_t *file_spec = (io_file_spec_t *)spec;
 	size_t bytes_read;
@@ -273,7 +275,8 @@
 
 	found_file = 0;
 	do {
-		result = io_read(backend_handle, &current_file.entry,
+		result = io_read(backend_handle,
+				 (uintptr_t)&current_file.entry,
 				 sizeof(current_file.entry),
 				 &bytes_read);
 		if (result == IO_SUCCESS) {
@@ -322,19 +325,19 @@
 
 
 /* Read data from a file in package */
-static int fip_file_read(io_entity_t *entity, void *buffer, size_t length,
+static int fip_file_read(io_entity_t *entity, uintptr_t buffer, size_t length,
 			  size_t *length_read)
 {
 	int result = IO_FAIL;
 	file_state_t *fp;
 	size_t file_offset;
 	size_t bytes_read;
-	io_handle backend_handle;
+	uintptr_t backend_handle;
 
 	assert(entity != NULL);
-	assert(buffer != NULL);
+	assert(buffer != (uintptr_t)NULL);
 	assert(length_read != NULL);
-	assert((void *)entity->info != NULL);
+	assert(entity->info != (uintptr_t)NULL);
 
 	/* Open the backend, attempt to access the blob image */
 	result = io_open(backend_dev_handle, backend_image_spec,
@@ -396,7 +399,7 @@
 /* Exported functions */
 
 /* Register the Firmware Image Package driver with the IO abstraction */
-int register_io_dev_fip(io_dev_connector_t **dev_con)
+int register_io_dev_fip(const io_dev_connector_t **dev_con)
 {
 	int result = IO_FAIL;
 	assert(dev_con != NULL);
diff --git a/drivers/io/io_memmap.c b/drivers/io/io_memmap.c
index a40e612..fc06fbb 100644
--- a/drivers/io/io_memmap.c
+++ b/drivers/io/io_memmap.c
@@ -42,9 +42,9 @@
 	/* Use the 'in_use' flag as any value for base and file_pos could be
 	 * valid.
 	 */
-	int	in_use;
-	size_t	base;
-	size_t  file_pos;
+	int		in_use;
+	uintptr_t	base;
+	size_t		file_pos;
 } file_state_t;
 
 static file_state_t current_file = {0};
@@ -56,25 +56,25 @@
 }
 
 /* Memmap device functions */
-static int memmap_dev_open(void *spec, io_dev_info_t **dev_info);
-static int memmap_block_open(io_dev_info_t *dev_info, const void *spec,
+static int memmap_dev_open(const uintptr_t dev_spec, io_dev_info_t **dev_info);
+static int memmap_block_open(io_dev_info_t *dev_info, const uintptr_t spec,
 			     io_entity_t *entity);
 static int memmap_block_seek(io_entity_t *entity, int mode,
 			     ssize_t offset);
-static int memmap_block_read(io_entity_t *entity, void *buffer,
+static int memmap_block_read(io_entity_t *entity, uintptr_t buffer,
 			     size_t length, size_t *length_read);
-static int memmap_block_write(io_entity_t *entity, const void *buffer,
+static int memmap_block_write(io_entity_t *entity, const uintptr_t buffer,
 			      size_t length, size_t *length_written);
 static int memmap_block_close(io_entity_t *entity);
 static int memmap_dev_close(io_dev_info_t *dev_info);
 
 
-static struct io_dev_connector memmap_dev_connector = {
+static const io_dev_connector_t memmap_dev_connector = {
 	.dev_open = memmap_dev_open
 };
 
 
-static struct io_dev_funcs memmap_dev_funcs = {
+static const io_dev_funcs_t memmap_dev_funcs = {
 	.type = device_type_memmap,
 	.open = memmap_block_open,
 	.seek = memmap_block_seek,
@@ -87,18 +87,19 @@
 };
 
 
-static struct io_dev_info memmap_dev_info = {
+/* No state associated with this device so structure can be const */
+static const io_dev_info_t memmap_dev_info = {
 	.funcs = &memmap_dev_funcs,
 	.info = (uintptr_t)NULL
 };
 
 
 /* Open a connection to the memmap device */
-static int memmap_dev_open(void *spec __attribute__((unused)),
+static int memmap_dev_open(const uintptr_t dev_spec __attribute__((unused)),
 			   io_dev_info_t **dev_info)
 {
 	assert(dev_info != NULL);
-	*dev_info = &memmap_dev_info;
+	*dev_info = (io_dev_info_t *)&memmap_dev_info; /* cast away const */
 
 	return IO_SUCCESS;
 }
@@ -116,7 +117,7 @@
 
 /* Open a file on the memmap device */
 /* TODO: Can we do any sensible limit checks on requested memory */
-static int memmap_block_open(io_dev_info_t *dev_info, const void *spec,
+static int memmap_block_open(io_dev_info_t *dev_info, const uintptr_t spec,
 			     io_entity_t *entity)
 {
 	int result = IO_FAIL;
@@ -166,18 +167,18 @@
 
 
 /* Read data from a file on the memmap device */
-static int memmap_block_read(io_entity_t *entity, void *buffer,
+static int memmap_block_read(io_entity_t *entity, uintptr_t buffer,
 			     size_t length, size_t *length_read)
 {
 	file_state_t *fp;
 
 	assert(entity != NULL);
-	assert(buffer != NULL);
+	assert(buffer != (uintptr_t)NULL);
 	assert(length_read != NULL);
 
 	fp = (file_state_t *)entity->info;
 
-	memcpy(buffer, (void *)(fp->base + fp->file_pos), length);
+	memcpy((void *)buffer, (void *)(fp->base + fp->file_pos), length);
 
 	*length_read = length;
 	/* advance the file 'cursor' for incremental reads */
@@ -188,18 +189,18 @@
 
 
 /* Write data to a file on the memmap device */
-static int memmap_block_write(io_entity_t *entity, const void *buffer,
+static int memmap_block_write(io_entity_t *entity, const uintptr_t buffer,
 			      size_t length, size_t *length_written)
 {
 	file_state_t *fp;
 
 	assert(entity != NULL);
-	assert(buffer != NULL);
+	assert(buffer != (uintptr_t)NULL);
 	assert(length_written != NULL);
 
 	fp = (file_state_t *)entity->info;
 
-	memcpy((void *)(fp->base + fp->file_pos), buffer, length);
+	memcpy((void *)(fp->base + fp->file_pos), (void *)buffer, length);
 
 	*length_written = length;
 
@@ -227,7 +228,7 @@
 /* Exported functions */
 
 /* Register the memmap driver with the IO abstraction */
-int register_io_dev_memmap(io_dev_connector_t **dev_con)
+int register_io_dev_memmap(const io_dev_connector_t **dev_con)
 {
 	int result = IO_FAIL;
 	assert(dev_con != NULL);
diff --git a/drivers/io/io_semihosting.c b/drivers/io/io_semihosting.c
index a37693d..3c92c6d 100644
--- a/drivers/io/io_semihosting.c
+++ b/drivers/io/io_semihosting.c
@@ -44,23 +44,23 @@
 
 /* Semi-hosting functions, device info and handle */
 
-static int sh_dev_open(void *spec, io_dev_info_t **dev_info);
-static int sh_file_open(io_dev_info_t *dev_info, const void *spec,
+static int sh_dev_open(const uintptr_t dev_spec, io_dev_info_t **dev_info);
+static int sh_file_open(io_dev_info_t *dev_info, const uintptr_t spec,
 		io_entity_t *entity);
 static int sh_file_seek(io_entity_t *entity, int mode, ssize_t offset);
 static int sh_file_len(io_entity_t *entity, size_t *length);
-static int sh_file_read(io_entity_t *entity, void *buffer, size_t length,
+static int sh_file_read(io_entity_t *entity, uintptr_t buffer, size_t length,
 		size_t *length_read);
-static int sh_file_write(io_entity_t *entity, const void *buffer,
+static int sh_file_write(io_entity_t *entity, const uintptr_t buffer,
 		size_t length, size_t *length_written);
 static int sh_file_close(io_entity_t *entity);
 
-static struct io_dev_connector sh_dev_connector = {
+static const io_dev_connector_t sh_dev_connector = {
 	.dev_open = sh_dev_open
 };
 
 
-static struct io_dev_funcs sh_dev_funcs = {
+static const io_dev_funcs_t sh_dev_funcs = {
 	.type = device_type_sh,
 	.open = sh_file_open,
 	.seek = sh_file_seek,
@@ -73,29 +73,31 @@
 };
 
 
-static struct io_dev_info sh_dev_info = {
+/* No state associated with this device so structure can be const */
+static const io_dev_info_t sh_dev_info = {
 	.funcs = &sh_dev_funcs,
 	.info = (uintptr_t)NULL
 };
 
 
 /* Open a connection to the semi-hosting device */
-static int sh_dev_open(void *spec __unused, io_dev_info_t **dev_info)
+static int sh_dev_open(const uintptr_t dev_spec __unused,
+		io_dev_info_t **dev_info)
 {
 	int result = IO_SUCCESS;
 	assert(dev_info != NULL);
-	*dev_info = &sh_dev_info;
+	*dev_info = (io_dev_info_t *)&sh_dev_info; /* cast away const */
 	return result;
 }
 
 
 /* Open a file on the semi-hosting device */
 static int sh_file_open(io_dev_info_t *dev_info __attribute__((unused)),
-		const void *spec, io_entity_t *entity)
+		const uintptr_t spec, io_entity_t *entity)
 {
 	int result = IO_FAIL;
 	long sh_result = -1;
-	const io_file_spec_t *file_spec = (io_file_spec_t *)spec;
+	const io_file_spec_t *file_spec = (const io_file_spec_t *)spec;
 
 	assert(file_spec != NULL);
 	assert(entity != NULL);
@@ -151,7 +153,7 @@
 
 
 /* Read data from a file on the semi-hosting device */
-static int sh_file_read(io_entity_t *entity, void *buffer, size_t length,
+static int sh_file_read(io_entity_t *entity, uintptr_t buffer, size_t length,
 		size_t *length_read)
 {
 	int result = IO_FAIL;
@@ -160,7 +162,7 @@
 	long file_handle;
 
 	assert(entity != NULL);
-	assert(buffer != NULL);
+	assert(buffer != (uintptr_t)NULL);
 	assert(length_read != NULL);
 
 	file_handle = (long)entity->info;
@@ -178,7 +180,7 @@
 
 
 /* Write data to a file on the semi-hosting device */
-static int sh_file_write(io_entity_t *entity, const void *buffer,
+static int sh_file_write(io_entity_t *entity, const uintptr_t buffer,
 		size_t length, size_t *length_written)
 {
 	int result = IO_FAIL;
@@ -187,7 +189,7 @@
 	size_t bytes = length;
 
 	assert(entity != NULL);
-	assert(buffer != NULL);
+	assert(buffer != (uintptr_t)NULL);
 	assert(length_written != NULL);
 
 	file_handle = (long)entity->info;
@@ -226,7 +228,7 @@
 /* Exported functions */
 
 /* Register the semi-hosting driver with the IO abstraction */
-int register_io_dev_sh(io_dev_connector_t **dev_con)
+int register_io_dev_sh(const io_dev_connector_t **dev_con)
 {
 	int result = IO_FAIL;
 	assert(dev_con != NULL);
diff --git a/include/drivers/io_driver.h b/include/drivers/io_driver.h
index cc01d3b..f34c71d 100644
--- a/include/drivers/io_driver.h
+++ b/include/drivers/io_driver.h
@@ -39,7 +39,7 @@
 /* Generic IO entity structure,representing an accessible IO construct on the
  * device, such as a file */
 typedef struct io_entity {
-	io_dev_handle dev_handle;
+	struct io_dev_info *dev_handle;
 	uintptr_t info;
 } io_entity_t;
 
@@ -47,7 +47,7 @@
 /* Device info structure, providing device-specific functions and a means of
  * adding driver-specific state */
 typedef struct io_dev_info {
-	struct io_dev_funcs *funcs;
+	const struct io_dev_funcs *funcs;
 	uintptr_t info;
 } io_dev_info_t;
 
@@ -55,23 +55,23 @@
 /* Structure used to create a connection to a type of device */
 typedef struct io_dev_connector {
 	/* dev_open opens a connection to a particular device driver */
-	int (*dev_open)(void *spec, io_dev_info_t **dev_info);
+	int (*dev_open)(const uintptr_t dev_spec, io_dev_info_t **dev_info);
 } io_dev_connector_t;
 
 
 /* Structure to hold device driver function pointers */
 typedef struct io_dev_funcs {
 	io_type_t (*type)(void);
-	int (*open)(io_dev_info_t *dev_info, const void *spec,
+	int (*open)(io_dev_info_t *dev_info, const uintptr_t spec,
 			io_entity_t *entity);
 	int (*seek)(io_entity_t *entity, int mode, ssize_t offset);
 	int (*size)(io_entity_t *entity, size_t *length);
-	int (*read)(io_entity_t *entity, void *buffer, size_t length,
+	int (*read)(io_entity_t *entity, uintptr_t buffer, size_t length,
 			size_t *length_read);
-	int (*write)(io_entity_t *entity, const void *buffer,
+	int (*write)(io_entity_t *entity, const uintptr_t buffer,
 			size_t length, size_t *length_written);
 	int (*close)(io_entity_t *entity);
-	int (*dev_init)(io_dev_info_t *dev_info, const void *init_params);
+	int (*dev_init)(io_dev_info_t *dev_info, const uintptr_t init_params);
 	int (*dev_close)(io_dev_info_t *dev_info);
 } io_dev_funcs_t;
 
@@ -79,7 +79,7 @@
 /* IO platform data - used to track devices registered for a specific
  * platform */
 typedef struct io_plat_data {
-	io_dev_info_t *devices[MAX_IO_DEVICES];
+	const io_dev_info_t *devices[MAX_IO_DEVICES];
 	unsigned int dev_count;
 } io_plat_data_t;
 
@@ -90,6 +90,6 @@
 void io_init(io_plat_data_t *data);
 
 /* Register a device driver */
-int io_register_device(io_dev_info_t *dev_info);
+int io_register_device(const io_dev_info_t *dev_info);
 
 #endif  /* __IO_DRIVER_H__ */
diff --git a/include/drivers/io_fip.h b/include/drivers/io_fip.h
index 212570d..90b2fd0 100644
--- a/include/drivers/io_fip.h
+++ b/include/drivers/io_fip.h
@@ -33,6 +33,6 @@
 
 struct io_dev_connector;
 
-int register_io_dev_fip(struct io_dev_connector **dev_con);
+int register_io_dev_fip(const struct io_dev_connector **dev_con);
 
 #endif /* __IO_FIP_H__ */
diff --git a/include/drivers/io_memmap.h b/include/drivers/io_memmap.h
index 0e59ecb..7ee60fe 100644
--- a/include/drivers/io_memmap.h
+++ b/include/drivers/io_memmap.h
@@ -33,6 +33,6 @@
 
 struct io_dev_connector;
 
-int register_io_dev_memmap(struct io_dev_connector **dev_con);
+int register_io_dev_memmap(const struct io_dev_connector **dev_con);
 
 #endif /* __IO_MEMMAP_H__ */
diff --git a/include/drivers/io_semihosting.h b/include/drivers/io_semihosting.h
index eab290a..8902a6f 100644
--- a/include/drivers/io_semihosting.h
+++ b/include/drivers/io_semihosting.h
@@ -33,6 +33,6 @@
 
 struct io_dev_connector;
 
-int register_io_dev_sh(struct io_dev_connector **dev_con);
+int register_io_dev_sh(const struct io_dev_connector **dev_con);
 
 #endif /* __IO_SH_H__ */
diff --git a/include/lib/io_storage.h b/include/lib/io_storage.h
index b6c5f9f..ae1158c 100644
--- a/include/lib/io_storage.h
+++ b/include/lib/io_storage.h
@@ -31,6 +31,7 @@
 #ifndef __IO_H__
 #define __IO_H__
 
+#include <stdint.h>
 #include <stdio.h> /* For ssize_t */
 
 
@@ -58,13 +59,6 @@
 /* Connector type, providing a means of identifying a device to open */
 struct io_dev_connector;
 
-/* Device handle, providing a client with access to a specific device */
-typedef struct io_dev_info *io_dev_handle;
-
-/* IO handle, providing a client with access to a specific source of data from
- * a device */
-typedef struct io_entity *io_handle;
-
 
 /* File specification - used to refer to data on a device supporting file-like
  * entities */
@@ -77,7 +71,7 @@
 /* Block specification - used to refer to data on a device supporting
  * block-like entities */
 typedef struct io_block_spec {
-	unsigned long offset;
+	size_t offset;
 	size_t length;
 } io_block_spec_t;
 
@@ -96,33 +90,35 @@
 
 
 /* Open a connection to a device */
-int io_dev_open(struct io_dev_connector *dev_con, void *dev_spec,
-		io_dev_handle *dev_handle);
+int io_dev_open(const struct io_dev_connector *dev_con,
+		const uintptr_t dev_spec,
+		uintptr_t *dev_handle);
 
 
 /* Initialise a device explicitly - to permit lazy initialisation or
  * re-initialisation */
-int io_dev_init(io_dev_handle dev_handle, const void *init_params);
+int io_dev_init(uintptr_t dev_handle, const uintptr_t init_params);
 
 /* TODO: Consider whether an explicit "shutdown" API should be included */
 
 /* Close a connection to a device */
-int io_dev_close(io_dev_handle dev_handle);
+int io_dev_close(uintptr_t dev_handle);
 
 
 /* Synchronous operations */
-int io_open(io_dev_handle dev_handle, const void *spec, io_handle *handle);
+int io_open(uintptr_t dev_handle, const uintptr_t spec, uintptr_t *handle);
 
-int io_seek(io_handle handle, io_seek_mode_t mode, ssize_t offset);
+int io_seek(uintptr_t handle, io_seek_mode_t mode, ssize_t offset);
 
-int io_size(io_handle handle, size_t *length);
+int io_size(uintptr_t handle, size_t *length);
 
-int io_read(io_handle handle, void *buffer, size_t length, size_t *length_read);
+int io_read(uintptr_t handle, uintptr_t buffer, size_t length,
+		size_t *length_read);
 
-int io_write(io_handle handle, const void *buffer, size_t length,
+int io_write(uintptr_t handle, const uintptr_t buffer, size_t length,
 		size_t *length_written);
 
-int io_close(io_handle handle);
+int io_close(uintptr_t handle);
 
 
 #endif /* __IO_H__ */
diff --git a/include/lib/semihosting.h b/include/lib/semihosting.h
index 9d0b39f..b4eecc5 100644
--- a/include/lib/semihosting.h
+++ b/include/lib/semihosting.h
@@ -31,6 +31,7 @@
 #ifndef __SEMIHOSTING_H__
 #define __SEMIHOSTING_H__
 
+#include <stdint.h>
 #include <stdio.h> /* For ssize_t */
 
 
@@ -63,17 +64,17 @@
 long semihosting_connection_supported(void);
 long semihosting_file_open(const char *file_name, size_t mode);
 long semihosting_file_seek(long file_handle, ssize_t offset);
-long semihosting_file_read(long file_handle, size_t *length, void *buffer);
+long semihosting_file_read(long file_handle, size_t *length, uintptr_t buffer);
 long semihosting_file_write(long file_handle,
 			    size_t *length,
-			    const void *buffer);
+			    const uintptr_t buffer);
 long semihosting_file_close(long file_handle);
 long semihosting_file_length(long file_handle);
 long semihosting_system(char *command_line);
 long semihosting_get_flen(const char *file_name);
 long semihosting_download_file(const char *file_name,
 			       size_t buf_size,
-			       void *buf);
+			       uintptr_t buf);
 void semihosting_write_char(char character);
 void semihosting_write_string(char *string);
 char semihosting_read_char(void);
diff --git a/lib/io_storage.c b/lib/io_storage.c
index 01ca1c6..204310a 100644
--- a/lib/io_storage.c
+++ b/lib/io_storage.c
@@ -64,9 +64,9 @@
 
 
 /* Return a boolean value indicating whether a device handle is valid */
-static int is_valid_dev(io_dev_handle handle)
+static int is_valid_dev(const uintptr_t dev_handle)
 {
-	const io_dev_info_t *dev = handle;
+	const io_dev_info_t *dev = (io_dev_info_t *)dev_handle;
 	int result = (dev != NULL) && (dev->funcs != NULL) &&
 			(dev->funcs->type != NULL) &&
 			(dev->funcs->type() < IO_TYPE_MAX);
@@ -75,10 +75,11 @@
 
 
 /* Return a boolean value indicating whether an IO entity is valid */
-static int is_valid_entity(io_handle handle)
+static int is_valid_entity(const uintptr_t handle)
 {
-	const io_entity_t *entity = handle;
-	int result = (entity != NULL) && (is_valid_dev(entity->dev_handle));
+	const io_entity_t *entity = (io_entity_t *)handle;
+	int result = (entity != NULL) &&
+			(is_valid_dev((uintptr_t)entity->dev_handle));
 	return result;
 }
 
@@ -93,7 +94,7 @@
 
 
 /* Open a connection to a specific device */
-static int dev_open(const io_dev_connector_t *dev_con, void *dev_spec,
+static int dev_open(const io_dev_connector_t *dev_con, const uintptr_t dev_spec,
 		io_dev_info_t **dev_info)
 {
 	int result = IO_FAIL;
@@ -106,15 +107,15 @@
 
 
 /* Set a handle to track an entity */
-static void set_handle(io_handle *handle, io_entity_t *entity)
+static void set_handle(uintptr_t *handle, io_entity_t *entity)
 {
 	assert(handle != NULL);
-	*handle = entity;
+	*handle = (uintptr_t)entity;
 }
 
 
 /* Locate an entity in the pool, specified by address */
-static int find_first_entity(struct io_entity *entity, unsigned int *index_out)
+static int find_first_entity(const io_entity_t *entity, unsigned int *index_out)
 {
 	int result = IO_FAIL;
 	for (int index = 0; index < MAX_IO_HANDLES; ++index) {
@@ -129,7 +130,7 @@
 
 
 /* Allocate an entity from the pool and return a pointer to it */
-static int allocate_entity(struct io_entity **entity)
+static int allocate_entity(io_entity_t **entity)
 {
 	int result = IO_FAIL;
 	assert(entity != NULL);
@@ -148,7 +149,7 @@
 
 
 /* Release an entity back to the pool */
-static int free_entity(struct io_entity *entity)
+static int free_entity(const io_entity_t *entity)
 {
 	int result = IO_FAIL;
 	unsigned int index = 0;
@@ -168,7 +169,7 @@
 
 
 /* Initialise the IO layer */
-void io_init(struct io_plat_data *data)
+void io_init(io_plat_data_t *data)
 {
 	assert(data != NULL);
 	platform_data = data;
@@ -176,7 +177,7 @@
 
 
 /* Register a device driver */
-int io_register_device(struct io_dev_info *dev_info)
+int io_register_device(const io_dev_info_t *dev_info)
 {
 	int result = IO_FAIL;
 	assert(dev_info != NULL);
@@ -197,26 +198,26 @@
 
 
 /* Open a connection to an IO device */
-int io_dev_open(struct io_dev_connector *dev_con, void *dev_spec,
-		io_dev_handle *handle)
+int io_dev_open(const io_dev_connector_t *dev_con, const uintptr_t dev_spec,
+		uintptr_t *handle)
 {
 	int result = IO_FAIL;
 	assert(handle != NULL);
 
-	result = dev_open(dev_con, dev_spec, handle);
+	result = dev_open(dev_con, dev_spec, (io_dev_info_t **)handle);
 	return result;
 }
 
 
 /* Initialise an IO device explicitly - to permit lazy initialisation or
  * re-initialisation */
-int io_dev_init(struct io_dev_info *dev_handle, const void *init_params)
+int io_dev_init(uintptr_t dev_handle, const uintptr_t init_params)
 {
 	int result = IO_FAIL;
-	assert(dev_handle != NULL);
+	assert(dev_handle != (uintptr_t)NULL);
 	assert(is_valid_dev(dev_handle));
 
-	io_dev_info_t *dev = dev_handle;
+	io_dev_info_t *dev = (io_dev_info_t *)dev_handle;
 
 	if (dev->funcs->dev_init != NULL) {
 		result = dev->funcs->dev_init(dev, init_params);
@@ -231,13 +232,13 @@
 /* TODO: Consider whether an explicit "shutdown" API should be included */
 
 /* Close a connection to a device */
-int io_dev_close(io_dev_handle dev_handle)
+int io_dev_close(uintptr_t dev_handle)
 {
 	int result = IO_FAIL;
-	assert(dev_handle != NULL);
+	assert(dev_handle != (uintptr_t)NULL);
 	assert(is_valid_dev(dev_handle));
 
-	io_dev_info_t *dev = dev_handle;
+	io_dev_info_t *dev = (io_dev_info_t *)dev_handle;
 
 	if (dev->funcs->dev_close != NULL) {
 		result = dev->funcs->dev_close(dev);
@@ -254,13 +255,13 @@
 
 
 /* Open an IO entity */
-int io_open(io_dev_handle dev_handle, const void *spec, io_handle *handle)
+int io_open(uintptr_t dev_handle, const uintptr_t spec, uintptr_t *handle)
 {
 	int result = IO_FAIL;
-	assert((spec != NULL) && (handle != NULL));
+	assert((spec != (uintptr_t)NULL) && (handle != NULL));
 	assert(is_valid_dev(dev_handle));
 
-	io_dev_info_t *dev = dev_handle;
+	io_dev_info_t *dev = (io_dev_info_t *)dev_handle;
 	io_entity_t *entity;
 
 	result = allocate_entity(&entity);
@@ -270,7 +271,7 @@
 		result = dev->funcs->open(dev, spec, entity);
 
 		if (result == IO_SUCCESS) {
-			entity->dev_handle = dev_handle;
+			entity->dev_handle = dev;
 			set_handle(handle, entity);
 		} else
 			free_entity(entity);
@@ -280,12 +281,12 @@
 
 
 /* Seek to a specific position in an IO entity */
-int io_seek(io_handle handle, io_seek_mode_t mode, ssize_t offset)
+int io_seek(uintptr_t handle, io_seek_mode_t mode, ssize_t offset)
 {
 	int result = IO_FAIL;
 	assert(is_valid_entity(handle) && is_valid_seek_mode(mode));
 
-	io_entity_t *entity = handle;
+	io_entity_t *entity = (io_entity_t *)handle;
 
 	io_dev_info_t *dev = entity->dev_handle;
 
@@ -299,12 +300,12 @@
 
 
 /* Determine the length of an IO entity */
-int io_size(io_handle handle, size_t *length)
+int io_size(uintptr_t handle, size_t *length)
 {
 	int result = IO_FAIL;
 	assert(is_valid_entity(handle) && (length != NULL));
 
-	io_entity_t *entity = handle;
+	io_entity_t *entity = (io_entity_t *)handle;
 
 	io_dev_info_t *dev = entity->dev_handle;
 
@@ -318,12 +319,15 @@
 
 
 /* Read data from an IO entity */
-int io_read(io_handle handle, void *buffer, size_t length, size_t *length_read)
+int io_read(uintptr_t handle,
+		uintptr_t buffer,
+		size_t length,
+		size_t *length_read)
 {
 	int result = IO_FAIL;
-	assert(is_valid_entity(handle) && (buffer != NULL));
+	assert(is_valid_entity(handle) && (buffer != (uintptr_t)NULL));
 
-	io_entity_t *entity = handle;
+	io_entity_t *entity = (io_entity_t *)handle;
 
 	io_dev_info_t *dev = entity->dev_handle;
 
@@ -337,13 +341,15 @@
 
 
 /* Write data to an IO entity */
-int io_write(io_handle handle, const void *buffer, size_t length,
+int io_write(uintptr_t handle,
+		const uintptr_t buffer,
+		size_t length,
 		size_t *length_written)
 {
 	int result = IO_FAIL;
-	assert(is_valid_entity(handle) && (buffer != NULL));
+	assert(is_valid_entity(handle) && (buffer != (uintptr_t)NULL));
 
-	io_entity_t *entity = handle;
+	io_entity_t *entity = (io_entity_t *)handle;
 
 	io_dev_info_t *dev = entity->dev_handle;
 
@@ -358,12 +364,12 @@
 
 
 /* Close an IO entity */
-int io_close(io_handle handle)
+int io_close(uintptr_t handle)
 {
 	int result = IO_FAIL;
 	assert(is_valid_entity(handle));
 
-	io_entity_t *entity = handle;
+	io_entity_t *entity = (io_entity_t *)handle;
 
 	io_dev_info_t *dev = entity->dev_handle;
 
diff --git a/lib/semihosting/semihosting.c b/lib/semihosting/semihosting.c
index 1bce377..3c9db22 100644
--- a/lib/semihosting/semihosting.c
+++ b/lib/semihosting/semihosting.c
@@ -48,7 +48,7 @@
 
 typedef struct {
 	long handle;
-	void *buffer;
+	uintptr_t buffer;
 	size_t length;
 } smh_file_read_write_block_t;
 
@@ -96,12 +96,12 @@
 	return result;
 }
 
-long semihosting_file_read(long file_handle, size_t *length, void *buffer)
+long semihosting_file_read(long file_handle, size_t *length, uintptr_t buffer)
 {
 	smh_file_read_write_block_t read_block;
 	long result = -EINVAL;
 
-	if ((length == NULL) || (buffer == NULL))
+	if ((length == NULL) || (buffer == (uintptr_t)NULL))
 		return result;
 
 	read_block.handle = file_handle;
@@ -122,15 +122,15 @@
 
 long semihosting_file_write(long file_handle,
 			    size_t *length,
-			    const void *buffer)
+			    const uintptr_t buffer)
 {
 	smh_file_read_write_block_t write_block;
 
-	if ((length == NULL) || (buffer == NULL))
+	if ((length == NULL) || (buffer == (uintptr_t)NULL))
 		return -EINVAL;
 
 	write_block.handle = file_handle;
-	write_block.buffer = (void *)buffer;
+	write_block.buffer = (uintptr_t)buffer; /* cast away const */
 	write_block.length = *length;
 
 	*length = semihosting_call(SEMIHOSTING_SYS_WRITE,
@@ -196,7 +196,7 @@
 
 long semihosting_download_file(const char *file_name,
 			      size_t buf_size,
-			      void *buf)
+			      uintptr_t buf)
 {
 	long ret = -EINVAL;
 	size_t length;
diff --git a/plat/fvp/plat_io_storage.c b/plat/fvp/plat_io_storage.c
index 3727d26..aac8a96 100644
--- a/plat/fvp/plat_io_storage.c
+++ b/plat/fvp/plat_io_storage.c
@@ -41,69 +41,91 @@
 
 /* IO devices */
 static io_plat_data_t io_data;
-static io_dev_connector_t *sh_dev_con;
-static void *const sh_dev_spec;
-static void *const sh_init_params;
-static io_dev_handle sh_dev_handle;
-static io_dev_connector_t *fip_dev_con;
-static void *const fip_dev_spec;
-static io_dev_handle fip_dev_handle;
-static io_dev_connector_t *memmap_dev_con;
-static void *const memmap_dev_spec;
-static void *const memmap_init_params;
-static io_dev_handle memmap_dev_handle;
+static const io_dev_connector_t *sh_dev_con;
+static uintptr_t sh_dev_spec;
+static uintptr_t sh_init_params;
+static uintptr_t sh_dev_handle;
+static const io_dev_connector_t *fip_dev_con;
+static uintptr_t fip_dev_spec;
+static uintptr_t fip_dev_handle;
+static const io_dev_connector_t *memmap_dev_con;
+static uintptr_t memmap_dev_spec;
+static uintptr_t memmap_init_params;
+static uintptr_t memmap_dev_handle;
 
-static io_block_spec_t fip_block_spec = {
+static const io_block_spec_t fip_block_spec = {
 	.offset = FLASH0_BASE,
 	.length = FLASH0_SIZE
 };
 
-static io_file_spec_t bl2_file_spec = {
+static const io_file_spec_t bl2_file_spec = {
 	.path = BL2_IMAGE_NAME,
 	.mode = FOPEN_MODE_RB
 };
 
-static io_file_spec_t bl31_file_spec = {
+static const io_file_spec_t bl31_file_spec = {
 	.path = BL31_IMAGE_NAME,
 	.mode = FOPEN_MODE_RB
 };
 
-static io_file_spec_t bl32_file_spec = {
+static const io_file_spec_t bl32_file_spec = {
 	.path = BL32_IMAGE_NAME,
 	.mode = FOPEN_MODE_RB
 };
 
-static io_file_spec_t bl33_file_spec = {
+static const io_file_spec_t bl33_file_spec = {
 	.path = BL33_IMAGE_NAME,
 	.mode = FOPEN_MODE_RB
 };
 
-static int open_fip(void *spec);
-static int open_memmap(void *spec);
+static int open_fip(const uintptr_t spec);
+static int open_memmap(const uintptr_t spec);
 
 struct plat_io_policy {
 	char *image_name;
-	io_dev_handle *dev_handle;
-	void *image_spec;
-	int (*check)(void *spec);
+	uintptr_t *dev_handle;
+	uintptr_t image_spec;
+	int (*check)(const uintptr_t spec);
 };
 
-static struct plat_io_policy policies[] = {
-	{ FIP_IMAGE_NAME,  &memmap_dev_handle, &fip_block_spec, open_memmap },
-	{ BL2_IMAGE_NAME,  &fip_dev_handle,    &bl2_file_spec,  open_fip    },
-	{ BL31_IMAGE_NAME, &fip_dev_handle,    &bl31_file_spec, open_fip    },
-	{ BL32_IMAGE_NAME, &fip_dev_handle,    &bl32_file_spec, open_fip    },
-	{ BL33_IMAGE_NAME, &fip_dev_handle,    &bl33_file_spec, open_fip    },
-	{0, 0, 0 }
+static const struct plat_io_policy policies[] = {
+	{
+		FIP_IMAGE_NAME,
+		&memmap_dev_handle,
+		(uintptr_t)&fip_block_spec,
+		open_memmap
+	}, {
+		BL2_IMAGE_NAME,
+		&fip_dev_handle,
+		(uintptr_t)&bl2_file_spec,
+		open_fip
+	}, {
+		BL31_IMAGE_NAME,
+		&fip_dev_handle,
+		(uintptr_t)&bl31_file_spec,
+		open_fip
+	}, {
+		BL32_IMAGE_NAME,
+		&fip_dev_handle,
+		(uintptr_t)&bl32_file_spec,
+		open_fip
+	}, {
+		BL33_IMAGE_NAME,
+		&fip_dev_handle,
+		(uintptr_t)&bl33_file_spec,
+		open_fip
+	}, {
+		0, 0, 0
+	}
 };
 
 
-static int open_fip(void *spec)
+static int open_fip(const uintptr_t spec)
 {
 	int result = IO_FAIL;
 
 	/* See if a Firmware Image Package is available */
-	result = io_dev_init(fip_dev_handle, (void *)FIP_IMAGE_NAME);
+	result = io_dev_init(fip_dev_handle, (uintptr_t)FIP_IMAGE_NAME);
 	if (result == IO_SUCCESS) {
 		INFO("Using FIP\n");
 		/*TODO: Check image defined in spec is present in FIP. */
@@ -112,10 +134,10 @@
 }
 
 
-static int open_memmap(void *spec)
+static int open_memmap(const uintptr_t spec)
 {
 	int result = IO_FAIL;
-	io_handle local_image_handle;
+	uintptr_t local_image_handle;
 
 	result = io_dev_init(memmap_dev_handle, memmap_init_params);
 	if (result == IO_SUCCESS) {
@@ -129,10 +151,10 @@
 }
 
 
-static int open_semihosting(void *spec)
+static int open_semihosting(const uintptr_t spec)
 {
 	int result = IO_FAIL;
-	io_handle local_image_handle;
+	uintptr_t local_image_handle;
 
 	/* See if the file exists on semi-hosting.*/
 	result = io_dev_init(sh_dev_handle, sh_init_params);
@@ -181,11 +203,11 @@
 
 /* Return an IO device handle and specification which can be used to access
  * an image. Use this to enforce platform load policy */
-int plat_get_image_source(const char *image_name, io_dev_handle *dev_handle,
-			  void **image_spec)
+int plat_get_image_source(const char *image_name, uintptr_t *dev_handle,
+			  uintptr_t *image_spec)
 {
 	int result = IO_FAIL;
-	struct plat_io_policy *policy;
+	const struct plat_io_policy *policy;
 
 	if ((image_name != NULL) && (dev_handle != NULL) &&
 	    (image_spec != NULL)) {
@@ -194,8 +216,7 @@
 			if (strcmp(policy->image_name, image_name) == 0) {
 				result = policy->check(policy->image_spec);
 				if (result == IO_SUCCESS) {
-					*(io_file_spec_t **)image_spec =
-						policy->image_spec;
+					*image_spec = policy->image_spec;
 					*dev_handle = *(policy->dev_handle);
 					break;
 				} else {
@@ -203,7 +224,7 @@
 							policy->image_spec);
 					if (result == IO_SUCCESS) {
 						*dev_handle = sh_dev_handle;
-						*(io_file_spec_t **)image_spec =
+						*image_spec =
 							policy->image_spec;
 					}
 				}
diff --git a/plat/fvp/plat_pm.c b/plat/fvp/plat_pm.c
index c80d315..5430fff 100644
--- a/plat/fvp/plat_pm.c
+++ b/plat/fvp/plat_pm.c
@@ -388,7 +388,7 @@
 /*******************************************************************************
  * Export the platform handlers to enable psci to invoke them
  ******************************************************************************/
-static plat_pm_ops_t fvp_plat_pm_ops = {
+static const plat_pm_ops_t fvp_plat_pm_ops = {
 	fvp_affinst_standby,
 	fvp_affinst_on,
 	fvp_affinst_off,
@@ -400,7 +400,7 @@
 /*******************************************************************************
  * Export the platform specific power ops & initialize the fvp power controller
  ******************************************************************************/
-int platform_setup_pm(plat_pm_ops_t **plat_ops)
+int platform_setup_pm(const plat_pm_ops_t **plat_ops)
 {
 	*plat_ops = &fvp_plat_pm_ops;
 	return 0;
diff --git a/plat/fvp/platform.h b/plat/fvp/platform.h
index 1ffdc98..1f4e432 100644
--- a/plat/fvp/platform.h
+++ b/plat/fvp/platform.h
@@ -349,7 +349,6 @@
  ******************************************************************************/
 struct plat_pm_ops;
 struct meminfo;
-struct io_dev_info;
 
 /*******************************************************************************
  * Function and variable prototypes
@@ -370,7 +369,7 @@
 extern void bl1_plat_arch_setup(void);
 extern void bl2_plat_arch_setup(void);
 extern void bl31_plat_arch_setup(void);
-extern int platform_setup_pm(struct plat_pm_ops **);
+extern int platform_setup_pm(const struct plat_pm_ops **);
 extern unsigned int platform_get_core_pos(unsigned long mpidr);
 extern void disable_mmu(void);
 extern void enable_mmu(void);
@@ -401,7 +400,7 @@
 /* Declarations for plat_io_storage.c */
 extern void io_setup(void);
 extern int plat_get_image_source(const char *image_name,
-		struct io_dev_info **dev_handle, void **image_spec);
+		uintptr_t *dev_handle, uintptr_t *image_spec);
 
 /* Declarations for plat_security.c */
 extern void plat_security_setup(void);
diff --git a/services/std_svc/psci/psci_common.c b/services/std_svc/psci/psci_common.c
index 1d5c362..f24a2f0 100644
--- a/services/std_svc/psci/psci_common.c
+++ b/services/std_svc/psci/psci_common.c
@@ -74,7 +74,7 @@
 /*******************************************************************************
  * Pointer to functions exported by the platform to complete power mgmt. ops
  ******************************************************************************/
-plat_pm_ops_t *psci_plat_pm_ops;
+const plat_pm_ops_t *psci_plat_pm_ops;
 
 /*******************************************************************************
  * Routine to return the maximum affinity level to traverse to after a cpu has
diff --git a/services/std_svc/psci/psci_private.h b/services/std_svc/psci/psci_private.h
index b0b5cc9..a570958 100644
--- a/services/std_svc/psci/psci_private.h
+++ b/services/std_svc/psci/psci_private.h
@@ -88,7 +88,7 @@
 extern ns_entry_info_t psci_ns_entry_info[PSCI_NUM_AFFS];
 extern unsigned int psci_ns_einfo_idx;
 extern aff_limits_node_t psci_aff_limits[MPIDR_MAX_AFFLVL + 1];
-extern plat_pm_ops_t *psci_plat_pm_ops;
+extern const plat_pm_ops_t *psci_plat_pm_ops;
 extern aff_map_node_t psci_aff_map[PSCI_NUM_AFFS];
 extern afflvl_power_on_finisher_t psci_afflvl_off_finish_handlers[];
 extern afflvl_power_on_finisher_t psci_afflvl_sus_finish_handlers[];