staging: vc04_services: Drop VCHIQ_ERROR usage

Drop the usage of VCHIQ_ERROR vchiq_status enum type. Replace it with
-EINVAL to report the error in most cases, -ENOMEM for out-of-memory
errors and -EHOSTDOWN for service shutdown.

This patch acts as intermediatory to address the TODO item:
    * Get rid of custom function return values
for vc04_services/interface.

Signed-off-by: Umang Jain <umang.jain@ideasonboard.com>
Tested-by: Stefan Wahren <stefan.wahren@i2se.com>
Link: https://lore.kernel.org/r/20221223122404.170585-4-umang.jain@ideasonboard.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/staging/vc04_services/include/linux/raspberrypi/vchiq.h b/drivers/staging/vc04_services/include/linux/raspberrypi/vchiq.h
index 52c513e..2ca4461 100644 (file)
--- a/drivers/staging/vc04_services/include/linux/raspberrypi/vchiq.h
+++ b/drivers/staging/vc04_services/include/linux/raspberrypi/vchiq.h
@@ -18,7 +18,6 @@ enum vchiq_reason {
 };
 
 enum vchiq_status {
-       VCHIQ_ERROR   = -1,
        VCHIQ_RETRY   = 1
 };
 

diff --git a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.c b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.c
index 6e4e172..2415bae 100644 (file)
--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.c
+++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.c
@@ -501,7 +501,7 @@ int vchiq_platform_init(struct platform_device *pdev, struct vchiq_state *state)
 
        vchiq_slot_zero = vchiq_init_slots(slot_mem, slot_mem_size);
        if (!vchiq_slot_zero)
-               return -EINVAL;
+               return -ENOMEM;
 
        vchiq_slot_zero->platform_data[VCHIQ_PLATFORM_FRAGMENTS_OFFSET_IDX] =
                (int)slot_phys + slot_mem_size;
@@ -795,7 +795,7 @@ vchiq_add_service(struct vchiq_instance *instance,
                *phandle = service->handle;
                status = 0;
        } else {
-               status = VCHIQ_ERROR;
+               status = -EINVAL;
        }
 
        vchiq_log_trace(vchiq_core_log_level, "%s(%p): returning %d", __func__, instance, status);
