// 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;
}