staging: vc04_services: Drop VCHIQ_RETRY usage

Drop the usage of VCHIQ_RETRY vchiq_status enum type in most of the
places and replace it with -EAGAIN. The exception to this replacement
is vchiq_send_remote_use() and vchiq_send_remote_use_active() which will
be addressed in the subsequent commit.

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-5-umang.jain@ideasonboard.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

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 2415bae..5cfad84 100644 (file)
--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.c
+++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.c
@@ -728,7 +728,7 @@ int vchiq_shutdown(struct vchiq_instance *instance)
        struct vchiq_state *state = instance->state;
 
        if (mutex_lock_killable(&state->mutex))
-               return VCHIQ_RETRY;
+               return -EAGAIN;
 
        /* Remove all services */
        vchiq_shutdown_internal(state, instance);
@@ -756,7 +756,7 @@ int vchiq_connect(struct vchiq_instance *instance)
 
        if (mutex_lock_killable(&state->mutex)) {
                vchiq_log_trace(vchiq_core_log_level, "%s: call to mutex_lock failed", __func__);
-               status = VCHIQ_RETRY;
+               status = -EAGAIN;
                goto failed;
        }
        status = vchiq_connect_internal(state, instance);
@@ -859,11 +859,11 @@ vchiq_bulk_transmit(struct vchiq_instance *instance, unsigned int handle, const
                }
 
                /*
-                * vchiq_*_bulk_transfer() may return VCHIQ_RETRY, so we need
+                * vchiq_*_bulk_transfer() may return -EAGAIN, so we need
                 * to implement a retry mechanism since this function is
                 * supposed to block until queued
                 */
-               if (status != VCHIQ_RETRY)
+               if (status != -EAGAIN)
                        break;
 
                msleep(1);
@@ -896,11 +896,11 @@ int vchiq_bulk_receive(struct vchiq_instance *instance, unsigned int handle,
                }
 
                /*
-                * vchiq_*_bulk_transfer() may return VCHIQ_RETRY, so we need
+                * vchiq_*_bulk_transfer() may return -EAGAIN, so we need
                 * to implement a retry mechanism since this function is
                 * supposed to block until queued
                 */
-               if (status != VCHIQ_RETRY)
+               if (status != -EAGAIN)
                        break;
 
                msleep(1);