@@ -808,7 +808,7 @@ vchiq_open_service(struct vchiq_instance *instance,
                   const struct vchiq_service_params_kernel *params,
                   unsigned int *phandle)
 {
-       enum vchiq_status   status = VCHIQ_ERROR;
+       int status = -EINVAL;
        struct vchiq_state   *state = instance->state;
        struct vchiq_service *service = NULL;
 
@@ -855,7 +855,7 @@ vchiq_bulk_transmit(struct vchiq_instance *instance, unsigned int handle, const
                                                              VCHIQ_BULK_TRANSMIT);
                        break;
                default:
-                       return VCHIQ_ERROR;
+                       return -EINVAL;
                }
 
                /*
@@ -892,7 +892,7 @@ int vchiq_bulk_receive(struct vchiq_instance *instance, unsigned int handle,
                                                              VCHIQ_BULK_RECEIVE);
                        break;
                default:
-                       return VCHIQ_ERROR;
+                       return -EINVAL;
                }
 
                /*
@@ -920,7 +920,7 @@ vchiq_blocking_bulk_transfer(struct vchiq_instance *instance, unsigned int handl
 
        service = find_service_by_handle(instance, handle);
        if (!service)
-               return VCHIQ_ERROR;
+               return -EINVAL;
 
        vchiq_service_put(service);
 
@@ -954,7 +954,7 @@ vchiq_blocking_bulk_transfer(struct vchiq_instance *instance, unsigned int handl
                waiter = kzalloc(sizeof(*waiter), GFP_KERNEL);
                if (!waiter) {
                        vchiq_log_error(vchiq_core_log_level, "%s - out of memory", __func__);
-                       return VCHIQ_ERROR;
+                       return -ENOMEM;
                }
        }
 
@@ -1127,7 +1127,7 @@ service_callback(struct vchiq_instance *instance, enum vchiq_reason reason,
                                vchiq_log_info(vchiq_arm_log_level, "%s closing", __func__);
                                DEBUG_TRACE(SERVICE_CALLBACK_LINE);
                                vchiq_service_put(service);
-                               return VCHIQ_ERROR;
+                               return -EINVAL;
                        }
                        DEBUG_TRACE(SERVICE_CALLBACK_LINE);
                        spin_lock(&msg_queue_spinlock);
@@ -1590,7 +1590,7 @@ vchiq_instance_set_trace(struct vchiq_instance *instance, int trace)
 int
 vchiq_use_service(struct vchiq_instance *instance, unsigned int handle)
 {
-       enum vchiq_status ret = VCHIQ_ERROR;
+       int ret = -EINVAL;
        struct vchiq_service *service = find_service_by_handle(instance, handle);
 
        if (service) {
@@ -1604,7 +1604,7 @@ EXPORT_SYMBOL(vchiq_use_service);
 int
 vchiq_release_service(struct vchiq_instance *instance, unsigned int handle)
 {
-       enum vchiq_status ret = VCHIQ_ERROR;
+       int ret = -EINVAL;
        struct vchiq_service *service = find_service_by_handle(instance, handle);
 
        if (service) {
@@ -1699,7 +1699,7 @@ int
 vchiq_check_service(struct vchiq_service *service)
 {
        struct vchiq_arm_state *arm_state;
-       enum vchiq_status ret = VCHIQ_ERROR;
+       int ret = -EINVAL;
 
        if (!service || !service->state)
                goto out;
@@ -1711,7 +1711,7 @@ vchiq_check_service(struct vchiq_service *service)
                ret = 0;
        read_unlock_bh(&arm_state->susp_res_lock);
 
-       if (ret == VCHIQ_ERROR) {
+       if (ret) {
                vchiq_log_error(vchiq_susp_log_level,
                                "%s ERROR - %c%c%c%c:%d service count %d, state count %d", __func__,
                                VCHIQ_FOURCC_AS_4CHARS(service->base.fourcc), service->client_id,

diff --git a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c
index aaca92d..7417cba 100644 (file)
--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c
+++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c
@@ -467,14 +467,14 @@ static inline int
 make_service_callback(struct vchiq_service *service, enum vchiq_reason reason,
                      struct vchiq_header *header, void *bulk_userdata)
 {
-       enum vchiq_status status;
+       int status;
 
        vchiq_log_trace(vchiq_core_log_level, "%d: callback:%d (%s, %pK, %pK)",
                        service->state->id, service->localport, reason_names[reason],
                        header, bulk_userdata);
        status = service->base.callback(service->instance, reason, header, service->handle,
                                        bulk_userdata);
-       if (status == VCHIQ_ERROR) {
+       if (status && (status != VCHIQ_RETRY)) {
                vchiq_log_warning(vchiq_core_log_level,
                                  "%d: ignoring ERROR from callback to service %x",
                                  service->state->id, service->handle);
@@ -940,7 +940,7 @@ queue_message(struct vchiq_state *state, struct vchiq_service *service,
                if (!service) {
                        WARN(1, "%s: service is NULL\n", __func__);
                        mutex_unlock(&state->slot_mutex);
-                       return VCHIQ_ERROR;
+                       return -EINVAL;
                }
 
                WARN_ON(flags & (QMFLAGS_NO_MUTEX_LOCK |
@@ -949,7 +949,7 @@ queue_message(struct vchiq_state *state, struct vchiq_service *service,
                if (service->closing) {
                        /* The service has been closed */
                        mutex_unlock(&state->slot_mutex);
-                       return VCHIQ_ERROR;
+                       return -EHOSTDOWN;
                }
 
                quota = &state->service_quotas[service->localport];
