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