@@ -961,7 +961,7 @@ vchiq_blocking_bulk_transfer(struct vchiq_instance *instance, unsigned int handl
        status = vchiq_bulk_transfer(instance, handle, data, NULL, size,
                                     &waiter->bulk_waiter,
                                     VCHIQ_BULK_MODE_BLOCKING, dir);
-       if ((status != VCHIQ_RETRY) || fatal_signal_pending(current) || !waiter->bulk_waiter.bulk) {
+       if ((status != -EAGAIN) || fatal_signal_pending(current) || !waiter->bulk_waiter.bulk) {
                struct vchiq_bulk *bulk = waiter->bulk_waiter.bulk;
 
                if (bulk) {
@@ -1001,7 +1001,7 @@ add_completion(struct vchiq_instance *instance, enum vchiq_reason reason,
                DEBUG_COUNT(COMPLETION_QUEUE_FULL_COUNT);
                if (wait_for_completion_interruptible(&instance->remove_event)) {
                        vchiq_log_info(vchiq_arm_log_level, "service_callback interrupted");
-                       return VCHIQ_RETRY;
+                       return -EAGAIN;
                } else if (instance->closing) {
                        vchiq_log_info(vchiq_arm_log_level, "service_callback closing");
                        return 0;
@@ -1122,7 +1122,7 @@ service_callback(struct vchiq_instance *instance, enum vchiq_reason reason,
                                vchiq_log_info(vchiq_arm_log_level, "%s interrupted", __func__);
                                DEBUG_TRACE(SERVICE_CALLBACK_LINE);
                                vchiq_service_put(service);
-                               return VCHIQ_RETRY;
+                               return -EAGAIN;
                        } else if (instance->closing) {
                                vchiq_log_info(vchiq_arm_log_level, "%s closing", __func__);
                                DEBUG_TRACE(SERVICE_CALLBACK_LINE);

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 7417cba..5a500fa 100644 (file)
--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c
+++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c
@@ -474,7 +474,7 @@ make_service_callback(struct vchiq_service *service, enum vchiq_reason reason,
                        header, bulk_userdata);
        status = service->base.callback(service->instance, reason, header, service->handle,
                                        bulk_userdata);
-       if (status && (status != VCHIQ_RETRY)) {
+       if (status && (status != -EAGAIN)) {
                vchiq_log_warning(vchiq_core_log_level,
                                  "%d: ignoring ERROR from callback to service %x",
                                  service->state->id, service->handle);
@@ -932,7 +932,7 @@ queue_message(struct vchiq_state *state, struct vchiq_service *service,
 
        if (!(flags & QMFLAGS_NO_MUTEX_LOCK) &&
            mutex_lock_killable(&state->slot_mutex))
-               return VCHIQ_RETRY;
+               return -EAGAIN;
 
        if (type == VCHIQ_MSG_DATA) {
                int tx_end_index;
@@ -973,7 +973,7 @@ queue_message(struct vchiq_state *state, struct vchiq_service *service,
                        mutex_unlock(&state->slot_mutex);
 
                        if (wait_for_completion_interruptible(&state->data_quota_event))
-                               return VCHIQ_RETRY;
+                               return -EAGAIN;
 
                        mutex_lock(&state->slot_mutex);
                        spin_lock(&quota_spinlock);
@@ -997,11 +997,11 @@ queue_message(struct vchiq_state *state, struct vchiq_service *service,
                        VCHIQ_SERVICE_STATS_INC(service, quota_stalls);
                        mutex_unlock(&state->slot_mutex);
                        if (wait_for_completion_interruptible(&quota->quota_event))
-                               return VCHIQ_RETRY;
+                               return -EAGAIN;
                        if (service->closing)
                                return -EHOSTDOWN;
                        if (mutex_lock_killable(&state->slot_mutex))
-                               return VCHIQ_RETRY;
+                               return -EAGAIN;
                        if (service->srvstate != VCHIQ_SRVSTATE_OPEN) {
                                /* The service has been closed */
                                mutex_unlock(&state->slot_mutex);
@@ -1025,7 +1025,7 @@ queue_message(struct vchiq_state *state, struct vchiq_service *service,
                 */
                if (!(flags & QMFLAGS_NO_MUTEX_LOCK))
                        mutex_unlock(&state->slot_mutex);
-               return VCHIQ_RETRY;
+               return -EAGAIN;
        }
 
        if (type == VCHIQ_MSG_DATA) {
@@ -1164,7 +1164,7 @@ queue_message_sync(struct vchiq_state *state, struct vchiq_service *service,
 
        if (VCHIQ_MSG_TYPE(msgid) != VCHIQ_MSG_RESUME &&
            mutex_lock_killable(&state->sync_mutex))
-               return VCHIQ_RETRY;
+               return -EAGAIN;
 
        remote_event_wait(&state->sync_release_event, &local->sync_release);
 
@@ -1358,7 +1358,7 @@ notify_bulks(struct vchiq_service *service, struct vchiq_bulk_queue *queue,
                                                get_bulk_reason(bulk);
                                status = make_service_callback(service, reason, NULL,
                                                               bulk->userdata);
-                               if (status == VCHIQ_RETRY)
+                               if (status == -EAGAIN)
                                        break;
                        }
                }
@@ -1369,7 +1369,7 @@ notify_bulks(struct vchiq_service *service, struct vchiq_bulk_queue *queue,
        if (!retry_poll)
                status = 0;
 
-       if (status == VCHIQ_RETRY)
+       if (status == -EAGAIN)
                request_poll(service->state, service, (queue == &service->bulk_tx) ?
                             VCHIQ_POLL_TXNOTIFY : VCHIQ_POLL_RXNOTIFY);
 
@@ -1536,14 +1536,14 @@ parse_open(struct vchiq_state *state, struct vchiq_header *header)
                /* Acknowledge the OPEN */
                if (service->sync) {
                        if (queue_message_sync(state, NULL, openack_id, memcpy_copy_callback,
-                                              &ack_payload, sizeof(ack_payload), 0) == VCHIQ_RETRY)
+                                              &ack_payload, sizeof(ack_payload), 0) == -EAGAIN)
                                goto bail_not_ready;
 
                        /* The service is now open */
                        set_service_state(service, VCHIQ_SRVSTATE_OPENSYNC);
                } else {
                        if (queue_message(state, NULL, openack_id, memcpy_copy_callback,
-                                         &ack_payload, sizeof(ack_payload), 0) == VCHIQ_RETRY)
+                                         &ack_payload, sizeof(ack_payload), 0) == -EAGAIN)
                                goto bail_not_ready;
 
                        /* The service is now open */
@@ -1558,7 +1558,7 @@ parse_open(struct vchiq_state *state, struct vchiq_header *header)
 fail_open:
        /* No available service, or an invalid request - send a CLOSE */
        if (queue_message(state, NULL, MAKE_CLOSE(0, VCHIQ_MSG_SRCPORT(msgid)),
-                         NULL, NULL, 0, 0) == VCHIQ_RETRY)
+                         NULL, NULL, 0, 0) == -EAGAIN)
                goto bail_not_ready;
 
        return 1;
@@ -1697,7 +1697,7 @@ parse_message(struct vchiq_state *state, struct vchiq_header *header)
 
                mark_service_closing_internal(service, 1);
 
-               if (vchiq_close_service_internal(service, CLOSE_RECVD) == VCHIQ_RETRY)
+               if (vchiq_close_service_internal(service, CLOSE_RECVD) == -EAGAIN)
                        goto bail_not_ready;
 
                vchiq_log_info(vchiq_core_log_level, "Close Service %c%c%c%c s:%u d:%d",
@@ -1714,7 +1714,7 @@ parse_message(struct vchiq_state *state, struct vchiq_header *header)
                        claim_slot(state->rx_info);
                        DEBUG_TRACE(PARSE_LINE);
                        if (make_service_callback(service, VCHIQ_MESSAGE_AVAILABLE, header,
-                                                 NULL) == VCHIQ_RETRY) {
+                                                 NULL) == -EAGAIN) {
                                DEBUG_TRACE(PARSE_LINE);
                                goto bail_not_ready;
                        }
@@ -1812,7 +1812,7 @@ parse_message(struct vchiq_state *state, struct vchiq_header *header)
                if (state->conn_state != VCHIQ_CONNSTATE_PAUSE_SENT) {
                        /* Send a PAUSE in response */
                        if (queue_message(state, NULL, MAKE_PAUSE, NULL, NULL, 0,
-                                         QMFLAGS_NO_MUTEX_UNLOCK) == VCHIQ_RETRY)
+                                         QMFLAGS_NO_MUTEX_UNLOCK) == -EAGAIN)
                                goto bail_not_ready;
                }
                /* At this point slot_mutex is held */
@@ -1929,7 +1929,7 @@ handle_poll(struct vchiq_state *state)
 
        case VCHIQ_CONNSTATE_PAUSING:
                if (queue_message(state, NULL, MAKE_PAUSE, NULL, NULL, 0,
-                                 QMFLAGS_NO_MUTEX_UNLOCK) != VCHIQ_RETRY) {
+                                 QMFLAGS_NO_MUTEX_UNLOCK) != -EAGAIN) {
                        vchiq_set_conn_state(state, VCHIQ_CONNSTATE_PAUSE_SENT);
                } else {
                        /* Retry later */
@@ -1939,7 +1939,7 @@ handle_poll(struct vchiq_state *state)
 
        case VCHIQ_CONNSTATE_RESUMING:
                if (queue_message(state, NULL, MAKE_RESUME, NULL, NULL, 0,
-                                 QMFLAGS_NO_MUTEX_LOCK) != VCHIQ_RETRY) {
+                                 QMFLAGS_NO_MUTEX_LOCK) != -EAGAIN) {
                        vchiq_set_conn_state(state, VCHIQ_CONNSTATE_CONNECTED);
                } else {
                        /*
@@ -2095,9 +2095,9 @@ sync_func(void *v)
                        if ((service->remoteport == remoteport) &&
                            (service->srvstate == VCHIQ_SRVSTATE_OPENSYNC)) {
                                if (make_service_callback(service, VCHIQ_MESSAGE_AVAILABLE, header,
-                                                         NULL) == VCHIQ_RETRY)
+                                                         NULL) == -EAGAIN)
                                        vchiq_log_error(vchiq_sync_log_level,
-                                                       "synchronous callback to service %d returns VCHIQ_RETRY",
+                                                       "synchronous callback to service %d returns -EAGAIN",
                                                        localport);
                        }
                        break;
@@ -2520,7 +2520,7 @@ vchiq_open_service_internal(struct vchiq_service *service, int client_id)
 
        /* Wait for the ACK/NAK */
        if (wait_for_completion_interruptible(&service->remove_event)) {
-               status = VCHIQ_RETRY;
+               status = -EAGAIN;
                vchiq_release_service_internal(service);
        } else if ((service->srvstate != VCHIQ_SRVSTATE_OPEN) &&
                   (service->srvstate != VCHIQ_SRVSTATE_OPENSYNC)) {
@@ -2653,7 +2653,7 @@ close_service_complete(struct vchiq_service *service, int failstate)
 
        status = make_service_callback(service, VCHIQ_SERVICE_CLOSED, NULL, NULL);
 
-       if (status != VCHIQ_RETRY) {
+       if (status != -EAGAIN) {
                int uc = service->service_use_count;
                int i;
                /* Complete the close process */
@@ -2734,7 +2734,7 @@ vchiq_close_service_internal(struct vchiq_service *service, int close_recvd)
        case VCHIQ_SRVSTATE_OPEN:
                if (close_recvd) {
                        if (!do_abort_bulks(service))
-                               status = VCHIQ_RETRY;
+                               status = -EAGAIN;
                }
 
                release_service_messages(service);
@@ -2773,7 +2773,7 @@ vchiq_close_service_internal(struct vchiq_service *service, int close_recvd)
                        break;
 
                if (!do_abort_bulks(service)) {
-                       status = VCHIQ_RETRY;
+                       status = -EAGAIN;
                        break;
                }
 
@@ -2857,15 +2857,15 @@ vchiq_connect_internal(struct vchiq_state *state, struct vchiq_instance *instanc
 
        if (state->conn_state == VCHIQ_CONNSTATE_DISCONNECTED) {
                if (queue_message(state, NULL, MAKE_CONNECT, NULL, NULL, 0,
-                                 QMFLAGS_IS_BLOCKING) == VCHIQ_RETRY)
-                       return VCHIQ_RETRY;
+                                 QMFLAGS_IS_BLOCKING) == -EAGAIN)
+                       return -EAGAIN;
 
                vchiq_set_conn_state(state, VCHIQ_CONNSTATE_CONNECTING);
        }
 
        if (state->conn_state == VCHIQ_CONNSTATE_CONNECTING) {
                if (wait_for_completion_interruptible(&state->connect))
-                       return VCHIQ_RETRY;
+                       return -EAGAIN;
 
                vchiq_set_conn_state(state, VCHIQ_CONNSTATE_CONNECTED);
                complete(&state->connect);
@@ -2912,7 +2912,7 @@ vchiq_close_service(struct vchiq_instance *instance, unsigned int handle)
 
        if (current == service->state->slot_handler_thread) {
                status = vchiq_close_service_internal(service, NO_CLOSE_RECVD);
-               WARN_ON(status == VCHIQ_RETRY);
+               WARN_ON(status == -EAGAIN);
        } else {
                /* Mark the service for termination by the slot handler */
                request_poll(service->state, service, VCHIQ_POLL_TERMINATE);
@@ -2920,7 +2920,7 @@ vchiq_close_service(struct vchiq_instance *instance, unsigned int handle)
 
        while (1) {
                if (wait_for_completion_interruptible(&service->remove_event)) {
-                       status = VCHIQ_RETRY;
+                       status = -EAGAIN;
                        break;
                }
 
@@ -2975,14 +2975,14 @@ vchiq_remove_service(struct vchiq_instance *instance, unsigned int handle)
                service->public_fourcc = VCHIQ_FOURCC_INVALID;
 
                status = vchiq_close_service_internal(service, NO_CLOSE_RECVD);
-               WARN_ON(status == VCHIQ_RETRY);
+               WARN_ON(status == -EAGAIN);
        } else {
                /* Mark the service for removal by the slot handler */
                request_poll(service->state, service, VCHIQ_POLL_REMOVE);
        }
        while (1) {
                if (wait_for_completion_interruptible(&service->remove_event)) {
-                       status = VCHIQ_RETRY;
+                       status = -EAGAIN;
                        break;
                }
 
@@ -3006,7 +3006,7 @@ vchiq_remove_service(struct vchiq_instance *instance, unsigned int handle)
 
 /*
  * This function may be called by kernel threads or user threads.
- * User threads may receive VCHIQ_RETRY to indicate that a signal has been
+ * User threads may receive -EAGAIN to indicate that a signal has been
  * received and the call should be retried after being returned to user
  * context.
  * When called in blocking mode, the userdata field points to a bulk_waiter
@@ -3063,7 +3063,7 @@ int vchiq_bulk_transfer(struct vchiq_instance *instance, unsigned int handle,
                &service->bulk_tx : &service->bulk_rx;
 
        if (mutex_lock_killable(&service->bulk_mutex)) {
-               status = VCHIQ_RETRY;
+               status = -EAGAIN;
                goto error_exit;
        }
 
@@ -3072,11 +3072,11 @@ int vchiq_bulk_transfer(struct vchiq_instance *instance, unsigned int handle,
                do {
                        mutex_unlock(&service->bulk_mutex);
                        if (wait_for_completion_interruptible(&service->bulk_remove_event)) {
-                               status = VCHIQ_RETRY;
+                               status = -EAGAIN;
                                goto error_exit;
                        }
                        if (mutex_lock_killable(&service->bulk_mutex)) {
-                               status = VCHIQ_RETRY;
+                               status = -EAGAIN;
                                goto error_exit;
                        }
                } while (queue->local_insert == queue->remove +
@@ -3109,7 +3109,7 @@ int vchiq_bulk_transfer(struct vchiq_instance *instance, unsigned int handle,
         * claim it here to ensure that isn't happening
         */
        if (mutex_lock_killable(&state->slot_mutex)) {
-               status = VCHIQ_RETRY;
+               status = -EAGAIN;
                goto cancel_bulk_error_exit;
        }
 
@@ -3149,7 +3149,7 @@ waiting:
        if (bulk_waiter) {
                bulk_waiter->bulk = bulk;
                if (wait_for_completion_interruptible(&bulk_waiter->event))
-                       status = VCHIQ_RETRY;
+                       status = -EAGAIN;
                else if (bulk_waiter->actual == VCHIQ_BULK_ACTUAL_ABORTED)
                        status = -EINVAL;
        }
@@ -3229,11 +3229,11 @@ int vchiq_queue_kernel_message(struct vchiq_instance *instance, unsigned int han
                                             data, size);
 
                /*
-                * vchiq_queue_message() may return VCHIQ_RETRY, so we need to
+                * vchiq_queue_message() may return -EAGAIN, so we need to
                 * implement a retry mechanism since this function is supposed
                 * to block until queued
                 */
-               if (status != VCHIQ_RETRY)
+               if (status != -EAGAIN)
                        break;
 
                msleep(1);

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 df27419..841e1a5 100644 (file)
--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_dev.c
+++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_dev.c
@@ -132,7 +132,7 @@ vchiq_ioc_queue_message(struct vchiq_instance *instance, unsigned int handle,
 
        if (status == -EINVAL)
                return -EIO;
-       else if (status == VCHIQ_RETRY)
+       else if (status == -EAGAIN)
                return -EINTR;
        return 0;
 }
@@ -192,7 +192,7 @@ static int vchiq_ioc_create_service(struct vchiq_instance *instance,
                status = vchiq_open_service_internal(service, instance->pid);
                if (status) {
                        vchiq_remove_service(instance, service->handle);
-                       return (status == VCHIQ_RETRY) ?
+                       return (status == -EAGAIN) ?
                                -EINTR : -EIO;
                }
        }
@@ -338,7 +338,7 @@ static int vchiq_irq_queue_bulk_tx_rx(struct vchiq_instance *instance,
                goto out;
        }
 
-       if ((status != VCHIQ_RETRY) || fatal_signal_pending(current) ||
+       if ((status != -EAGAIN) || fatal_signal_pending(current) ||
            !waiter->bulk_waiter.bulk) {
                if (waiter->bulk_waiter.bulk) {
                        /* Cancel the signal when the transfer completes. */
@@ -366,7 +366,7 @@ out:
                return ret;
        else if (status == -EINVAL)
                return -EIO;
-       else if (status == VCHIQ_RETRY)
+       else if (status == -EAGAIN)
                return -EINTR;
        return 0;
 }
@@ -686,7 +686,7 @@ vchiq_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                 */
                if (user_service->close_pending &&
                    wait_for_completion_interruptible(&user_service->close_event))
-                       status = VCHIQ_RETRY;
+                       status = -EAGAIN;
                break;
        }
 
@@ -864,7 +864,7 @@ vchiq_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
        if (ret == 0) {
                if (status == -EINVAL)
                        ret = -EIO;
-               else if (status == VCHIQ_RETRY)
+               else if (status == -EAGAIN)
                        ret = -EINTR;
        }