staging: vc04_services: Remove function block_resume()

			vchiq_videocore_wanted(state);

}

static int

block_resume(struct vchiq_arm_state *arm_state)

{

	int status = VCHIQ_SUCCESS;

	const unsigned long timeout_val =

				msecs_to_jiffies(FORCE_SUSPEND_TIMEOUT_MS);

	int resume_count = 0;

	/* Allow any threads which were blocked by the last force suspend to

	 * complete if they haven't already.  Only give this one shot; if

	 * blocked_count is incremented after blocked_blocker is completed

	 * (which only happens when blocked_count hits 0) then those threads

	 * will have to wait until next time around */

	if (arm_state->blocked_count) {

		reinit_completion(&arm_state->blocked_blocker);

		write_unlock_bh(&arm_state->susp_res_lock);

		vchiq_log_info(vchiq_susp_log_level, "%s wait for previously "

			"blocked clients", __func__);

		if (wait_for_completion_interruptible_timeout(

				&arm_state->blocked_blocker, timeout_val)

					<= 0) {

			vchiq_log_error(vchiq_susp_log_level, "%s wait for "

				"previously blocked clients failed", __func__);

			status = VCHIQ_ERROR;

			write_lock_bh(&arm_state->susp_res_lock);

			goto out;

		}

		vchiq_log_info(vchiq_susp_log_level, "%s previously blocked "

			"clients resumed", __func__);

		write_lock_bh(&arm_state->susp_res_lock);

	}

	/* We need to wait for resume to complete if it's in process */

	while (arm_state->vc_resume_state != VC_RESUME_RESUMED &&

			arm_state->vc_resume_state > VC_RESUME_IDLE) {

		if (resume_count > 1) {

			status = VCHIQ_ERROR;

			vchiq_log_error(vchiq_susp_log_level, "%s waited too "

				"many times for resume", __func__);

			goto out;

		}

		write_unlock_bh(&arm_state->susp_res_lock);

		vchiq_log_info(vchiq_susp_log_level, "%s wait for resume",

			__func__);

		if (wait_for_completion_interruptible_timeout(

				&arm_state->vc_resume_complete, timeout_val)

					<= 0) {

			vchiq_log_error(vchiq_susp_log_level, "%s wait for "

				"resume failed (%s)", __func__,

				resume_state_names[arm_state->vc_resume_state +

							VC_RESUME_NUM_OFFSET]);

			status = VCHIQ_ERROR;

			write_lock_bh(&arm_state->susp_res_lock);

			goto out;

		}

		vchiq_log_info(vchiq_susp_log_level, "%s resumed", __func__);

		write_lock_bh(&arm_state->susp_res_lock);

		resume_count++;

	}

	reinit_completion(&arm_state->resume_blocker);

	arm_state->resume_blocked = 1;

out:

	return status;

}

static inline void

unblock_resume(struct vchiq_arm_state *arm_state)

{