staging: vc04_services: Get rid of vchiq_arm_vcsuspend()

			(arm_state->vc_resume_state < VC_RESUME_REQUESTED);

}

/* Initiate suspend via slot handler. Should be called with the write lock

 * held */

enum vchiq_status

vchiq_arm_vcsuspend(struct vchiq_state *state)

{

	enum vchiq_status status = VCHIQ_ERROR;

	struct vchiq_arm_state *arm_state = vchiq_platform_get_arm_state(state);

	if (!arm_state)

		goto out;

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

	status = VCHIQ_SUCCESS;

	switch (arm_state->vc_suspend_state) {

	case VC_SUSPEND_REQUESTED:

		vchiq_log_info(vchiq_susp_log_level, "%s: suspend already "

			"requested", __func__);

		break;

	case VC_SUSPEND_IN_PROGRESS:

		vchiq_log_info(vchiq_susp_log_level, "%s: suspend already in "

			"progress", __func__);

		break;

	default:

		/* We don't expect to be in other states, so log but continue

		 * anyway */

		vchiq_log_error(vchiq_susp_log_level,

			"%s unexpected suspend state %s", __func__,

			suspend_state_names[arm_state->vc_suspend_state +

						VC_SUSPEND_NUM_OFFSET]);

		/* fall through */

	case VC_SUSPEND_REJECTED:

	case VC_SUSPEND_FAILED:

		/* Ensure any idle state actions have been run */

		set_suspend_state(arm_state, VC_SUSPEND_IDLE);

		/* fall through */

	case VC_SUSPEND_IDLE:

		vchiq_log_info(vchiq_susp_log_level,

			"%s: suspending", __func__);

		set_suspend_state(arm_state, VC_SUSPEND_REQUESTED);

		/* kick the slot handler thread to initiate suspend */

		request_poll(state, NULL, 0);

		break;

	}

out:

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

	return status;

}

void

vchiq_platform_check_suspend(struct vchiq_state *state)

{

extern struct vchiq_state *

vchiq_get_state(void);

extern enum vchiq_status

vchiq_arm_vcsuspend(struct vchiq_state *state);

extern enum vchiq_status

vchiq_arm_vcresume(struct vchiq_state *state);