155 lines
3.9 KiB
C
155 lines
3.9 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright (C) 2022 Linaro Ltd.
|
|
* Author: Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>
|
|
*/
|
|
|
|
#include <linux/errno.h>
|
|
#include <linux/mhi_ep.h>
|
|
#include "internal.h"
|
|
|
|
bool __must_check mhi_ep_check_mhi_state(struct mhi_ep_cntrl *mhi_cntrl,
|
|
enum mhi_state cur_mhi_state,
|
|
enum mhi_state mhi_state)
|
|
{
|
|
if (mhi_state == MHI_STATE_SYS_ERR)
|
|
return true; /* Allowed in any state */
|
|
|
|
if (mhi_state == MHI_STATE_READY)
|
|
return cur_mhi_state == MHI_STATE_RESET;
|
|
|
|
if (mhi_state == MHI_STATE_M0)
|
|
return cur_mhi_state == MHI_STATE_M3 || cur_mhi_state == MHI_STATE_READY;
|
|
|
|
if (mhi_state == MHI_STATE_M3)
|
|
return cur_mhi_state == MHI_STATE_M0;
|
|
|
|
return false;
|
|
}
|
|
|
|
int mhi_ep_set_mhi_state(struct mhi_ep_cntrl *mhi_cntrl, enum mhi_state mhi_state)
|
|
{
|
|
struct device *dev = &mhi_cntrl->mhi_dev->dev;
|
|
|
|
if (!mhi_ep_check_mhi_state(mhi_cntrl, mhi_cntrl->mhi_state, mhi_state)) {
|
|
dev_err(dev, "MHI state change to %s from %s is not allowed!\n",
|
|
mhi_state_str(mhi_state),
|
|
mhi_state_str(mhi_cntrl->mhi_state));
|
|
return -EACCES;
|
|
}
|
|
|
|
/* TODO: Add support for M1 and M2 states */
|
|
if (mhi_state == MHI_STATE_M1 || mhi_state == MHI_STATE_M2) {
|
|
dev_err(dev, "MHI state (%s) not supported\n", mhi_state_str(mhi_state));
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
mhi_ep_mmio_masked_write(mhi_cntrl, EP_MHISTATUS, MHISTATUS_MHISTATE_MASK, mhi_state);
|
|
mhi_cntrl->mhi_state = mhi_state;
|
|
|
|
if (mhi_state == MHI_STATE_READY)
|
|
mhi_ep_mmio_masked_write(mhi_cntrl, EP_MHISTATUS, MHISTATUS_READY_MASK, 1);
|
|
|
|
if (mhi_state == MHI_STATE_SYS_ERR)
|
|
mhi_ep_mmio_masked_write(mhi_cntrl, EP_MHISTATUS, MHISTATUS_SYSERR_MASK, 1);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int mhi_ep_set_m0_state(struct mhi_ep_cntrl *mhi_cntrl)
|
|
{
|
|
struct device *dev = &mhi_cntrl->mhi_dev->dev;
|
|
enum mhi_state old_state;
|
|
int ret;
|
|
|
|
/* If MHI is in M3, resume suspended channels */
|
|
mutex_lock(&mhi_cntrl->state_lock);
|
|
|
|
old_state = mhi_cntrl->mhi_state;
|
|
if (old_state == MHI_STATE_M3)
|
|
mhi_ep_resume_channels(mhi_cntrl);
|
|
|
|
ret = mhi_ep_set_mhi_state(mhi_cntrl, MHI_STATE_M0);
|
|
if (ret) {
|
|
mhi_ep_handle_syserr(mhi_cntrl);
|
|
goto err_unlock;
|
|
}
|
|
|
|
/* Signal host that the device moved to M0 */
|
|
ret = mhi_ep_send_state_change_event(mhi_cntrl, MHI_STATE_M0);
|
|
if (ret) {
|
|
dev_err(dev, "Failed sending M0 state change event\n");
|
|
goto err_unlock;
|
|
}
|
|
|
|
if (old_state == MHI_STATE_READY) {
|
|
/* Send AMSS EE event to host */
|
|
ret = mhi_ep_send_ee_event(mhi_cntrl, MHI_EE_AMSS);
|
|
if (ret) {
|
|
dev_err(dev, "Failed sending AMSS EE event\n");
|
|
goto err_unlock;
|
|
}
|
|
}
|
|
|
|
err_unlock:
|
|
mutex_unlock(&mhi_cntrl->state_lock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int mhi_ep_set_m3_state(struct mhi_ep_cntrl *mhi_cntrl)
|
|
{
|
|
struct device *dev = &mhi_cntrl->mhi_dev->dev;
|
|
int ret;
|
|
|
|
mutex_lock(&mhi_cntrl->state_lock);
|
|
|
|
ret = mhi_ep_set_mhi_state(mhi_cntrl, MHI_STATE_M3);
|
|
if (ret) {
|
|
mhi_ep_handle_syserr(mhi_cntrl);
|
|
goto err_unlock;
|
|
}
|
|
|
|
mhi_ep_suspend_channels(mhi_cntrl);
|
|
|
|
/* Signal host that the device moved to M3 */
|
|
ret = mhi_ep_send_state_change_event(mhi_cntrl, MHI_STATE_M3);
|
|
if (ret) {
|
|
dev_err(dev, "Failed sending M3 state change event\n");
|
|
goto err_unlock;
|
|
}
|
|
|
|
err_unlock:
|
|
mutex_unlock(&mhi_cntrl->state_lock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int mhi_ep_set_ready_state(struct mhi_ep_cntrl *mhi_cntrl)
|
|
{
|
|
struct device *dev = &mhi_cntrl->mhi_dev->dev;
|
|
enum mhi_state mhi_state;
|
|
int ret, is_ready;
|
|
|
|
mutex_lock(&mhi_cntrl->state_lock);
|
|
|
|
/* Ensure that the MHISTATUS is set to RESET by host */
|
|
mhi_state = mhi_ep_mmio_masked_read(mhi_cntrl, EP_MHISTATUS, MHISTATUS_MHISTATE_MASK);
|
|
is_ready = mhi_ep_mmio_masked_read(mhi_cntrl, EP_MHISTATUS, MHISTATUS_READY_MASK);
|
|
|
|
if (mhi_state != MHI_STATE_RESET || is_ready) {
|
|
dev_err(dev, "READY state transition failed. MHI host not in RESET state\n");
|
|
ret = -EIO;
|
|
goto err_unlock;
|
|
}
|
|
|
|
ret = mhi_ep_set_mhi_state(mhi_cntrl, MHI_STATE_READY);
|
|
if (ret)
|
|
mhi_ep_handle_syserr(mhi_cntrl);
|
|
|
|
err_unlock:
|
|
mutex_unlock(&mhi_cntrl->state_lock);
|
|
|
|
return ret;
|
|
}
|