staging: vc04_services: Get rid of resume_blocked in struct vchiq_arm_state

The boolean value is never set to true, hence remove it and all the code that
depends on it.

Signed-off-by: Nicolas Saenz Julienne <nsaenzjulienne@suse.de>
Link: https://lore.kernel.org/r/20200131103836.14312-3-nsaenzjulienne@suse.de
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 4458c1e..af4dc23 100644 (file)
--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.c
+++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.c
@@ -2270,10 +2270,7 @@ vchiq_videocore_wanted(struct vchiq_state *state)
                return 1;
        else if (!arm_state->videocore_use_count)
                /* usage count zero - check for override unless we're forcing */
-               if (arm_state->resume_blocked)
-                       return 0;
-               else
-                       return vchiq_platform_videocore_wanted(state);
+               return vchiq_platform_videocore_wanted(state);
        else
                /* non-zero usage count - videocore still required */
                return 1;
@@ -2567,7 +2564,6 @@ static inline void
 unblock_resume(struct vchiq_arm_state *arm_state)
 {
        complete_all(&arm_state->resume_blocker);
-       arm_state->resume_blocked = 0;
 }
 
 /* Initiate suspend via slot handler. Should be called with the write lock
@@ -2724,46 +2720,6 @@ vchiq_use_internal(struct vchiq_state *state, struct vchiq_service *service,
        }
 
        write_lock_bh(&arm_state->susp_res_lock);
-       while (arm_state->resume_blocked) {
-               /* If we call 'use' while force suspend is waiting for suspend,
-                * then we're about to block the thread which the force is
-                * waiting to complete, so we're bound to just time out. In this
-                * case, set the suspend state such that the wait will be
-                * canceled, so we can complete as quickly as possible. */
-               if (arm_state->resume_blocked && arm_state->vc_suspend_state ==
-                               VC_SUSPEND_IDLE) {
-                       set_suspend_state(arm_state, VC_SUSPEND_FORCE_CANCELED);
-                       break;
-               }
-               /* If suspend is already in progress then we need to block */
-               if (!try_wait_for_completion(&arm_state->resume_blocker)) {
-                       /* Indicate that there are threads waiting on the resume
-                        * blocker.  These need to be allowed to complete before
-                        * a _second_ call to force suspend can complete,
-                        * otherwise low priority threads might never actually
-                        * continue */
-                       arm_state->blocked_count++;
-                       write_unlock_bh(&arm_state->susp_res_lock);
-                       vchiq_log_info(vchiq_susp_log_level, "%s %s resume "
-                               "blocked - waiting...", __func__, entity);
-                       if (wait_for_completion_killable(
-                                       &arm_state->resume_blocker)) {
-                               vchiq_log_error(vchiq_susp_log_level, "%s %s "
-                                       "wait for resume blocker interrupted",
-                                       __func__, entity);
-                               ret = VCHIQ_ERROR;
-                               write_lock_bh(&arm_state->susp_res_lock);
-                               arm_state->blocked_count--;
-                               write_unlock_bh(&arm_state->susp_res_lock);
-                               goto out;
-                       }
-                       vchiq_log_info(vchiq_susp_log_level, "%s %s resume "
-                               "unblocked", __func__, entity);
-                       write_lock_bh(&arm_state->susp_res_lock);
-                       if (--arm_state->blocked_count == 0)
-                               complete_all(&arm_state->blocked_blocker);
-               }
-       }
 
        stop_suspend_timer(arm_state);
 
@@ -2861,10 +2817,7 @@ vchiq_release_internal(struct vchiq_state *state, struct vchiq_service *service)
        --(*entity_uc);
 
        if (!vchiq_videocore_wanted(state)) {
-               if (vchiq_platform_use_suspend_timer() &&
-                               !arm_state->resume_blocked) {
-                       /* Only use the timer if we're not trying to force
-                        * suspend (=> resume_blocked) */
+               if (vchiq_platform_use_suspend_timer()) {
                        start_suspend_timer(arm_state);
                } else {
                        vchiq_log_info(vchiq_susp_log_level,

diff --git a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.h b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.h
index f004428..c904f7b 100644 (file)
--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.h
+++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.h
@@ -74,7 +74,6 @@ struct vchiq_arm_state {
        ** ARM is suspending
        */
        struct completion resume_blocker;
-       int resume_blocked;
        struct completion blocked_blocker;
        int blocked_count;