mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-05 10:04:12 +08:00
d3062a2109
This patch adds slim_alloc_txn_tid() and slim_free_txn_tid() api to allow controllers like ngd to allocate tids for user specific commands. This also cleans up the existing code to use single place for tid allocations and free. This patch also make the tid allocation cyclic one, its very useful to track the transactions back during debug. Signed-off-by: Srinivas Kandagatla <srinivas.kandagatla@linaro.org> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
364 lines
9.1 KiB
C
364 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, 0,
|
|
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;
|
|
}
|
|
}
|
|
|
|
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 && (!need_tid || 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;
|
|
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);
|