mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-06 02:24:14 +08:00
a263c1ff6a
In some usecases transaction ids are dynamically allocated inside
the controller driver after sending the messages which have generic
acknowledge responses. So check for this before refcounting pm_runtime.
Without this we would end up imbalancing runtime pm count by
doing pm_runtime_put() in both slim_do_transfer() and slim_msg_response()
for a single pm_runtime_get() in slim_do_transfer()
Fixes: d3062a2109
("slimbus: messaging: add slim_alloc/free_txn_tid()")
Cc: <stable@vger.kernel.org>
Signed-off-by: Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
Link: https://lore.kernel.org/r/20210809082428.11236-3-srinivas.kandagatla@linaro.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
366 lines
9.1 KiB
C
366 lines
9.1 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright (c) 2011-2017, The Linux Foundation
|
|
*/
|
|
|
|
#include <linux/slab.h>
|
|
#include <linux/pm_runtime.h>
|
|
#include "slimbus.h"
|
|
|
|
/**
|
|
* slim_msg_response() - Deliver Message response received from a device to the
|
|
* framework.
|
|
*
|
|
* @ctrl: Controller handle
|
|
* @reply: Reply received from the device
|
|
* @len: Length of the reply
|
|
* @tid: Transaction ID received with which framework can associate reply.
|
|
*
|
|
* Called by controller to inform framework about the response received.
|
|
* This helps in making the API asynchronous, and controller-driver doesn't need
|
|
* to manage 1 more table other than the one managed by framework mapping TID
|
|
* with buffers
|
|
*/
|
|
void slim_msg_response(struct slim_controller *ctrl, u8 *reply, u8 tid, u8 len)
|
|
{
|
|
struct slim_msg_txn *txn;
|
|
struct slim_val_inf *msg;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&ctrl->txn_lock, flags);
|
|
txn = idr_find(&ctrl->tid_idr, tid);
|
|
spin_unlock_irqrestore(&ctrl->txn_lock, flags);
|
|
|
|
if (txn == NULL)
|
|
return;
|
|
|
|
msg = txn->msg;
|
|
if (msg == NULL || msg->rbuf == NULL) {
|
|
dev_err(ctrl->dev, "Got response to invalid TID:%d, len:%d\n",
|
|
tid, len);
|
|
return;
|
|
}
|
|
|
|
slim_free_txn_tid(ctrl, txn);
|
|
memcpy(msg->rbuf, reply, len);
|
|
if (txn->comp)
|
|
complete(txn->comp);
|
|
|
|
/* Remove runtime-pm vote now that response was received for TID txn */
|
|
pm_runtime_mark_last_busy(ctrl->dev);
|
|
pm_runtime_put_autosuspend(ctrl->dev);
|
|
}
|
|
EXPORT_SYMBOL_GPL(slim_msg_response);
|
|
|
|
/**
|
|
* slim_alloc_txn_tid() - Allocate a tid to txn
|
|
*
|
|
* @ctrl: Controller handle
|
|
* @txn: transaction to be allocated with tid.
|
|
*
|
|
* Return: zero on success with valid txn->tid and error code on failures.
|
|
*/
|
|
int slim_alloc_txn_tid(struct slim_controller *ctrl, struct slim_msg_txn *txn)
|
|
{
|
|
unsigned long flags;
|
|
int ret = 0;
|
|
|
|
spin_lock_irqsave(&ctrl->txn_lock, flags);
|
|
ret = idr_alloc_cyclic(&ctrl->tid_idr, txn, 1,
|
|
SLIM_MAX_TIDS, GFP_ATOMIC);
|
|
if (ret < 0) {
|
|
spin_unlock_irqrestore(&ctrl->txn_lock, flags);
|
|
return ret;
|
|
}
|
|
txn->tid = ret;
|
|
spin_unlock_irqrestore(&ctrl->txn_lock, flags);
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(slim_alloc_txn_tid);
|
|
|
|
/**
|
|
* slim_free_txn_tid() - Freee tid of txn
|
|
*
|
|
* @ctrl: Controller handle
|
|
* @txn: transaction whose tid should be freed
|
|
*/
|
|
void slim_free_txn_tid(struct slim_controller *ctrl, struct slim_msg_txn *txn)
|
|
{
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&ctrl->txn_lock, flags);
|
|
idr_remove(&ctrl->tid_idr, txn->tid);
|
|
spin_unlock_irqrestore(&ctrl->txn_lock, flags);
|
|
}
|
|
EXPORT_SYMBOL_GPL(slim_free_txn_tid);
|
|
|
|
/**
|
|
* slim_do_transfer() - Process a SLIMbus-messaging transaction
|
|
*
|
|
* @ctrl: Controller handle
|
|
* @txn: Transaction to be sent over SLIMbus
|
|
*
|
|
* Called by controller to transmit messaging transactions not dealing with
|
|
* Interface/Value elements. (e.g. transmittting a message to assign logical
|
|
* address to a slave device
|
|
*
|
|
* Return: -ETIMEDOUT: If transmission of this message timed out
|
|
* (e.g. due to bus lines not being clocked or driven by controller)
|
|
*/
|
|
int slim_do_transfer(struct slim_controller *ctrl, struct slim_msg_txn *txn)
|
|
{
|
|
DECLARE_COMPLETION_ONSTACK(done);
|
|
bool need_tid = false, clk_pause_msg = false;
|
|
int ret, timeout;
|
|
|
|
/*
|
|
* do not vote for runtime-PM if the transactions are part of clock
|
|
* pause sequence
|
|
*/
|
|
if (ctrl->sched.clk_state == SLIM_CLK_ENTERING_PAUSE &&
|
|
(txn->mt == SLIM_MSG_MT_CORE &&
|
|
txn->mc >= SLIM_MSG_MC_BEGIN_RECONFIGURATION &&
|
|
txn->mc <= SLIM_MSG_MC_RECONFIGURE_NOW))
|
|
clk_pause_msg = true;
|
|
|
|
if (!clk_pause_msg) {
|
|
ret = pm_runtime_get_sync(ctrl->dev);
|
|
if (ctrl->sched.clk_state != SLIM_CLK_ACTIVE) {
|
|
dev_err(ctrl->dev, "ctrl wrong state:%d, ret:%d\n",
|
|
ctrl->sched.clk_state, ret);
|
|
goto slim_xfer_err;
|
|
}
|
|
}
|
|
/* Initialize tid to invalid value */
|
|
txn->tid = 0;
|
|
need_tid = slim_tid_txn(txn->mt, txn->mc);
|
|
|
|
if (need_tid) {
|
|
ret = slim_alloc_txn_tid(ctrl, txn);
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (!txn->msg->comp)
|
|
txn->comp = &done;
|
|
else
|
|
txn->comp = txn->comp;
|
|
}
|
|
|
|
ret = ctrl->xfer_msg(ctrl, txn);
|
|
|
|
if (!ret && need_tid && !txn->msg->comp) {
|
|
unsigned long ms = txn->rl + HZ;
|
|
|
|
timeout = wait_for_completion_timeout(txn->comp,
|
|
msecs_to_jiffies(ms));
|
|
if (!timeout) {
|
|
ret = -ETIMEDOUT;
|
|
slim_free_txn_tid(ctrl, txn);
|
|
}
|
|
}
|
|
|
|
if (ret)
|
|
dev_err(ctrl->dev, "Tx:MT:0x%x, MC:0x%x, LA:0x%x failed:%d\n",
|
|
txn->mt, txn->mc, txn->la, ret);
|
|
|
|
slim_xfer_err:
|
|
if (!clk_pause_msg && (txn->tid == 0 || ret == -ETIMEDOUT)) {
|
|
/*
|
|
* remove runtime-pm vote if this was TX only, or
|
|
* if there was error during this transaction
|
|
*/
|
|
pm_runtime_mark_last_busy(ctrl->dev);
|
|
pm_runtime_put_autosuspend(ctrl->dev);
|
|
}
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(slim_do_transfer);
|
|
|
|
static int slim_val_inf_sanity(struct slim_controller *ctrl,
|
|
struct slim_val_inf *msg, u8 mc)
|
|
{
|
|
if (!msg || msg->num_bytes > 16 ||
|
|
(msg->start_offset + msg->num_bytes) > 0xC00)
|
|
goto reterr;
|
|
switch (mc) {
|
|
case SLIM_MSG_MC_REQUEST_VALUE:
|
|
case SLIM_MSG_MC_REQUEST_INFORMATION:
|
|
if (msg->rbuf != NULL)
|
|
return 0;
|
|
break;
|
|
|
|
case SLIM_MSG_MC_CHANGE_VALUE:
|
|
case SLIM_MSG_MC_CLEAR_INFORMATION:
|
|
if (msg->wbuf != NULL)
|
|
return 0;
|
|
break;
|
|
|
|
case SLIM_MSG_MC_REQUEST_CHANGE_VALUE:
|
|
case SLIM_MSG_MC_REQUEST_CLEAR_INFORMATION:
|
|
if (msg->rbuf != NULL && msg->wbuf != NULL)
|
|
return 0;
|
|
break;
|
|
}
|
|
reterr:
|
|
if (msg)
|
|
dev_err(ctrl->dev, "Sanity check failed:msg:offset:0x%x, mc:%d\n",
|
|
msg->start_offset, mc);
|
|
return -EINVAL;
|
|
}
|
|
|
|
static u16 slim_slicesize(int code)
|
|
{
|
|
static const u8 sizetocode[16] = {
|
|
0, 1, 2, 3, 3, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7
|
|
};
|
|
|
|
code = clamp(code, 1, (int)ARRAY_SIZE(sizetocode));
|
|
|
|
return sizetocode[code - 1];
|
|
}
|
|
|
|
/**
|
|
* slim_xfer_msg() - Transfer a value info message on slim device
|
|
*
|
|
* @sbdev: slim device to which this msg has to be transfered
|
|
* @msg: value info message pointer
|
|
* @mc: message code of the message
|
|
*
|
|
* Called by drivers which want to transfer a vlaue or info elements.
|
|
*
|
|
* Return: -ETIMEDOUT: If transmission of this message timed out
|
|
*/
|
|
int slim_xfer_msg(struct slim_device *sbdev, struct slim_val_inf *msg,
|
|
u8 mc)
|
|
{
|
|
DEFINE_SLIM_LDEST_TXN(txn_stack, mc, 6, sbdev->laddr, msg);
|
|
struct slim_msg_txn *txn = &txn_stack;
|
|
struct slim_controller *ctrl = sbdev->ctrl;
|
|
int ret;
|
|
u16 sl;
|
|
|
|
if (!ctrl)
|
|
return -EINVAL;
|
|
|
|
ret = slim_val_inf_sanity(ctrl, msg, mc);
|
|
if (ret)
|
|
return ret;
|
|
|
|
sl = slim_slicesize(msg->num_bytes);
|
|
|
|
dev_dbg(ctrl->dev, "SB xfer msg:os:%x, len:%d, MC:%x, sl:%x\n",
|
|
msg->start_offset, msg->num_bytes, mc, sl);
|
|
|
|
txn->ec = ((sl | (1 << 3)) | ((msg->start_offset & 0xFFF) << 4));
|
|
|
|
switch (mc) {
|
|
case SLIM_MSG_MC_REQUEST_CHANGE_VALUE:
|
|
case SLIM_MSG_MC_CHANGE_VALUE:
|
|
case SLIM_MSG_MC_REQUEST_CLEAR_INFORMATION:
|
|
case SLIM_MSG_MC_CLEAR_INFORMATION:
|
|
txn->rl += msg->num_bytes;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (slim_tid_txn(txn->mt, txn->mc))
|
|
txn->rl++;
|
|
|
|
return slim_do_transfer(ctrl, txn);
|
|
}
|
|
EXPORT_SYMBOL_GPL(slim_xfer_msg);
|
|
|
|
static void slim_fill_msg(struct slim_val_inf *msg, u32 addr,
|
|
size_t count, u8 *rbuf, u8 *wbuf)
|
|
{
|
|
msg->start_offset = addr;
|
|
msg->num_bytes = count;
|
|
msg->rbuf = rbuf;
|
|
msg->wbuf = wbuf;
|
|
msg->comp = NULL;
|
|
}
|
|
|
|
/**
|
|
* slim_read() - Read SLIMbus value element
|
|
*
|
|
* @sdev: client handle.
|
|
* @addr: address of value element to read.
|
|
* @count: number of bytes to read. Maximum bytes allowed are 16.
|
|
* @val: will return what the value element value was
|
|
*
|
|
* Return: -EINVAL for Invalid parameters, -ETIMEDOUT If transmission of
|
|
* this message timed out (e.g. due to bus lines not being clocked
|
|
* or driven by controller)
|
|
*/
|
|
int slim_read(struct slim_device *sdev, u32 addr, size_t count, u8 *val)
|
|
{
|
|
struct slim_val_inf msg;
|
|
|
|
slim_fill_msg(&msg, addr, count, val, NULL);
|
|
|
|
return slim_xfer_msg(sdev, &msg, SLIM_MSG_MC_REQUEST_VALUE);
|
|
}
|
|
EXPORT_SYMBOL_GPL(slim_read);
|
|
|
|
/**
|
|
* slim_readb() - Read byte from SLIMbus value element
|
|
*
|
|
* @sdev: client handle.
|
|
* @addr: address in the value element to read.
|
|
*
|
|
* Return: byte value of value element.
|
|
*/
|
|
int slim_readb(struct slim_device *sdev, u32 addr)
|
|
{
|
|
int ret;
|
|
u8 buf;
|
|
|
|
ret = slim_read(sdev, addr, 1, &buf);
|
|
if (ret < 0)
|
|
return ret;
|
|
else
|
|
return buf;
|
|
}
|
|
EXPORT_SYMBOL_GPL(slim_readb);
|
|
|
|
/**
|
|
* slim_write() - Write SLIMbus value element
|
|
*
|
|
* @sdev: client handle.
|
|
* @addr: address in the value element to write.
|
|
* @count: number of bytes to write. Maximum bytes allowed are 16.
|
|
* @val: value to write to value element
|
|
*
|
|
* Return: -EINVAL for Invalid parameters, -ETIMEDOUT If transmission of
|
|
* this message timed out (e.g. due to bus lines not being clocked
|
|
* or driven by controller)
|
|
*/
|
|
int slim_write(struct slim_device *sdev, u32 addr, size_t count, u8 *val)
|
|
{
|
|
struct slim_val_inf msg;
|
|
|
|
slim_fill_msg(&msg, addr, count, NULL, val);
|
|
|
|
return slim_xfer_msg(sdev, &msg, SLIM_MSG_MC_CHANGE_VALUE);
|
|
}
|
|
EXPORT_SYMBOL_GPL(slim_write);
|
|
|
|
/**
|
|
* slim_writeb() - Write byte to SLIMbus value element
|
|
*
|
|
* @sdev: client handle.
|
|
* @addr: address of value element to write.
|
|
* @value: value to write to value element
|
|
*
|
|
* Return: -EINVAL for Invalid parameters, -ETIMEDOUT If transmission of
|
|
* this message timed out (e.g. due to bus lines not being clocked
|
|
* or driven by controller)
|
|
*
|
|
*/
|
|
int slim_writeb(struct slim_device *sdev, u32 addr, u8 value)
|
|
{
|
|
return slim_write(sdev, addr, 1, &value);
|
|
}
|
|
EXPORT_SYMBOL_GPL(slim_writeb);
|