@@ -999,13 +999,13 @@ queue_message(struct vchiq_state *state, struct vchiq_service *service,
                        if (wait_for_completion_interruptible(&quota->quota_event))
                                return VCHIQ_RETRY;
                        if (service->closing)
-                               return VCHIQ_ERROR;
+                               return -EHOSTDOWN;
                        if (mutex_lock_killable(&state->slot_mutex))
                                return VCHIQ_RETRY;
                        if (service->srvstate != VCHIQ_SRVSTATE_OPEN) {
                                /* The service has been closed */
                                mutex_unlock(&state->slot_mutex);
-                               return VCHIQ_ERROR;
+                               return -EHOSTDOWN;
                        }
                        spin_lock(&quota_spinlock);
                        tx_end_index = SLOT_QUEUE_INDEX_FROM_POS(state->local_tx_pos + stride - 1);
@@ -1047,7 +1047,7 @@ queue_message(struct vchiq_state *state, struct vchiq_service *service,
                if (callback_result < 0) {
                        mutex_unlock(&state->slot_mutex);
                        VCHIQ_SERVICE_STATS_INC(service, error_count);
-                       return VCHIQ_ERROR;
+                       return -EINVAL;
                }
 
                if (SRVTRACE_ENABLED(service,
@@ -1195,7 +1195,7 @@ queue_message_sync(struct vchiq_state *state, struct vchiq_service *service,
        if (callback_result < 0) {
                mutex_unlock(&state->slot_mutex);
                VCHIQ_SERVICE_STATS_INC(service, error_count);
-               return VCHIQ_ERROR;
+               return -EINVAL;
        }
 
        if (service) {
@@ -2530,7 +2530,7 @@ vchiq_open_service_internal(struct vchiq_service *service, int client_id)
                                        service->state->id,
                                        srvstate_names[service->srvstate],
                                        kref_read(&service->ref_count));
-               status = VCHIQ_ERROR;
+               status = -EINVAL;
                VCHIQ_SERVICE_STATS_INC(service, error_count);
                vchiq_release_service_internal(service);
        }
@@ -2648,7 +2648,7 @@ close_service_complete(struct vchiq_service *service, int failstate)
                vchiq_log_error(vchiq_core_log_level, "%s(%x) called in state %s", __func__,
                                service->handle, srvstate_names[service->srvstate]);
                WARN(1, "%s in unexpected state\n", __func__);
-               return VCHIQ_ERROR;
+               return -EINVAL;
        }
 
        status = make_service_callback(service, VCHIQ_SERVICE_CLOSED, NULL, NULL);
@@ -2705,7 +2705,7 @@ vchiq_close_service_internal(struct vchiq_service *service, int close_recvd)
                                        __func__, srvstate_names[service->srvstate]);
                } else if (is_server) {
                        if (service->srvstate == VCHIQ_SRVSTATE_LISTENING) {
-                               status = VCHIQ_ERROR;
+                               status = -EINVAL;
                        } else {
                                service->client_id = 0;
                                service->remoteport = VCHIQ_PORT_FREE;
@@ -2896,7 +2896,7 @@ vchiq_close_service(struct vchiq_instance *instance, unsigned int handle)
        int status = 0;
 
        if (!service)
-               return VCHIQ_ERROR;
+               return -EINVAL;
 
        vchiq_log_info(vchiq_core_log_level, "%d: close_service:%d",
                       service->state->id, service->localport);
@@ -2905,7 +2905,7 @@ vchiq_close_service(struct vchiq_instance *instance, unsigned int handle)
            (service->srvstate == VCHIQ_SRVSTATE_LISTENING) ||
            (service->srvstate == VCHIQ_SRVSTATE_HIDDEN)) {
                vchiq_service_put(service);
-               return VCHIQ_ERROR;
+               return -EINVAL;
        }
 
        mark_service_closing(service);
@@ -2938,7 +2938,7 @@ vchiq_close_service(struct vchiq_instance *instance, unsigned int handle)
        if (!status &&
            (service->srvstate != VCHIQ_SRVSTATE_FREE) &&
            (service->srvstate != VCHIQ_SRVSTATE_LISTENING))
-               status = VCHIQ_ERROR;
+               status = -EINVAL;
 
        vchiq_service_put(service);
 
@@ -2954,14 +2954,14 @@ vchiq_remove_service(struct vchiq_instance *instance, unsigned int handle)
        int status = 0;
 
        if (!service)
-               return VCHIQ_ERROR;
+               return -EINVAL;
 
        vchiq_log_info(vchiq_core_log_level, "%d: remove_service:%d",
                       service->state->id, service->localport);
 
        if (service->srvstate == VCHIQ_SRVSTATE_FREE) {
                vchiq_service_put(service);
-               return VCHIQ_ERROR;
+               return -EINVAL;
        }
 
        mark_service_closing(service);
@@ -2997,7 +2997,7 @@ vchiq_remove_service(struct vchiq_instance *instance, unsigned int handle)
        }
 
        if (!status && (service->srvstate != VCHIQ_SRVSTATE_FREE))
-               status = VCHIQ_ERROR;
+               status = -EINVAL;
 
        vchiq_service_put(service);
 
@@ -3024,7 +3024,7 @@ int vchiq_bulk_transfer(struct vchiq_instance *instance, unsigned int handle,
        const char dir_char = (dir == VCHIQ_BULK_TRANSMIT) ? 't' : 'r';
        const int dir_msgtype = (dir == VCHIQ_BULK_TRANSMIT) ?
                VCHIQ_MSG_BULK_TX : VCHIQ_MSG_BULK_RX;
-       enum vchiq_status status = VCHIQ_ERROR;
+       int status = -EINVAL;
        int payload[2];
 
        if (!service)
@@ -3151,7 +3151,7 @@ waiting:
                if (wait_for_completion_interruptible(&bulk_waiter->event))
                        status = VCHIQ_RETRY;
                else if (bulk_waiter->actual == VCHIQ_BULK_ACTUAL_ABORTED)
-                       status = VCHIQ_ERROR;
+                       status = -EINVAL;
        }
 
        return status;
@@ -3177,7 +3177,7 @@ vchiq_queue_message(struct vchiq_instance *instance, unsigned int handle,
                    size_t size)
 {
        struct vchiq_service *service = find_service_by_handle(instance, handle);
-       enum vchiq_status status = VCHIQ_ERROR;
+       int status = -EINVAL;
        int data_id;
 
        if (!service)
@@ -3208,7 +3208,7 @@ vchiq_queue_message(struct vchiq_instance *instance, unsigned int handle,
                                            copy_callback, context, size, 1);
                break;
        default:
-               status = VCHIQ_ERROR;
+               status = -EINVAL;
                break;
        }
 
@@ -3288,7 +3288,7 @@ release_message_sync(struct vchiq_state *state, struct vchiq_header *header)
 int
 vchiq_get_peer_version(struct vchiq_instance *instance, unsigned int handle, short *peer_version)
 {
-       enum vchiq_status status = VCHIQ_ERROR;
+       int status = -EINVAL;
        struct vchiq_service *service = find_service_by_handle(instance, handle);
 
        if (!service)

diff --git a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_dev.c b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_dev.c
index d9c4d55..df27419 100644 (file)
--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_dev.c
+++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_dev.c
@@ -130,7 +130,7 @@ vchiq_ioc_queue_message(struct vchiq_instance *instance, unsigned int handle,
        status = vchiq_queue_message(instance, handle, vchiq_ioc_copy_element_data,
                                     &context, total_size);
 
-       if (status == VCHIQ_ERROR)
+       if (status == -EINVAL)
                return -EIO;
        else if (status == VCHIQ_RETRY)
                return -EINTR;
@@ -364,7 +364,7 @@ out:
        vchiq_service_put(service);
        if (ret)
                return ret;
-       else if (status == VCHIQ_ERROR)
+       else if (status == -EINVAL)
                return -EIO;
        else if (status == VCHIQ_RETRY)
                return -EINTR;
@@ -862,7 +862,7 @@ vchiq_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                vchiq_service_put(service);
 
        if (ret == 0) {
-               if (status == VCHIQ_ERROR)
+               if (status == -EINVAL)
                        ret = -EIO;
                else if (status == VCHIQ_RETRY)
                        ret = -EINTR;