1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright (c) 2011-2017, The Linux Foundation
  4 */
  5
  6#include <linux/slab.h>
  7#include <linux/pm_runtime.h>
  8#include "slimbus.h"
  9
 10/**
 11 * slim_msg_response() - Deliver Message response received from a device to the
 12 *			framework.
 13 *
 14 * @ctrl: Controller handle
 15 * @reply: Reply received from the device
 16 * @len: Length of the reply
 17 * @tid: Transaction ID received with which framework can associate reply.
 18 *
 19 * Called by controller to inform framework about the response received.
 20 * This helps in making the API asynchronous, and controller-driver doesn't need
 21 * to manage 1 more table other than the one managed by framework mapping TID
 22 * with buffers
 23 */
 24void slim_msg_response(struct slim_controller *ctrl, u8 *reply, u8 tid, u8 len)
 25{
 26	struct slim_msg_txn *txn;
 27	struct slim_val_inf *msg;
 28	unsigned long flags;
 29
 30	spin_lock_irqsave(&ctrl->txn_lock, flags);
 31	txn = idr_find(&ctrl->tid_idr, tid);
 32	if (txn == NULL) {
 33		spin_unlock_irqrestore(&ctrl->txn_lock, flags);
 34		return;
 35	}
 36
 37	msg = txn->msg;
 38	if (msg == NULL || msg->rbuf == NULL) {
 39		dev_err(ctrl->dev, "Got response to invalid TID:%d, len:%d\n",
 40				tid, len);
 41		spin_unlock_irqrestore(&ctrl->txn_lock, flags);
 42		return;
 43	}
 44
 45	idr_remove(&ctrl->tid_idr, tid);
 46	spin_unlock_irqrestore(&ctrl->txn_lock, flags);
 47
 48	memcpy(msg->rbuf, reply, len);
 49	if (txn->comp)
 50		complete(txn->comp);
 51
 52	/* Remove runtime-pm vote now that response was received for TID txn */
 53	pm_runtime_mark_last_busy(ctrl->dev);
 54	pm_runtime_put_autosuspend(ctrl->dev);
 55}
 56EXPORT_SYMBOL_GPL(slim_msg_response);
 57
 58/**
 59 * slim_do_transfer() - Process a SLIMbus-messaging transaction
 60 *
 61 * @ctrl: Controller handle
 62 * @txn: Transaction to be sent over SLIMbus
 63 *
 64 * Called by controller to transmit messaging transactions not dealing with
 65 * Interface/Value elements. (e.g. transmittting a message to assign logical
 66 * address to a slave device
 67 *
 68 * Return: -ETIMEDOUT: If transmission of this message timed out
 69 *	(e.g. due to bus lines not being clocked or driven by controller)
 70 */
 71int slim_do_transfer(struct slim_controller *ctrl, struct slim_msg_txn *txn)
 72{
 73	DECLARE_COMPLETION_ONSTACK(done);
 74	bool need_tid = false, clk_pause_msg = false;
 75	unsigned long flags;
 76	int ret, tid, timeout;
 77
 78	/*
 79	 * do not vote for runtime-PM if the transactions are part of clock
 80	 * pause sequence
 81	 */
 82	if (ctrl->sched.clk_state == SLIM_CLK_ENTERING_PAUSE &&
 83		(txn->mt == SLIM_MSG_MT_CORE &&
 84		 txn->mc >= SLIM_MSG_MC_BEGIN_RECONFIGURATION &&
 85		 txn->mc <= SLIM_MSG_MC_RECONFIGURE_NOW))
 86		clk_pause_msg = true;
 87
 88	if (!clk_pause_msg) {
 89		ret = pm_runtime_get_sync(ctrl->dev);
 90		if (ctrl->sched.clk_state != SLIM_CLK_ACTIVE) {
 91			dev_err(ctrl->dev, "ctrl wrong state:%d, ret:%d\n",
 92				ctrl->sched.clk_state, ret);
 93			goto slim_xfer_err;
 94		}
 95	}
 96
 97	need_tid = slim_tid_txn(txn->mt, txn->mc);
 98
 99	if (need_tid) {
100		spin_lock_irqsave(&ctrl->txn_lock, flags);
101		tid = idr_alloc(&ctrl->tid_idr, txn, 0,
102				SLIM_MAX_TIDS, GFP_ATOMIC);
103		txn->tid = tid;
104
105		if (!txn->msg->comp)
106			txn->comp = &done;
107		else
108			txn->comp = txn->comp;
109
110		spin_unlock_irqrestore(&ctrl->txn_lock, flags);
111
112		if (tid < 0)
113			return tid;
114	}
115
116	ret = ctrl->xfer_msg(ctrl, txn);
117
118	if (ret && need_tid && !txn->msg->comp) {
119		unsigned long ms = txn->rl + HZ;
120
121		timeout = wait_for_completion_timeout(txn->comp,
122						      msecs_to_jiffies(ms));
123		if (!timeout) {
124			ret = -ETIMEDOUT;
125			spin_lock_irqsave(&ctrl->txn_lock, flags);
126			idr_remove(&ctrl->tid_idr, tid);
127			spin_unlock_irqrestore(&ctrl->txn_lock, flags);
128		}
129	}
130
131	if (ret)
132		dev_err(ctrl->dev, "Tx:MT:0x%x, MC:0x%x, LA:0x%x failed:%d\n",
133			txn->mt, txn->mc, txn->la, ret);
134
135slim_xfer_err:
136	if (!clk_pause_msg && (!need_tid  || ret == -ETIMEDOUT)) {
137		/*
138		 * remove runtime-pm vote if this was TX only, or
139		 * if there was error during this transaction
140		 */
141		pm_runtime_mark_last_busy(ctrl->dev);
142		pm_runtime_mark_last_busy(ctrl->dev);
143	}
144	return ret;
145}
146EXPORT_SYMBOL_GPL(slim_do_transfer);
147
148static int slim_val_inf_sanity(struct slim_controller *ctrl,
149			       struct slim_val_inf *msg, u8 mc)
150{
151	if (!msg || msg->num_bytes > 16 ||
152	    (msg->start_offset + msg->num_bytes) > 0xC00)
153		goto reterr;
154	switch (mc) {
155	case SLIM_MSG_MC_REQUEST_VALUE:
156	case SLIM_MSG_MC_REQUEST_INFORMATION:
157		if (msg->rbuf != NULL)
158			return 0;
159		break;
160
161	case SLIM_MSG_MC_CHANGE_VALUE:
162	case SLIM_MSG_MC_CLEAR_INFORMATION:
163		if (msg->wbuf != NULL)
164			return 0;
165		break;
166
167	case SLIM_MSG_MC_REQUEST_CHANGE_VALUE:
168	case SLIM_MSG_MC_REQUEST_CLEAR_INFORMATION:
169		if (msg->rbuf != NULL && msg->wbuf != NULL)
170			return 0;
171		break;
172	}
173reterr:
174	if (msg)
175		dev_err(ctrl->dev, "Sanity check failed:msg:offset:0x%x, mc:%d\n",
176			msg->start_offset, mc);
177	return -EINVAL;
178}
179
180static u16 slim_slicesize(int code)
181{
182	static const u8 sizetocode[16] = {
183		0, 1, 2, 3, 3, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7
184	};
185
186	code = clamp(code, 1, (int)ARRAY_SIZE(sizetocode));
187
188	return sizetocode[code - 1];
189}
190
191/**
192 * slim_xfer_msg() - Transfer a value info message on slim device
193 *
194 * @sbdev: slim device to which this msg has to be transfered
195 * @msg: value info message pointer
196 * @mc: message code of the message
197 *
198 * Called by drivers which want to transfer a vlaue or info elements.
199 *
200 * Return: -ETIMEDOUT: If transmission of this message timed out
201 */
202int slim_xfer_msg(struct slim_device *sbdev, struct slim_val_inf *msg,
203		  u8 mc)
204{
205	DEFINE_SLIM_LDEST_TXN(txn_stack, mc, 6, sbdev->laddr, msg);
206	struct slim_msg_txn *txn = &txn_stack;
207	struct slim_controller *ctrl = sbdev->ctrl;
208	int ret;
209	u16 sl;
210
211	if (!ctrl)
212		return -EINVAL;
213
214	ret = slim_val_inf_sanity(ctrl, msg, mc);
215	if (ret)
216		return ret;
217
218	sl = slim_slicesize(msg->num_bytes);
219
220	dev_dbg(ctrl->dev, "SB xfer msg:os:%x, len:%d, MC:%x, sl:%x\n",
221		msg->start_offset, msg->num_bytes, mc, sl);
222
223	txn->ec = ((sl | (1 << 3)) | ((msg->start_offset & 0xFFF) << 4));
224
225	switch (mc) {
226	case SLIM_MSG_MC_REQUEST_CHANGE_VALUE:
227	case SLIM_MSG_MC_CHANGE_VALUE:
228	case SLIM_MSG_MC_REQUEST_CLEAR_INFORMATION:
229	case SLIM_MSG_MC_CLEAR_INFORMATION:
230		txn->rl += msg->num_bytes;
231	default:
232		break;
233	}
234
235	if (slim_tid_txn(txn->mt, txn->mc))
236		txn->rl++;
237
238	return slim_do_transfer(ctrl, txn);
239}
240EXPORT_SYMBOL_GPL(slim_xfer_msg);
241
242static void slim_fill_msg(struct slim_val_inf *msg, u32 addr,
243			 size_t count, u8 *rbuf, u8 *wbuf)
244{
245	msg->start_offset = addr;
246	msg->num_bytes = count;
247	msg->rbuf = rbuf;
248	msg->wbuf = wbuf;
249}
250
251/**
252 * slim_read() - Read SLIMbus value element
253 *
254 * @sdev: client handle.
255 * @addr:  address of value element to read.
256 * @count: number of bytes to read. Maximum bytes allowed are 16.
257 * @val: will return what the value element value was
258 *
259 * Return: -EINVAL for Invalid parameters, -ETIMEDOUT If transmission of
260 * this message timed out (e.g. due to bus lines not being clocked
261 * or driven by controller)
262 */
263int slim_read(struct slim_device *sdev, u32 addr, size_t count, u8 *val)
264{
265	struct slim_val_inf msg;
266
267	slim_fill_msg(&msg, addr, count, val, NULL);
268
269	return slim_xfer_msg(sdev, &msg, SLIM_MSG_MC_REQUEST_VALUE);
270}
271EXPORT_SYMBOL_GPL(slim_read);
272
273/**
274 * slim_readb() - Read byte from SLIMbus value element
275 *
276 * @sdev: client handle.
277 * @addr:  address in the value element to read.
278 *
279 * Return: byte value of value element.
280 */
281int slim_readb(struct slim_device *sdev, u32 addr)
282{
283	int ret;
284	u8 buf;
285
286	ret = slim_read(sdev, addr, 1, &buf);
287	if (ret < 0)
288		return ret;
289	else
290		return buf;
291}
292EXPORT_SYMBOL_GPL(slim_readb);
293
294/**
295 * slim_write() - Write SLIMbus value element
296 *
297 * @sdev: client handle.
298 * @addr:  address in the value element to write.
299 * @count: number of bytes to write. Maximum bytes allowed are 16.
300 * @val: value to write to value element
301 *
302 * Return: -EINVAL for Invalid parameters, -ETIMEDOUT If transmission of
303 * this message timed out (e.g. due to bus lines not being clocked
304 * or driven by controller)
305 */
306int slim_write(struct slim_device *sdev, u32 addr, size_t count, u8 *val)
307{
308	struct slim_val_inf msg;
309
310	slim_fill_msg(&msg, addr, count,  val, NULL);
311
312	return slim_xfer_msg(sdev, &msg, SLIM_MSG_MC_CHANGE_VALUE);
313}
314EXPORT_SYMBOL_GPL(slim_write);
315
316/**
317 * slim_writeb() - Write byte to SLIMbus value element
318 *
319 * @sdev: client handle.
320 * @addr:  address of value element to write.
321 * @value: value to write to value element
322 *
323 * Return: -EINVAL for Invalid parameters, -ETIMEDOUT If transmission of
324 * this message timed out (e.g. due to bus lines not being clocked
325 * or driven by controller)
326 *
327 */
328int slim_writeb(struct slim_device *sdev, u32 addr, u8 value)
329{
330	return slim_write(sdev, addr, 1, &value);
331}
332EXPORT_SYMBOL_GPL(slim_writeb);