1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2022 Linaro Ltd.
4 * Author: Manivannan Sadhasivam <manivannan.sadhasivam@linaro.org>
5 */
6
7#include <linux/errno.h>
8#include <linux/mhi_ep.h>
9#include "internal.h"
10
11bool __must_check mhi_ep_check_mhi_state(struct mhi_ep_cntrl *mhi_cntrl,
12					 enum mhi_state cur_mhi_state,
13					 enum mhi_state mhi_state)
14{
15	if (mhi_state == MHI_STATE_SYS_ERR)
16		return true;    /* Allowed in any state */
17
18	if (mhi_state == MHI_STATE_READY)
19		return cur_mhi_state == MHI_STATE_RESET;
20
21	if (mhi_state == MHI_STATE_M0)
22		return cur_mhi_state == MHI_STATE_M3 || cur_mhi_state == MHI_STATE_READY;
23
24	if (mhi_state == MHI_STATE_M3)
25		return cur_mhi_state == MHI_STATE_M0;
26
27	return false;
28}
29
30int mhi_ep_set_mhi_state(struct mhi_ep_cntrl *mhi_cntrl, enum mhi_state mhi_state)
31{
32	struct device *dev = &mhi_cntrl->mhi_dev->dev;
33
34	if (!mhi_ep_check_mhi_state(mhi_cntrl, mhi_cntrl->mhi_state, mhi_state)) {
35		dev_err(dev, "MHI state change to %s from %s is not allowed!\n",
36			mhi_state_str(mhi_state),
37			mhi_state_str(mhi_cntrl->mhi_state));
38		return -EACCES;
39	}
40
41	/* TODO: Add support for M1 and M2 states */
42	if (mhi_state == MHI_STATE_M1 || mhi_state == MHI_STATE_M2) {
43		dev_err(dev, "MHI state (%s) not supported\n", mhi_state_str(mhi_state));
44		return -EOPNOTSUPP;
45	}
46
47	mhi_ep_mmio_masked_write(mhi_cntrl, EP_MHISTATUS, MHISTATUS_MHISTATE_MASK, mhi_state);
48	mhi_cntrl->mhi_state = mhi_state;
49
50	if (mhi_state == MHI_STATE_READY)
51		mhi_ep_mmio_masked_write(mhi_cntrl, EP_MHISTATUS, MHISTATUS_READY_MASK, 1);
52
53	if (mhi_state == MHI_STATE_SYS_ERR)
54		mhi_ep_mmio_masked_write(mhi_cntrl, EP_MHISTATUS, MHISTATUS_SYSERR_MASK, 1);
55
56	return 0;
57}
58
59int mhi_ep_set_m0_state(struct mhi_ep_cntrl *mhi_cntrl)
60{
61	struct device *dev = &mhi_cntrl->mhi_dev->dev;
62	enum mhi_state old_state;
63	int ret;
64
65	/* If MHI is in M3, resume suspended channels */
66	mutex_lock(&mhi_cntrl->state_lock);
67
68	old_state = mhi_cntrl->mhi_state;
69	if (old_state == MHI_STATE_M3)
70		mhi_ep_resume_channels(mhi_cntrl);
71
72	ret = mhi_ep_set_mhi_state(mhi_cntrl, MHI_STATE_M0);
73	if (ret) {
74		mhi_ep_handle_syserr(mhi_cntrl);
75		goto err_unlock;
76	}
77
78	/* Signal host that the device moved to M0 */
79	ret = mhi_ep_send_state_change_event(mhi_cntrl, MHI_STATE_M0);
80	if (ret) {
81		dev_err(dev, "Failed sending M0 state change event\n");
82		goto err_unlock;
83	}
84
85	if (old_state == MHI_STATE_READY) {
86		/* Send AMSS EE event to host */
87		ret = mhi_ep_send_ee_event(mhi_cntrl, MHI_EE_AMSS);
88		if (ret) {
89			dev_err(dev, "Failed sending AMSS EE event\n");
90			goto err_unlock;
91		}
92	}
93
94err_unlock:
95	mutex_unlock(&mhi_cntrl->state_lock);
96
97	return ret;
98}
99
100int mhi_ep_set_m3_state(struct mhi_ep_cntrl *mhi_cntrl)
101{
102	struct device *dev = &mhi_cntrl->mhi_dev->dev;
103	int ret;
104
105	mutex_lock(&mhi_cntrl->state_lock);
106
107	ret = mhi_ep_set_mhi_state(mhi_cntrl, MHI_STATE_M3);
108	if (ret) {
109		mhi_ep_handle_syserr(mhi_cntrl);
110		goto err_unlock;
111	}
112
113	mhi_ep_suspend_channels(mhi_cntrl);
114
115	/* Signal host that the device moved to M3 */
116	ret = mhi_ep_send_state_change_event(mhi_cntrl, MHI_STATE_M3);
117	if (ret) {
118		dev_err(dev, "Failed sending M3 state change event\n");
119		goto err_unlock;
120	}
121
122err_unlock:
123	mutex_unlock(&mhi_cntrl->state_lock);
124
125	return ret;
126}
127
128int mhi_ep_set_ready_state(struct mhi_ep_cntrl *mhi_cntrl)
129{
130	struct device *dev = &mhi_cntrl->mhi_dev->dev;
131	enum mhi_state mhi_state;
132	int ret, is_ready;
133
134	mutex_lock(&mhi_cntrl->state_lock);
135
136	/* Ensure that the MHISTATUS is set to RESET by host */
137	mhi_state = mhi_ep_mmio_masked_read(mhi_cntrl, EP_MHISTATUS, MHISTATUS_MHISTATE_MASK);
138	is_ready = mhi_ep_mmio_masked_read(mhi_cntrl, EP_MHISTATUS, MHISTATUS_READY_MASK);
139
140	if (mhi_state != MHI_STATE_RESET || is_ready) {
141		dev_err(dev, "READY state transition failed. MHI host not in RESET state\n");
142		ret = -EIO;
143		goto err_unlock;
144	}
145
146	ret = mhi_ep_set_mhi_state(mhi_cntrl, MHI_STATE_READY);
147	if (ret)
148		mhi_ep_handle_syserr(mhi_cntrl);
149
150err_unlock:
151	mutex_unlock(&mhi_cntrl->state_lock);
152
153	return ret;
154}
155