mirror of
https://github.com/ARM-software/arm-trusted-firmware.git
synced 2025-04-16 09:34:18 +00:00
Merge pull request #423 from jcastillo-arm/jc/genfw/1211
Remove deprecated IO return definitions
This commit is contained in:
Achin Gupta
commit
135c9ddd36
8 changed files with 100 additions and 137 deletions
|
|
@ -151,11 +151,11 @@ unsigned long image_size(unsigned int image_id)
|
|||
uintptr_t image_handle;
|
||||
uintptr_t image_spec;
|
||||
size_t image_size = 0;
|
||||
int io_result = IO_FAIL;
|
||||
int io_result;
|
||||
|
||||
/* Obtain a reference to the image by querying the platform layer */
|
||||
io_result = plat_get_image_source(image_id, &dev_handle, &image_spec);
|
||||
if (io_result != IO_SUCCESS) {
|
||||
if (io_result != 0) {
|
||||
WARN("Failed to obtain reference to image id=%u (%i)\n",
|
||||
image_id, io_result);
|
||||
return 0;
|
||||
|
|
@ -163,7 +163,7 @@ unsigned long image_size(unsigned int image_id)
|
|||
|
||||
/* Attempt to access the image */
|
||||
io_result = io_open(dev_handle, image_spec, &image_handle);
|
||||
if (io_result != IO_SUCCESS) {
|
||||
if (io_result != 0) {
|
||||
WARN("Failed to access image id=%u (%i)\n",
|
||||
image_id, io_result);
|
||||
return 0;
|
||||
|
|
@ -171,7 +171,7 @@ unsigned long image_size(unsigned int image_id)
|
|||
|
||||
/* Find the size of the image */
|
||||
io_result = io_size(image_handle, &image_size);
|
||||
if ((io_result != IO_SUCCESS) || (image_size == 0)) {
|
||||
if ((io_result != 0) || (image_size == 0)) {
|
||||
WARN("Failed to determine the size of the image id=%u (%i)\n",
|
||||
image_id, io_result);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -134,14 +134,14 @@ static int fip_dev_open(const uintptr_t dev_spec __attribute__((unused)),
|
|||
assert(dev_info != NULL);
|
||||
*dev_info = (io_dev_info_t *)&fip_dev_info; /* cast away const */
|
||||
|
||||
return IO_SUCCESS;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/* Do some basic package checks. */
|
||||
static int fip_dev_init(io_dev_info_t *dev_info, const uintptr_t init_params)
|
||||
{
|
||||
int result = IO_FAIL;
|
||||
int result;
|
||||
unsigned int image_id = (unsigned int)init_params;
|
||||
uintptr_t backend_handle;
|
||||
fip_toc_header_t header;
|
||||
|
|
@ -150,28 +150,28 @@ static int fip_dev_init(io_dev_info_t *dev_info, const uintptr_t init_params)
|
|||
/* Obtain a reference to the image by querying the platform layer */
|
||||
result = plat_get_image_source(image_id, &backend_dev_handle,
|
||||
&backend_image_spec);
|
||||
if (result != IO_SUCCESS) {
|
||||
if (result != 0) {
|
||||
WARN("Failed to obtain reference to image id=%u (%i)\n",
|
||||
image_id, result);
|
||||
result = IO_FAIL;
|
||||
result = -ENOENT;
|
||||
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) {
|
||||
if (result != 0) {
|
||||
WARN("Failed to access image id=%u (%i)\n", image_id, result);
|
||||
result = IO_FAIL;
|
||||
result = -ENOENT;
|
||||
goto fip_dev_init_exit;
|
||||
}
|
||||
|
||||
result = io_read(backend_handle, (uintptr_t)&header, sizeof(header),
|
||||
&bytes_read);
|
||||
if (result == IO_SUCCESS) {
|
||||
if (result == 0) {
|
||||
if (!is_valid_header(&header)) {
|
||||
WARN("Firmware Image Package header check failed.\n");
|
||||
result = IO_FAIL;
|
||||
result = -ENOENT;
|
||||
} else {
|
||||
VERBOSE("FIP header looks OK.\n");
|
||||
}
|
||||
|
|
@ -192,7 +192,7 @@ static int fip_dev_close(io_dev_info_t *dev_info)
|
|||
backend_dev_handle = (uintptr_t)NULL;
|
||||
backend_image_spec = (uintptr_t)NULL;
|
||||
|
||||
return IO_SUCCESS;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -200,7 +200,7 @@ static int fip_dev_close(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)
|
||||
{
|
||||
int result = IO_FAIL;
|
||||
int result;
|
||||
uintptr_t backend_handle;
|
||||
const io_uuid_spec_t *uuid_spec = (io_uuid_spec_t *)spec;
|
||||
size_t bytes_read;
|
||||
|
|
@ -217,23 +217,23 @@ static int fip_file_open(io_dev_info_t *dev_info, const uintptr_t spec,
|
|||
*/
|
||||
if (current_file.entry.offset_address != 0) {
|
||||
WARN("fip_file_open : Only one open file at a time.\n");
|
||||
return IO_RESOURCES_EXHAUSTED;
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
/* Attempt to access the FIP image */
|
||||
result = io_open(backend_dev_handle, backend_image_spec,
|
||||
&backend_handle);
|
||||
if (result != IO_SUCCESS) {
|
||||
if (result != 0) {
|
||||
WARN("Failed to open Firmware Image Package (%i)\n", result);
|
||||
result = IO_FAIL;
|
||||
result = -ENOENT;
|
||||
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_t));
|
||||
if (result != IO_SUCCESS) {
|
||||
if (result != 0) {
|
||||
WARN("fip_file_open: failed to seek\n");
|
||||
result = IO_FAIL;
|
||||
result = -ENOENT;
|
||||
goto fip_file_open_close;
|
||||
}
|
||||
|
||||
|
|
@ -243,7 +243,7 @@ static int fip_file_open(io_dev_info_t *dev_info, const uintptr_t spec,
|
|||
(uintptr_t)¤t_file.entry,
|
||||
sizeof(current_file.entry),
|
||||
&bytes_read);
|
||||
if (result == IO_SUCCESS) {
|
||||
if (result == 0) {
|
||||
if (compare_uuids(¤t_file.entry.uuid,
|
||||
&uuid_spec->uuid) == 0) {
|
||||
found_file = 1;
|
||||
|
|
@ -265,7 +265,7 @@ static int fip_file_open(io_dev_info_t *dev_info, const uintptr_t spec,
|
|||
} else {
|
||||
/* Did not find the file in the FIP. */
|
||||
current_file.entry.offset_address = 0;
|
||||
result = IO_FAIL;
|
||||
result = -ENOENT;
|
||||
}
|
||||
|
||||
fip_file_open_close:
|
||||
|
|
@ -284,7 +284,7 @@ static int fip_file_len(io_entity_t *entity, size_t *length)
|
|||
|
||||
*length = ((file_state_t *)entity->info)->entry.size;
|
||||
|
||||
return IO_SUCCESS;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -292,7 +292,7 @@ static int fip_file_len(io_entity_t *entity, 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;
|
||||
int result;
|
||||
file_state_t *fp;
|
||||
size_t file_offset;
|
||||
size_t bytes_read;
|
||||
|
|
@ -306,9 +306,9 @@ static int fip_file_read(io_entity_t *entity, uintptr_t buffer, size_t length,
|
|||
/* Open the backend, attempt to access the blob image */
|
||||
result = io_open(backend_dev_handle, backend_image_spec,
|
||||
&backend_handle);
|
||||
if (result != IO_SUCCESS) {
|
||||
if (result != 0) {
|
||||
WARN("Failed to open FIP (%i)\n", result);
|
||||
result = IO_FAIL;
|
||||
result = -ENOENT;
|
||||
goto fip_file_read_exit;
|
||||
}
|
||||
|
||||
|
|
@ -317,17 +317,17 @@ static int fip_file_read(io_entity_t *entity, uintptr_t buffer, size_t length,
|
|||
/* 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) {
|
||||
if (result != 0) {
|
||||
WARN("fip_file_read: failed to seek\n");
|
||||
result = IO_FAIL;
|
||||
result = -ENOENT;
|
||||
goto fip_file_read_close;
|
||||
}
|
||||
|
||||
result = io_read(backend_handle, buffer, length, &bytes_read);
|
||||
if (result != IO_SUCCESS) {
|
||||
if (result != 0) {
|
||||
/* We cannot read our data. Fail. */
|
||||
WARN("Failed to read payload (%i)\n", result);
|
||||
result = IO_FAIL;
|
||||
result = -ENOENT;
|
||||
goto fip_file_read_close;
|
||||
} else {
|
||||
/* Set caller length and new file position. */
|
||||
|
|
@ -357,7 +357,7 @@ static int fip_file_close(io_entity_t *entity)
|
|||
/* Clear the Entity info. */
|
||||
entity->info = 0;
|
||||
|
||||
return IO_SUCCESS;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Exported functions */
|
||||
|
|
@ -365,11 +365,11 @@ static int fip_file_close(io_entity_t *entity)
|
|||
/* Register the Firmware Image Package driver with the IO abstraction */
|
||||
int register_io_dev_fip(const io_dev_connector_t **dev_con)
|
||||
{
|
||||
int result = IO_FAIL;
|
||||
int result;
|
||||
assert(dev_con != NULL);
|
||||
|
||||
result = io_register_device(&fip_dev_info);
|
||||
if (result == IO_SUCCESS)
|
||||
if (result == 0)
|
||||
*dev_con = &fip_dev_connector;
|
||||
|
||||
return result;
|
||||
|
|
|
|||
|
|
@ -101,7 +101,7 @@ static int memmap_dev_open(const uintptr_t dev_spec __attribute__((unused)),
|
|||
assert(dev_info != NULL);
|
||||
*dev_info = (io_dev_info_t *)&memmap_dev_info; /* cast away const */
|
||||
|
||||
return IO_SUCCESS;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -111,7 +111,7 @@ static int memmap_dev_close(io_dev_info_t *dev_info)
|
|||
{
|
||||
/* NOP */
|
||||
/* TODO: Consider tracking open files and cleaning them up here */
|
||||
return IO_SUCCESS;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -120,7 +120,7 @@ static int memmap_dev_close(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)
|
||||
{
|
||||
int result = IO_FAIL;
|
||||
int result = -ENOMEM;
|
||||
const io_block_spec_t *block_spec = (io_block_spec_t *)spec;
|
||||
|
||||
/* Since we need to track open state for seek() we only allow one open
|
||||
|
|
@ -136,10 +136,9 @@ static int memmap_block_open(io_dev_info_t *dev_info, const uintptr_t spec,
|
|||
/* File cursor offset for seek and incremental reads etc. */
|
||||
current_file.file_pos = 0;
|
||||
entity->info = (uintptr_t)¤t_file;
|
||||
result = IO_SUCCESS;
|
||||
result = 0;
|
||||
} else {
|
||||
WARN("A Memmap device is already active. Close first.\n");
|
||||
result = IO_RESOURCES_EXHAUSTED;
|
||||
}
|
||||
|
||||
return result;
|
||||
|
|
@ -149,7 +148,7 @@ static int memmap_block_open(io_dev_info_t *dev_info, const uintptr_t spec,
|
|||
/* Seek to a particular file offset on the memmap device */
|
||||
static int memmap_block_seek(io_entity_t *entity, int mode, ssize_t offset)
|
||||
{
|
||||
int result = IO_FAIL;
|
||||
int result = -ENOENT;
|
||||
|
||||
/* We only support IO_SEEK_SET for the moment. */
|
||||
if (mode == IO_SEEK_SET) {
|
||||
|
|
@ -157,9 +156,7 @@ static int memmap_block_seek(io_entity_t *entity, int mode, ssize_t offset)
|
|||
|
||||
/* TODO: can we do some basic limit checks on seek? */
|
||||
((file_state_t *)entity->info)->file_pos = offset;
|
||||
result = IO_SUCCESS;
|
||||
} else {
|
||||
result = IO_FAIL;
|
||||
result = 0;
|
||||
}
|
||||
|
||||
return result;
|
||||
|
|
@ -184,7 +181,7 @@ static int memmap_block_read(io_entity_t *entity, uintptr_t buffer,
|
|||
/* advance the file 'cursor' for incremental reads */
|
||||
fp->file_pos += length;
|
||||
|
||||
return IO_SUCCESS;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -207,7 +204,7 @@ static int memmap_block_write(io_entity_t *entity, const uintptr_t buffer,
|
|||
/* advance the file 'cursor' for incremental writes */
|
||||
fp->file_pos += length;
|
||||
|
||||
return IO_SUCCESS;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -221,7 +218,7 @@ static int memmap_block_close(io_entity_t *entity)
|
|||
/* This would be a mem free() if we had malloc.*/
|
||||
memset((void *)¤t_file, 0, sizeof(current_file));
|
||||
|
||||
return IO_SUCCESS;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -230,11 +227,11 @@ static int memmap_block_close(io_entity_t *entity)
|
|||
/* Register the memmap driver with the IO abstraction */
|
||||
int register_io_dev_memmap(const io_dev_connector_t **dev_con)
|
||||
{
|
||||
int result = IO_FAIL;
|
||||
int result;
|
||||
assert(dev_con != NULL);
|
||||
|
||||
result = io_register_device(&memmap_dev_info);
|
||||
if (result == IO_SUCCESS)
|
||||
if (result == 0)
|
||||
*dev_con = &memmap_dev_connector;
|
||||
|
||||
return result;
|
||||
|
|
|
|||
|
|
@ -84,10 +84,9 @@ static const io_dev_info_t sh_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 = (io_dev_info_t *)&sh_dev_info; /* cast away const */
|
||||
return result;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -95,7 +94,7 @@ static int sh_dev_open(const uintptr_t dev_spec __unused,
|
|||
static int sh_file_open(io_dev_info_t *dev_info __attribute__((unused)),
|
||||
const uintptr_t spec, io_entity_t *entity)
|
||||
{
|
||||
int result = IO_FAIL;
|
||||
int result = -ENOENT;
|
||||
long sh_result = -1;
|
||||
const io_file_spec_t *file_spec = (const io_file_spec_t *)spec;
|
||||
|
||||
|
|
@ -106,9 +105,7 @@ static int sh_file_open(io_dev_info_t *dev_info __attribute__((unused)),
|
|||
|
||||
if (sh_result > 0) {
|
||||
entity->info = (uintptr_t)sh_result;
|
||||
result = IO_SUCCESS;
|
||||
} else {
|
||||
result = IO_FAIL;
|
||||
result = 0;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
|
@ -117,7 +114,6 @@ static int sh_file_open(io_dev_info_t *dev_info __attribute__((unused)),
|
|||
/* Seek to a particular file offset on the semi-hosting device */
|
||||
static int sh_file_seek(io_entity_t *entity, int mode, ssize_t offset)
|
||||
{
|
||||
int result = IO_FAIL;
|
||||
long file_handle, sh_result;
|
||||
|
||||
assert(entity != NULL);
|
||||
|
|
@ -126,16 +122,14 @@ static int sh_file_seek(io_entity_t *entity, int mode, ssize_t offset)
|
|||
|
||||
sh_result = semihosting_file_seek(file_handle, offset);
|
||||
|
||||
result = (sh_result == 0) ? IO_SUCCESS : IO_FAIL;
|
||||
|
||||
return result;
|
||||
return (sh_result == 0) ? 0 : -ENOENT;
|
||||
}
|
||||
|
||||
|
||||
/* Return the size of a file on the semi-hosting device */
|
||||
static int sh_file_len(io_entity_t *entity, size_t *length)
|
||||
{
|
||||
int result = IO_FAIL;
|
||||
int result = -ENOENT;
|
||||
|
||||
assert(entity != NULL);
|
||||
assert(length != NULL);
|
||||
|
|
@ -144,7 +138,7 @@ static int sh_file_len(io_entity_t *entity, size_t *length)
|
|||
long sh_result = semihosting_file_length(sh_handle);
|
||||
|
||||
if (sh_result >= 0) {
|
||||
result = IO_SUCCESS;
|
||||
result = 0;
|
||||
*length = (size_t)sh_result;
|
||||
}
|
||||
|
||||
|
|
@ -156,7 +150,7 @@ static int sh_file_len(io_entity_t *entity, 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;
|
||||
int result = -ENOENT;
|
||||
long sh_result = -1;
|
||||
size_t bytes = length;
|
||||
long file_handle;
|
||||
|
|
@ -171,9 +165,8 @@ static int sh_file_read(io_entity_t *entity, uintptr_t buffer, size_t length,
|
|||
|
||||
if (sh_result >= 0) {
|
||||
*length_read = (bytes != length) ? bytes : length;
|
||||
result = IO_SUCCESS;
|
||||
} else
|
||||
result = IO_FAIL;
|
||||
result = 0;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
|
@ -197,14 +190,13 @@ static int sh_file_write(io_entity_t *entity, const uintptr_t buffer,
|
|||
|
||||
*length_written = length - bytes;
|
||||
|
||||
return (sh_result == 0) ? IO_SUCCESS : IO_FAIL;
|
||||
return (sh_result == 0) ? 0 : -ENOENT;
|
||||
}
|
||||
|
||||
|
||||
/* Close a file on the semi-hosting device */
|
||||
static int sh_file_close(io_entity_t *entity)
|
||||
{
|
||||
int result = IO_FAIL;
|
||||
long sh_result = -1;
|
||||
long file_handle;
|
||||
|
||||
|
|
@ -214,9 +206,7 @@ static int sh_file_close(io_entity_t *entity)
|
|||
|
||||
sh_result = semihosting_file_close(file_handle);
|
||||
|
||||
result = (sh_result >= 0) ? IO_SUCCESS : IO_FAIL;
|
||||
|
||||
return result;
|
||||
return (sh_result >= 0) ? 0 : -ENOENT;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -225,11 +215,11 @@ static int sh_file_close(io_entity_t *entity)
|
|||
/* Register the semi-hosting driver with the IO abstraction */
|
||||
int register_io_dev_sh(const io_dev_connector_t **dev_con)
|
||||
{
|
||||
int result = IO_FAIL;
|
||||
int result;
|
||||
assert(dev_con != NULL);
|
||||
|
||||
result = io_register_device(&sh_dev_info);
|
||||
if (result == IO_SUCCESS)
|
||||
if (result == 0)
|
||||
*dev_con = &sh_dev_connector;
|
||||
|
||||
return result;
|
||||
|
|
|
|||
|
|
@ -96,7 +96,7 @@ static int is_valid_seek_mode(io_seek_mode_t mode)
|
|||
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;
|
||||
int result;
|
||||
assert(dev_info != NULL);
|
||||
assert(is_valid_dev_connector(dev_con));
|
||||
|
||||
|
|
@ -116,10 +116,10 @@ static void set_handle(uintptr_t *handle, io_entity_t *entity)
|
|||
/* Locate an entity in the pool, specified by address */
|
||||
static int find_first_entity(const io_entity_t *entity, unsigned int *index_out)
|
||||
{
|
||||
int result = IO_FAIL;
|
||||
int result = -ENOENT;
|
||||
for (int index = 0; index < MAX_IO_HANDLES; ++index) {
|
||||
if (entity_map[index] == entity) {
|
||||
result = IO_SUCCESS;
|
||||
result = 0;
|
||||
*index_out = index;
|
||||
break;
|
||||
}
|
||||
|
|
@ -131,17 +131,16 @@ static int find_first_entity(const io_entity_t *entity, unsigned int *index_out)
|
|||
/* Allocate an entity from the pool and return a pointer to it */
|
||||
static int allocate_entity(io_entity_t **entity)
|
||||
{
|
||||
int result = IO_FAIL;
|
||||
int result = -ENOMEM;
|
||||
assert(entity != NULL);
|
||||
|
||||
if (entity_count < MAX_IO_HANDLES) {
|
||||
unsigned int index = 0;
|
||||
result = find_first_entity(NULL, &index);
|
||||
assert(result == IO_SUCCESS);
|
||||
assert(result == 0);
|
||||
*entity = entity_map[index] = &entity_pool[index];
|
||||
++entity_count;
|
||||
} else
|
||||
result = IO_RESOURCES_EXHAUSTED;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
|
@ -150,12 +149,12 @@ static int allocate_entity(io_entity_t **entity)
|
|||
/* Release an entity back to the pool */
|
||||
static int free_entity(const io_entity_t *entity)
|
||||
{
|
||||
int result = IO_FAIL;
|
||||
int result;
|
||||
unsigned int index = 0;
|
||||
assert(entity != NULL);
|
||||
|
||||
result = find_first_entity(entity, &index);
|
||||
if (result == IO_SUCCESS) {
|
||||
if (result == 0) {
|
||||
entity_map[index] = NULL;
|
||||
--entity_count;
|
||||
}
|
||||
|
|
@ -169,15 +168,13 @@ static int free_entity(const io_entity_t *entity)
|
|||
/* Register a device driver */
|
||||
int io_register_device(const io_dev_info_t *dev_info)
|
||||
{
|
||||
int result = IO_FAIL;
|
||||
int result = -ENOMEM;
|
||||
assert(dev_info != NULL);
|
||||
|
||||
if (dev_count < MAX_IO_DEVICES) {
|
||||
devices[dev_count] = dev_info;
|
||||
dev_count++;
|
||||
result = IO_SUCCESS;
|
||||
} else {
|
||||
result = IO_RESOURCES_EXHAUSTED;
|
||||
result = 0;
|
||||
}
|
||||
|
||||
return result;
|
||||
|
|
@ -188,7 +185,7 @@ int io_register_device(const io_dev_info_t *dev_info)
|
|||
int io_dev_open(const io_dev_connector_t *dev_con, const uintptr_t dev_spec,
|
||||
uintptr_t *handle)
|
||||
{
|
||||
int result = IO_FAIL;
|
||||
int result;
|
||||
assert(handle != NULL);
|
||||
|
||||
result = dev_open(dev_con, dev_spec, (io_dev_info_t **)handle);
|
||||
|
|
@ -200,18 +197,17 @@ int io_dev_open(const io_dev_connector_t *dev_con, const uintptr_t dev_spec,
|
|||
* re-initialisation */
|
||||
int io_dev_init(uintptr_t dev_handle, const uintptr_t init_params)
|
||||
{
|
||||
int result = IO_FAIL;
|
||||
int result = 0;
|
||||
assert(dev_handle != (uintptr_t)NULL);
|
||||
assert(is_valid_dev(dev_handle));
|
||||
|
||||
io_dev_info_t *dev = (io_dev_info_t *)dev_handle;
|
||||
|
||||
/* Absence of registered function implies NOP here */
|
||||
if (dev->funcs->dev_init != NULL) {
|
||||
result = dev->funcs->dev_init(dev, init_params);
|
||||
} else {
|
||||
/* Absence of registered function implies NOP here */
|
||||
result = IO_SUCCESS;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
|
@ -221,17 +217,15 @@ int io_dev_init(uintptr_t dev_handle, const uintptr_t init_params)
|
|||
/* Close a connection to a device */
|
||||
int io_dev_close(uintptr_t dev_handle)
|
||||
{
|
||||
int result = IO_FAIL;
|
||||
int result = 0;
|
||||
assert(dev_handle != (uintptr_t)NULL);
|
||||
assert(is_valid_dev(dev_handle));
|
||||
|
||||
io_dev_info_t *dev = (io_dev_info_t *)dev_handle;
|
||||
|
||||
/* Absence of registered function implies NOP here */
|
||||
if (dev->funcs->dev_close != NULL) {
|
||||
result = dev->funcs->dev_close(dev);
|
||||
} else {
|
||||
/* Absence of registered function implies NOP here */
|
||||
result = IO_SUCCESS;
|
||||
}
|
||||
|
||||
return result;
|
||||
|
|
@ -244,7 +238,7 @@ int io_dev_close(uintptr_t dev_handle)
|
|||
/* Open an IO entity */
|
||||
int io_open(uintptr_t dev_handle, const uintptr_t spec, uintptr_t *handle)
|
||||
{
|
||||
int result = IO_FAIL;
|
||||
int result;
|
||||
assert((spec != (uintptr_t)NULL) && (handle != NULL));
|
||||
assert(is_valid_dev(dev_handle));
|
||||
|
||||
|
|
@ -253,11 +247,11 @@ int io_open(uintptr_t dev_handle, const uintptr_t spec, uintptr_t *handle)
|
|||
|
||||
result = allocate_entity(&entity);
|
||||
|
||||
if (result == IO_SUCCESS) {
|
||||
if (result == 0) {
|
||||
assert(dev->funcs->open != NULL);
|
||||
result = dev->funcs->open(dev, spec, entity);
|
||||
|
||||
if (result == IO_SUCCESS) {
|
||||
if (result == 0) {
|
||||
entity->dev_handle = dev;
|
||||
set_handle(handle, entity);
|
||||
} else
|
||||
|
|
@ -270,7 +264,7 @@ int io_open(uintptr_t dev_handle, const uintptr_t spec, uintptr_t *handle)
|
|||
/* Seek to a specific position in an IO entity */
|
||||
int io_seek(uintptr_t handle, io_seek_mode_t mode, ssize_t offset)
|
||||
{
|
||||
int result = IO_FAIL;
|
||||
int result = -ENODEV;
|
||||
assert(is_valid_entity(handle) && is_valid_seek_mode(mode));
|
||||
|
||||
io_entity_t *entity = (io_entity_t *)handle;
|
||||
|
|
@ -279,8 +273,6 @@ int io_seek(uintptr_t handle, io_seek_mode_t mode, ssize_t offset)
|
|||
|
||||
if (dev->funcs->seek != NULL)
|
||||
result = dev->funcs->seek(entity, mode, offset);
|
||||
else
|
||||
result = IO_NOT_SUPPORTED;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
|
@ -289,7 +281,7 @@ int io_seek(uintptr_t handle, io_seek_mode_t mode, ssize_t offset)
|
|||
/* Determine the length of an IO entity */
|
||||
int io_size(uintptr_t handle, size_t *length)
|
||||
{
|
||||
int result = IO_FAIL;
|
||||
int result = -ENODEV;
|
||||
assert(is_valid_entity(handle) && (length != NULL));
|
||||
|
||||
io_entity_t *entity = (io_entity_t *)handle;
|
||||
|
|
@ -298,8 +290,6 @@ int io_size(uintptr_t handle, size_t *length)
|
|||
|
||||
if (dev->funcs->size != NULL)
|
||||
result = dev->funcs->size(entity, length);
|
||||
else
|
||||
result = IO_NOT_SUPPORTED;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
|
@ -311,7 +301,7 @@ int io_read(uintptr_t handle,
|
|||
size_t length,
|
||||
size_t *length_read)
|
||||
{
|
||||
int result = IO_FAIL;
|
||||
int result = -ENODEV;
|
||||
assert(is_valid_entity(handle) && (buffer != (uintptr_t)NULL));
|
||||
|
||||
io_entity_t *entity = (io_entity_t *)handle;
|
||||
|
|
@ -320,8 +310,6 @@ int io_read(uintptr_t handle,
|
|||
|
||||
if (dev->funcs->read != NULL)
|
||||
result = dev->funcs->read(entity, buffer, length, length_read);
|
||||
else
|
||||
result = IO_NOT_SUPPORTED;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
|
@ -333,7 +321,7 @@ int io_write(uintptr_t handle,
|
|||
size_t length,
|
||||
size_t *length_written)
|
||||
{
|
||||
int result = IO_FAIL;
|
||||
int result = -ENODEV;
|
||||
assert(is_valid_entity(handle) && (buffer != (uintptr_t)NULL));
|
||||
|
||||
io_entity_t *entity = (io_entity_t *)handle;
|
||||
|
|
@ -343,8 +331,7 @@ int io_write(uintptr_t handle,
|
|||
if (dev->funcs->write != NULL) {
|
||||
result = dev->funcs->write(entity, buffer, length,
|
||||
length_written);
|
||||
} else
|
||||
result = IO_NOT_SUPPORTED;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
|
@ -353,19 +340,17 @@ int io_write(uintptr_t handle,
|
|||
/* Close an IO entity */
|
||||
int io_close(uintptr_t handle)
|
||||
{
|
||||
int result = IO_FAIL;
|
||||
int result = 0;
|
||||
assert(is_valid_entity(handle));
|
||||
|
||||
io_entity_t *entity = (io_entity_t *)handle;
|
||||
|
||||
io_dev_info_t *dev = entity->dev_handle;
|
||||
|
||||
/* Absence of registered function implies NOP here */
|
||||
if (dev->funcs->close != NULL)
|
||||
result = dev->funcs->close(entity);
|
||||
else {
|
||||
/* Absence of registered function implies NOP here */
|
||||
result = IO_SUCCESS;
|
||||
}
|
||||
|
||||
/* Ignore improbable free_entity failure */
|
||||
(void)free_entity(entity);
|
||||
|
||||
|
|
|
|||
|
|
@ -89,15 +89,6 @@ typedef struct io_block_spec {
|
|||
#define IO_MODE_RW (1 << 1)
|
||||
|
||||
|
||||
/* Return codes reported by 'io_*' APIs.
|
||||
* IMPORTANT: these definitions are deprecated. Callers should use standard
|
||||
* errno definitions when checking the return value of io_* APIs. */
|
||||
#define IO_SUCCESS (0)
|
||||
#define IO_FAIL (-ENOENT)
|
||||
#define IO_NOT_SUPPORTED (-ENODEV)
|
||||
#define IO_RESOURCES_EXHAUSTED (-ENOMEM)
|
||||
|
||||
|
||||
/* Open a connection to a device */
|
||||
int io_dev_open(const struct io_dev_connector *dev_con,
|
||||
const uintptr_t dev_spec,
|
||||
|
|
|
|||
|
|
@ -114,14 +114,14 @@ static const io_file_spec_t sh_file_spec[] = {
|
|||
|
||||
static int open_semihosting(const uintptr_t spec)
|
||||
{
|
||||
int result = IO_FAIL;
|
||||
int result;
|
||||
uintptr_t local_image_handle;
|
||||
|
||||
/* See if the file exists on semi-hosting.*/
|
||||
result = io_dev_init(sh_dev_handle, (uintptr_t)NULL);
|
||||
if (result == IO_SUCCESS) {
|
||||
if (result == 0) {
|
||||
result = io_open(sh_dev_handle, spec, &local_image_handle);
|
||||
if (result == IO_SUCCESS) {
|
||||
if (result == 0) {
|
||||
VERBOSE("Using Semi-hosting IO\n");
|
||||
io_close(local_image_handle);
|
||||
}
|
||||
|
|
@ -137,11 +137,11 @@ void plat_arm_io_setup(void)
|
|||
|
||||
/* Register the additional IO devices on this platform */
|
||||
io_result = register_io_dev_sh(&sh_dev_con);
|
||||
assert(io_result == IO_SUCCESS);
|
||||
assert(io_result == 0);
|
||||
|
||||
/* Open connections to devices and cache the handles */
|
||||
io_result = io_dev_open(sh_dev_con, (uintptr_t)NULL, &sh_dev_handle);
|
||||
assert(io_result == IO_SUCCESS);
|
||||
assert(io_result == 0);
|
||||
|
||||
/* Ignore improbable errors in release builds */
|
||||
(void)io_result;
|
||||
|
|
@ -154,7 +154,7 @@ int plat_arm_get_alt_image_source(unsigned int image_id, uintptr_t *dev_handle,
|
|||
uintptr_t *image_spec)
|
||||
{
|
||||
int result = open_semihosting((const uintptr_t)&sh_file_spec[image_id]);
|
||||
if (result == IO_SUCCESS) {
|
||||
if (result == 0) {
|
||||
*dev_handle = sh_dev_handle;
|
||||
*image_spec = (uintptr_t)&sh_file_spec[image_id];
|
||||
}
|
||||
|
|
|
|||
|
|
@ -220,9 +220,9 @@ static int open_fip(const uintptr_t spec)
|
|||
|
||||
/* See if a Firmware Image Package is available */
|
||||
result = io_dev_init(fip_dev_handle, (uintptr_t)FIP_IMAGE_ID);
|
||||
if (result == IO_SUCCESS) {
|
||||
if (result == 0) {
|
||||
result = io_open(fip_dev_handle, spec, &local_image_handle);
|
||||
if (result == IO_SUCCESS) {
|
||||
if (result == 0) {
|
||||
VERBOSE("Using FIP\n");
|
||||
io_close(local_image_handle);
|
||||
}
|
||||
|
|
@ -237,9 +237,9 @@ static int open_memmap(const uintptr_t spec)
|
|||
uintptr_t local_image_handle;
|
||||
|
||||
result = io_dev_init(memmap_dev_handle, (uintptr_t)NULL);
|
||||
if (result == IO_SUCCESS) {
|
||||
if (result == 0) {
|
||||
result = io_open(memmap_dev_handle, spec, &local_image_handle);
|
||||
if (result == IO_SUCCESS) {
|
||||
if (result == 0) {
|
||||
VERBOSE("Using Memmap\n");
|
||||
io_close(local_image_handle);
|
||||
}
|
||||
|
|
@ -253,19 +253,19 @@ void arm_io_setup(void)
|
|||
int io_result;
|
||||
|
||||
io_result = register_io_dev_fip(&fip_dev_con);
|
||||
assert(io_result == IO_SUCCESS);
|
||||
assert(io_result == 0);
|
||||
|
||||
io_result = register_io_dev_memmap(&memmap_dev_con);
|
||||
assert(io_result == IO_SUCCESS);
|
||||
assert(io_result == 0);
|
||||
|
||||
/* Open connections to devices and cache the handles */
|
||||
io_result = io_dev_open(fip_dev_con, (uintptr_t)NULL,
|
||||
&fip_dev_handle);
|
||||
assert(io_result == IO_SUCCESS);
|
||||
assert(io_result == 0);
|
||||
|
||||
io_result = io_dev_open(memmap_dev_con, (uintptr_t)NULL,
|
||||
&memmap_dev_handle);
|
||||
assert(io_result == IO_SUCCESS);
|
||||
assert(io_result == 0);
|
||||
|
||||
/* Ignore improbable errors in release builds */
|
||||
(void)io_result;
|
||||
|
|
@ -282,7 +282,7 @@ int plat_arm_get_alt_image_source(
|
|||
uintptr_t *image_spec __attribute__((unused)))
|
||||
{
|
||||
/* By default do not try an alternative */
|
||||
return IO_FAIL;
|
||||
return -ENOENT;
|
||||
}
|
||||
|
||||
/* Return an IO device handle and specification which can be used to access
|
||||
|
|
@ -290,14 +290,14 @@ int plat_arm_get_alt_image_source(
|
|||
int plat_get_image_source(unsigned int image_id, uintptr_t *dev_handle,
|
||||
uintptr_t *image_spec)
|
||||
{
|
||||
int result = IO_FAIL;
|
||||
int result;
|
||||
const struct plat_io_policy *policy;
|
||||
|
||||
assert(image_id < ARRAY_SIZE(policies));
|
||||
|
||||
policy = &policies[image_id];
|
||||
result = policy->check(policy->image_spec);
|
||||
if (result == IO_SUCCESS) {
|
||||
if (result == 0) {
|
||||
*image_spec = policy->image_spec;
|
||||
*dev_handle = *(policy->dev_handle);
|
||||
} else {
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue