Remove deprecated IO return definitions

Patch 7e26fe1f deprecates IO specific return definitions in favour
of standard errno codes. This patch removes those definitions
and its usage from the IO framework, IO drivers and IO platform
layer. Following this patch, standard errno codes must be used
when checking the return value of an IO function.

Change-Id: Id6e0e9d0a7daf15a81ec598cf74de83d5768650f

diff --git a/common/bl_common.c b/common/bl_common.c
index 91a0ae8c43f31414112badb533af5bf94cf96d3d..aeda69aa7de793c29827a23f2d6e66d79b2aa7b2 100644 (file)
--- a/common/bl_common.c
+++ b/common/bl_common.c
@@ -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);
        }

diff --git a/drivers/io/io_fip.c b/drivers/io/io_fip.c
index 5a8a294a02a38b032b6fb549d03ade5e8697d357..d2914238052cb4268e71e20f2aa922ae4c2da095 100644 (file)
--- a/drivers/io/io_fip.c
+++ b/drivers/io/io_fip.c
@@ -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)&current_file.entry,
                                 sizeof(current_file.entry),
                                 &bytes_read);
-               if (result == IO_SUCCESS) {
+               if (result == 0) {
                        if (compare_uuids(&current_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;

diff --git a/drivers/io/io_memmap.c b/drivers/io/io_memmap.c
index fc06fbb90cb33286636aa14fd33c3bca96b35d8c..d45107e516a83f1c263a85f333869fdb97921919 100644 (file)
--- a/drivers/io/io_memmap.c
+++ b/drivers/io/io_memmap.c
@@ -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)&current_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 *)&current_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;

diff --git a/drivers/io/io_semihosting.c b/drivers/io/io_semihosting.c
index 8e62be1d961c31c1370c367226d69c01c04f6d6d..63d0f68ec02a8eb1895f58afcbfa9f264425c4bd 100644 (file)
--- a/drivers/io/io_semihosting.c
+++ b/drivers/io/io_semihosting.c
@@ -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;

diff --git a/drivers/io/io_storage.c b/drivers/io/io_storage.c
index a3a8186d0fede11f1a327004ca6e84de56c8355a..7cb1a6aa2e5988ed9755bb20e38de297f0843c96 100644 (file)
--- a/drivers/io/io_storage.c
+++ b/drivers/io/io_storage.c
@@ -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);
 

diff --git a/include/drivers/io/io_storage.h b/include/drivers/io/io_storage.h
index 4c3526ef10b2d7f4d3ece2caee75409cd3b2b532..970ab2cd10aad7fa7805e6e5989618e9a8f2460a 100644 (file)
--- a/include/drivers/io/io_storage.h
+++ b/include/drivers/io/io_storage.h
@@ -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,

diff --git a/plat/arm/board/fvp/fvp_io_storage.c b/plat/arm/board/fvp/fvp_io_storage.c
index e9d847f69a4675282628647144be4296a3001a3c..0b74de2e251a39f1df0b87c5fbf4aa1fefdfa3e7 100644 (file)
--- a/plat/arm/board/fvp/fvp_io_storage.c
+++ b/plat/arm/board/fvp/fvp_io_storage.c
@@ -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];
        }

diff --git a/plat/arm/common/arm_io_storage.c b/plat/arm/common/arm_io_storage.c
index 8488f1213c04e5d6bac352ee0d7c581788760da8..ae67cde00deed17fe093be1d55e3a42aa61b3d12 100644 (file)
--- a/plat/arm/common/arm_io_storage.c
+++ b/plat/arm/common/arm_io_storage.c
@@ -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 {