Commit 248a58a3 authored by Nishka Dasgupta's avatar Nishka Dasgupta Committed by Greg Kroah-Hartman
Browse files

staging: vc04_services: Remove vchiq_arm_force_suspend() 



Remove unused function vchiq_arm_force_suspend.
Issue found with Coccinelle.

Signed-off-by: default avatarNishka Dasgupta <nishkadg.linux@gmail.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 49bc1452

drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.c

+0 −120
Original line number Diff line number Diff line
@@ -2741,126 +2741,6 @@ output_msg: 


}



/* Try to get videocore into suspended state, regardless of autosuspend state.

** We don't actually force suspend, since videocore may get into a bad state

** if we force suspend at a bad time.  Instead, we wait for autosuspend to

** determine a good point to suspend.  If this doesn't happen within 100ms we

** report failure.

**

** Returns VCHIQ_SUCCESS if videocore suspended successfully, VCHIQ_RETRY if

** videocore failed to suspend in time or VCHIQ_ERROR if interrupted.

*/

VCHIQ_STATUS_T

vchiq_arm_force_suspend(struct vchiq_state *state)

{

	struct vchiq_arm_state *arm_state = vchiq_platform_get_arm_state(state);

	VCHIQ_STATUS_T status = VCHIQ_ERROR;

	long rc = 0;

	int repeat = -1;



	if (!arm_state)

		goto out;



	vchiq_log_trace(vchiq_susp_log_level, "%s", __func__);



	write_lock_bh(&arm_state->susp_res_lock);



	status = block_resume(arm_state);

	if (status != VCHIQ_SUCCESS)

		goto unlock;

	if (arm_state->vc_suspend_state == VC_SUSPEND_SUSPENDED) {

		/* Already suspended - just block resume and exit */

		vchiq_log_info(vchiq_susp_log_level, "%s already suspended",

			__func__);

		status = VCHIQ_SUCCESS;

		goto unlock;

	} else if (arm_state->vc_suspend_state <= VC_SUSPEND_IDLE) {

		/* initiate suspend immediately in the case that we're waiting

		 * for the timeout */

		stop_suspend_timer(arm_state);

		if (!vchiq_videocore_wanted(state)) {

			vchiq_log_info(vchiq_susp_log_level, "%s videocore "

				"idle, initiating suspend", __func__);

			status = vchiq_arm_vcsuspend(state);

		} else if (arm_state->autosuspend_override <

						FORCE_SUSPEND_FAIL_MAX) {

			vchiq_log_info(vchiq_susp_log_level, "%s letting "

				"videocore go idle", __func__);

			status = VCHIQ_SUCCESS;

		} else {

			vchiq_log_warning(vchiq_susp_log_level, "%s failed too "

				"many times - attempting suspend", __func__);

			status = vchiq_arm_vcsuspend(state);

		}

	} else {

		vchiq_log_info(vchiq_susp_log_level, "%s videocore suspend "

			"in progress - wait for completion", __func__);

		status = VCHIQ_SUCCESS;

	}



	/* Wait for suspend to happen due to system idle (not forced..) */

	if (status != VCHIQ_SUCCESS)

		goto unblock_resume;



	do {

		write_unlock_bh(&arm_state->susp_res_lock);



		rc = wait_for_completion_interruptible_timeout(

				&arm_state->vc_suspend_complete,

				msecs_to_jiffies(FORCE_SUSPEND_TIMEOUT_MS));



		write_lock_bh(&arm_state->susp_res_lock);

		if (rc < 0) {

			vchiq_log_warning(vchiq_susp_log_level, "%s "

				"interrupted waiting for suspend", __func__);

			status = VCHIQ_ERROR;

			goto unblock_resume;

		} else if (rc == 0) {

			if (arm_state->vc_suspend_state > VC_SUSPEND_IDLE) {

				/* Repeat timeout once if in progress */

				if (repeat < 0) {

					repeat = 1;

					continue;

				}

			}

			arm_state->autosuspend_override++;

			output_timeout_error(state);



			status = VCHIQ_RETRY;

			goto unblock_resume;

		}

	} while (0 < (repeat--));



	/* Check and report state in case we need to abort ARM suspend */

	if (arm_state->vc_suspend_state != VC_SUSPEND_SUSPENDED) {

		status = VCHIQ_RETRY;

		vchiq_log_error(vchiq_susp_log_level,

			"%s videocore suspend failed (state %s)", __func__,

			suspend_state_names[arm_state->vc_suspend_state +

						VC_SUSPEND_NUM_OFFSET]);

		/* Reset the state only if it's still in an error state.

		 * Something could have already initiated another suspend. */

		if (arm_state->vc_suspend_state < VC_SUSPEND_IDLE)

			set_suspend_state(arm_state, VC_SUSPEND_IDLE);



		goto unblock_resume;

	}



	/* successfully suspended - unlock and exit */

	goto unlock;



unblock_resume:

	/* all error states need to unblock resume before exit */

	unblock_resume(arm_state);



unlock:

	write_unlock_bh(&arm_state->susp_res_lock);



out:

	vchiq_log_trace(vchiq_susp_log_level, "%s exit %d", __func__, status);

	return status;

}



void

vchiq_check_suspend(struct vchiq_state *state)

{

drivers/staging/vc04_services/interface/vchiq_arm/vchiq_arm.h

+0 −3
Original line number Diff line number Diff line
@@ -112,9 +112,6 @@ vchiq_get_state(void); 
extern VCHIQ_STATUS_T

vchiq_arm_vcsuspend(struct vchiq_state *state);



extern VCHIQ_STATUS_T

vchiq_arm_force_suspend(struct vchiq_state *state);



extern VCHIQ_STATUS_T

vchiq_arm_vcresume(struct vchiq_state *state);