andrius
/
arm-trusted-firmware
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Remove variables from .data section 

Update code base to remove variables from the .data section,
mainly by using const static data where possible and adding
the const specifier as required. Most changes are to the IO
subsystem, including the framework APIs. The FVP power
management code is also affected.

Delay initialization of the global static variable,
next_image_type in bl31_main.c, until it is realy needed.
Doing this moves the variable from the .data to the .bss
section.

Also review the IO interface for inconsistencies, using
uintptr_t where possible instead of void *. Remove the
io_handle and io_dev_handle typedefs, which were
unnecessary, replacing instances with uintptr_t.

Fixes ARM-software/tf-issues#107.

Change-Id: I085a62197c82410b566e4698e5590063563ed304
This commit is contained in:
Dan Handley 2014-04-23 13:47:06 +01:00
parent 408c37682a
commit 625de1d4f0
18 changed files with 224 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
bl31/bl31_main.c
View File

@ -50,7 +50,7 @@ static int32_t (*bl32_init)(meminfo_t *);
* 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 @@ void bl31_main(void)
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

14
common/bl_common.c
View File

@ -251,9 +251,9 @@ static void dump_load_info(unsigned long image_load_addr,
/* 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 long load_image(meminfo_t *mem_layout,
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 @@ unsigned long load_image(meminfo_t *mem_layout,
/* 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;

53
drivers/io/io_fip.c
View File

@ -62,7 +62,7 @@ typedef struct {
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 plat_fip_name_uuid_t name_uuid[] = {
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 @@ io_type_t device_type_fip(void)
}
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_funcs fip_dev_funcs = {
};
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 @@ static int fip_dev_init(io_dev_info_t *dev_info, const void *init_params)
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 @@ static int fip_dev_close(io_dev_info_t *dev_info)
/* 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 @@ static int fip_file_open(io_dev_info_t *dev_info, const void *spec,
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 @@ static int fip_file_len(io_entity_t *entity, size_t *length)
/* 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 @@ static int fip_file_close(io_entity_t *entity)
/* 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);

41
drivers/io/io_memmap.c
View File

@ -42,9 +42,9 @@ typedef struct {
/* 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 @@ io_type_t device_type_memmap(void)
}
/* 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_funcs memmap_dev_funcs = {
};
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 @@ static int memmap_dev_close(io_dev_info_t *dev_info)
/* 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 @@ static int memmap_block_seek(io_entity_t *entity, int mode, ssize_t offset)
/* 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 @@ static int memmap_block_read(io_entity_t *entity, void *buffer,
/* 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 @@ static int memmap_block_close(io_entity_t *entity)
/* 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);

34
drivers/io/io_semihosting.c
View File

@ -44,23 +44,23 @@ static io_type_t device_type_sh(void)
/* 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_funcs sh_dev_funcs = {
};
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 @@ static int sh_file_len(io_entity_t *entity, size_t *length)
/* 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 @@ static int sh_file_read(io_entity_t *entity, void *buffer, size_t length,
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 @@ static int sh_file_read(io_entity_t *entity, void *buffer, size_t length,
/* 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 @@ static int sh_file_write(io_entity_t *entity, const void *buffer,
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 @@ static int sh_file_close(io_entity_t *entity)
/* 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);

18
include/drivers/io_driver.h
View File

@ -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 @@ typedef struct io_entity {
/* 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 @@ typedef struct io_dev_info {
/* 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 @@ typedef struct io_dev_funcs {
/* 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 @@ typedef struct io_plat_data {
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__ */

2
include/drivers/io_fip.h
View File

@ -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__ */

2
include/drivers/io_memmap.h
View File

@ -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__ */

2
include/drivers/io_semihosting.h
View File

@ -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__ */

32
include/lib/io_storage.h
View File

@ -31,6 +31,7 @@
#ifndef __IO_H__
#define __IO_H__
#include <stdint.h>
#include <stdio.h> /* For ssize_t */
@ -58,13 +59,6 @@ typedef enum {
/* 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 @@ typedef struct io_file_spec {
/* 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 @@ typedef struct io_block_spec {
/* 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__ */

7
include/lib/semihosting.h
View File

@ -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);

82
lib/io_storage.c
View File

@ -64,9 +64,9 @@ static int is_valid_dev_connector(const io_dev_connector_t *dev_con)
/* 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 @@ static int is_valid_dev(io_dev_handle handle)
/* 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 @@ static int is_valid_seek_mode(io_seek_mode_t mode)
/* 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 @@ static int dev_open(const io_dev_connector_t *dev_con, void *dev_spec,
/* 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 @@ static int find_first_entity(struct io_entity *entity, unsigned int *index_out)
/* 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 @@ static int allocate_entity(struct io_entity **entity)
/* 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 @@ static int free_entity(struct io_entity *entity)
/* 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 @@ void io_init(struct io_plat_data *data)
/* 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 @@ int io_register_device(struct io_dev_info *dev_info)
/* 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 @@ int io_dev_init(struct io_dev_info *dev_handle, const void *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)
{
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 @@ int io_dev_close(io_dev_handle dev_handle)
/* 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 @@ int io_open(io_dev_handle dev_handle, const void *spec, io_handle *handle)
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 @@ int io_open(io_dev_handle dev_handle, const void *spec, io_handle *handle)
/* 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 @@ int io_seek(io_handle handle, io_seek_mode_t mode, ssize_t offset)
/* 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 @@ int io_size(io_handle handle, size_t *length)
/* 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 @@ int io_read(io_handle handle, void *buffer, size_t length, size_t *length_read)
/* 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 @@ int io_write(io_handle handle, const void *buffer, size_t length,
/* 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;

14
lib/semihosting/semihosting.c
View File

@ -48,7 +48,7 @@ typedef struct {
typedef struct {
long handle;
void *buffer;
uintptr_t buffer;
size_t length;
} smh_file_read_write_block_t;
@ -96,12 +96,12 @@ long semihosting_file_seek(long file_handle, ssize_t offset)
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_read(long file_handle, size_t *length, void *buffer)
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_get_flen(const char *file_name)
long semihosting_download_file(const char *file_name,
size_t buf_size,
void *buf)
uintptr_t buf)
{
long ret = -EINVAL;
size_t length;

101
plat/fvp/plat_io_storage.c
View File

@ -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_fip(void *spec)
}
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_memmap(void *spec)
}
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 @@ void io_setup (void)
/* 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 @@ int plat_get_image_source(const char *image_name, io_dev_handle *dev_handle,
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 @@ int plat_get_image_source(const char *image_name, io_dev_handle *dev_handle,
policy->image_spec);
if (result == IO_SUCCESS) {
*dev_handle = sh_dev_handle;
*(io_file_spec_t **)image_spec =
*image_spec =
policy->image_spec;
}
}

4
plat/fvp/plat_pm.c
View File

@ -388,7 +388,7 @@ int fvp_affinst_suspend_finish(unsigned long mpidr,
/*******************************************************************************
* 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 @@ static plat_pm_ops_t fvp_plat_pm_ops = {
/*******************************************************************************
* 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;

5
plat/fvp/platform.h
View File

@ -349,7 +349,6 @@ typedef volatile struct mailbox {
******************************************************************************/
struct plat_pm_ops;
struct meminfo;
struct io_dev_info;
/*******************************************************************************
* Function and variable prototypes
@ -370,7 +369,7 @@ extern unsigned long warm_boot_entrypoint;
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 @@ extern unsigned int plat_get_aff_state(unsigned int, unsigned long);
/* 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);

2
services/std_svc/psci/psci_common.c
View File

@ -74,7 +74,7 @@ aff_limits_node_t psci_aff_limits[MPIDR_MAX_AFFLVL + 1];
/*******************************************************************************
* 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

2
services/std_svc/psci/psci_private.h
View File

@ -88,7 +88,7 @@ extern suspend_context_t psci_suspend_context[PSCI_NUM_AFFS];
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[];