mirror of
https://github.com/torvalds/linux.git
synced 2024-12-06 19:11:31 +00:00
58ecdf03db
Messages that are sent to platform, also known as commands and can be: 1. Synchronous commands that block the channel until the requested work has been completed. The platform responds to these commands over the same channel and hence can't be used to send another command until the previous command has completed. 2. Asynchronous commands on the other hand, the platform schedules the requested work to complete later in time and returns almost immediately freeing the channel for new commands. The response indicates the success or failure in the ability to schedule the requested work. When the work has completed, the platform sends an additional delayed response message. Using the same transmit buffer used for sending the asynchronous command even for the delayed response corresponding to it simplifies handling of the delayed response. It's the caller of asynchronous command that is responsible for allocating the completion flag that scmi driver can complete to indicate the arrival of delayed response. Signed-off-by: Sudeep Holla <sudeep.holla@arm.com>
972 lines
26 KiB
C
972 lines
26 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* System Control and Management Interface (SCMI) Message Protocol driver
|
|
*
|
|
* SCMI Message Protocol is used between the System Control Processor(SCP)
|
|
* and the Application Processors(AP). The Message Handling Unit(MHU)
|
|
* provides a mechanism for inter-processor communication between SCP's
|
|
* Cortex M3 and AP.
|
|
*
|
|
* SCP offers control and management of the core/cluster power states,
|
|
* various power domain DVFS including the core/cluster, certain system
|
|
* clocks configuration, thermal sensors and many others.
|
|
*
|
|
* Copyright (C) 2018 ARM Ltd.
|
|
*/
|
|
|
|
#include <linux/bitmap.h>
|
|
#include <linux/export.h>
|
|
#include <linux/io.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/ktime.h>
|
|
#include <linux/mailbox_client.h>
|
|
#include <linux/module.h>
|
|
#include <linux/of_address.h>
|
|
#include <linux/of_device.h>
|
|
#include <linux/processor.h>
|
|
#include <linux/semaphore.h>
|
|
#include <linux/slab.h>
|
|
|
|
#include "common.h"
|
|
|
|
#define MSG_ID_MASK GENMASK(7, 0)
|
|
#define MSG_XTRACT_ID(hdr) FIELD_GET(MSG_ID_MASK, (hdr))
|
|
#define MSG_TYPE_MASK GENMASK(9, 8)
|
|
#define MSG_XTRACT_TYPE(hdr) FIELD_GET(MSG_TYPE_MASK, (hdr))
|
|
#define MSG_TYPE_COMMAND 0
|
|
#define MSG_TYPE_DELAYED_RESP 2
|
|
#define MSG_TYPE_NOTIFICATION 3
|
|
#define MSG_PROTOCOL_ID_MASK GENMASK(17, 10)
|
|
#define MSG_XTRACT_PROT_ID(hdr) FIELD_GET(MSG_PROTOCOL_ID_MASK, (hdr))
|
|
#define MSG_TOKEN_ID_MASK GENMASK(27, 18)
|
|
#define MSG_XTRACT_TOKEN(hdr) FIELD_GET(MSG_TOKEN_ID_MASK, (hdr))
|
|
#define MSG_TOKEN_MAX (MSG_XTRACT_TOKEN(MSG_TOKEN_ID_MASK) + 1)
|
|
|
|
enum scmi_error_codes {
|
|
SCMI_SUCCESS = 0, /* Success */
|
|
SCMI_ERR_SUPPORT = -1, /* Not supported */
|
|
SCMI_ERR_PARAMS = -2, /* Invalid Parameters */
|
|
SCMI_ERR_ACCESS = -3, /* Invalid access/permission denied */
|
|
SCMI_ERR_ENTRY = -4, /* Not found */
|
|
SCMI_ERR_RANGE = -5, /* Value out of range */
|
|
SCMI_ERR_BUSY = -6, /* Device busy */
|
|
SCMI_ERR_COMMS = -7, /* Communication Error */
|
|
SCMI_ERR_GENERIC = -8, /* Generic Error */
|
|
SCMI_ERR_HARDWARE = -9, /* Hardware Error */
|
|
SCMI_ERR_PROTOCOL = -10,/* Protocol Error */
|
|
SCMI_ERR_MAX
|
|
};
|
|
|
|
/* List of all SCMI devices active in system */
|
|
static LIST_HEAD(scmi_list);
|
|
/* Protection for the entire list */
|
|
static DEFINE_MUTEX(scmi_list_mutex);
|
|
|
|
/**
|
|
* struct scmi_xfers_info - Structure to manage transfer information
|
|
*
|
|
* @xfer_block: Preallocated Message array
|
|
* @xfer_alloc_table: Bitmap table for allocated messages.
|
|
* Index of this bitmap table is also used for message
|
|
* sequence identifier.
|
|
* @xfer_lock: Protection for message allocation
|
|
*/
|
|
struct scmi_xfers_info {
|
|
struct scmi_xfer *xfer_block;
|
|
unsigned long *xfer_alloc_table;
|
|
spinlock_t xfer_lock;
|
|
};
|
|
|
|
/**
|
|
* struct scmi_desc - Description of SoC integration
|
|
*
|
|
* @max_rx_timeout_ms: Timeout for communication with SoC (in Milliseconds)
|
|
* @max_msg: Maximum number of messages that can be pending
|
|
* simultaneously in the system
|
|
* @max_msg_size: Maximum size of data per message that can be handled.
|
|
*/
|
|
struct scmi_desc {
|
|
int max_rx_timeout_ms;
|
|
int max_msg;
|
|
int max_msg_size;
|
|
};
|
|
|
|
/**
|
|
* struct scmi_chan_info - Structure representing a SCMI channel information
|
|
*
|
|
* @cl: Mailbox Client
|
|
* @chan: Transmit/Receive mailbox channel
|
|
* @payload: Transmit/Receive mailbox channel payload area
|
|
* @dev: Reference to device in the SCMI hierarchy corresponding to this
|
|
* channel
|
|
* @handle: Pointer to SCMI entity handle
|
|
*/
|
|
struct scmi_chan_info {
|
|
struct mbox_client cl;
|
|
struct mbox_chan *chan;
|
|
void __iomem *payload;
|
|
struct device *dev;
|
|
struct scmi_handle *handle;
|
|
};
|
|
|
|
/**
|
|
* struct scmi_info - Structure representing a SCMI instance
|
|
*
|
|
* @dev: Device pointer
|
|
* @desc: SoC description for this instance
|
|
* @handle: Instance of SCMI handle to send to clients
|
|
* @version: SCMI revision information containing protocol version,
|
|
* implementation version and (sub-)vendor identification.
|
|
* @tx_minfo: Universal Transmit Message management info
|
|
* @tx_idr: IDR object to map protocol id to Tx channel info pointer
|
|
* @rx_idr: IDR object to map protocol id to Rx channel info pointer
|
|
* @protocols_imp: List of protocols implemented, currently maximum of
|
|
* MAX_PROTOCOLS_IMP elements allocated by the base protocol
|
|
* @node: List head
|
|
* @users: Number of users of this instance
|
|
*/
|
|
struct scmi_info {
|
|
struct device *dev;
|
|
const struct scmi_desc *desc;
|
|
struct scmi_revision_info version;
|
|
struct scmi_handle handle;
|
|
struct scmi_xfers_info tx_minfo;
|
|
struct idr tx_idr;
|
|
struct idr rx_idr;
|
|
u8 *protocols_imp;
|
|
struct list_head node;
|
|
int users;
|
|
};
|
|
|
|
#define client_to_scmi_chan_info(c) container_of(c, struct scmi_chan_info, cl)
|
|
#define handle_to_scmi_info(h) container_of(h, struct scmi_info, handle)
|
|
|
|
/*
|
|
* SCMI specification requires all parameters, message headers, return
|
|
* arguments or any protocol data to be expressed in little endian
|
|
* format only.
|
|
*/
|
|
struct scmi_shared_mem {
|
|
__le32 reserved;
|
|
__le32 channel_status;
|
|
#define SCMI_SHMEM_CHAN_STAT_CHANNEL_ERROR BIT(1)
|
|
#define SCMI_SHMEM_CHAN_STAT_CHANNEL_FREE BIT(0)
|
|
__le32 reserved1[2];
|
|
__le32 flags;
|
|
#define SCMI_SHMEM_FLAG_INTR_ENABLED BIT(0)
|
|
__le32 length;
|
|
__le32 msg_header;
|
|
u8 msg_payload[0];
|
|
};
|
|
|
|
static const int scmi_linux_errmap[] = {
|
|
/* better than switch case as long as return value is continuous */
|
|
0, /* SCMI_SUCCESS */
|
|
-EOPNOTSUPP, /* SCMI_ERR_SUPPORT */
|
|
-EINVAL, /* SCMI_ERR_PARAM */
|
|
-EACCES, /* SCMI_ERR_ACCESS */
|
|
-ENOENT, /* SCMI_ERR_ENTRY */
|
|
-ERANGE, /* SCMI_ERR_RANGE */
|
|
-EBUSY, /* SCMI_ERR_BUSY */
|
|
-ECOMM, /* SCMI_ERR_COMMS */
|
|
-EIO, /* SCMI_ERR_GENERIC */
|
|
-EREMOTEIO, /* SCMI_ERR_HARDWARE */
|
|
-EPROTO, /* SCMI_ERR_PROTOCOL */
|
|
};
|
|
|
|
static inline int scmi_to_linux_errno(int errno)
|
|
{
|
|
if (errno < SCMI_SUCCESS && errno > SCMI_ERR_MAX)
|
|
return scmi_linux_errmap[-errno];
|
|
return -EIO;
|
|
}
|
|
|
|
/**
|
|
* scmi_dump_header_dbg() - Helper to dump a message header.
|
|
*
|
|
* @dev: Device pointer corresponding to the SCMI entity
|
|
* @hdr: pointer to header.
|
|
*/
|
|
static inline void scmi_dump_header_dbg(struct device *dev,
|
|
struct scmi_msg_hdr *hdr)
|
|
{
|
|
dev_dbg(dev, "Message ID: %x Sequence ID: %x Protocol: %x\n",
|
|
hdr->id, hdr->seq, hdr->protocol_id);
|
|
}
|
|
|
|
static void scmi_fetch_response(struct scmi_xfer *xfer,
|
|
struct scmi_shared_mem __iomem *mem)
|
|
{
|
|
xfer->hdr.status = ioread32(mem->msg_payload);
|
|
/* Skip the length of header and status in payload area i.e 8 bytes */
|
|
xfer->rx.len = min_t(size_t, xfer->rx.len, ioread32(&mem->length) - 8);
|
|
|
|
/* Take a copy to the rx buffer.. */
|
|
memcpy_fromio(xfer->rx.buf, mem->msg_payload + 4, xfer->rx.len);
|
|
}
|
|
|
|
/**
|
|
* pack_scmi_header() - packs and returns 32-bit header
|
|
*
|
|
* @hdr: pointer to header containing all the information on message id,
|
|
* protocol id and sequence id.
|
|
*
|
|
* Return: 32-bit packed message header to be sent to the platform.
|
|
*/
|
|
static inline u32 pack_scmi_header(struct scmi_msg_hdr *hdr)
|
|
{
|
|
return FIELD_PREP(MSG_ID_MASK, hdr->id) |
|
|
FIELD_PREP(MSG_TOKEN_ID_MASK, hdr->seq) |
|
|
FIELD_PREP(MSG_PROTOCOL_ID_MASK, hdr->protocol_id);
|
|
}
|
|
|
|
/**
|
|
* unpack_scmi_header() - unpacks and records message and protocol id
|
|
*
|
|
* @msg_hdr: 32-bit packed message header sent from the platform
|
|
* @hdr: pointer to header to fetch message and protocol id.
|
|
*/
|
|
static inline void unpack_scmi_header(u32 msg_hdr, struct scmi_msg_hdr *hdr)
|
|
{
|
|
hdr->id = MSG_XTRACT_ID(msg_hdr);
|
|
hdr->protocol_id = MSG_XTRACT_PROT_ID(msg_hdr);
|
|
}
|
|
|
|
/**
|
|
* scmi_tx_prepare() - mailbox client callback to prepare for the transfer
|
|
*
|
|
* @cl: client pointer
|
|
* @m: mailbox message
|
|
*
|
|
* This function prepares the shared memory which contains the header and the
|
|
* payload.
|
|
*/
|
|
static void scmi_tx_prepare(struct mbox_client *cl, void *m)
|
|
{
|
|
struct scmi_xfer *t = m;
|
|
struct scmi_chan_info *cinfo = client_to_scmi_chan_info(cl);
|
|
struct scmi_shared_mem __iomem *mem = cinfo->payload;
|
|
|
|
/*
|
|
* Ideally channel must be free by now unless OS timeout last
|
|
* request and platform continued to process the same, wait
|
|
* until it releases the shared memory, otherwise we may endup
|
|
* overwriting its response with new message payload or vice-versa
|
|
*/
|
|
spin_until_cond(ioread32(&mem->channel_status) &
|
|
SCMI_SHMEM_CHAN_STAT_CHANNEL_FREE);
|
|
/* Mark channel busy + clear error */
|
|
iowrite32(0x0, &mem->channel_status);
|
|
iowrite32(t->hdr.poll_completion ? 0 : SCMI_SHMEM_FLAG_INTR_ENABLED,
|
|
&mem->flags);
|
|
iowrite32(sizeof(mem->msg_header) + t->tx.len, &mem->length);
|
|
iowrite32(pack_scmi_header(&t->hdr), &mem->msg_header);
|
|
if (t->tx.buf)
|
|
memcpy_toio(mem->msg_payload, t->tx.buf, t->tx.len);
|
|
}
|
|
|
|
/**
|
|
* scmi_xfer_get() - Allocate one message
|
|
*
|
|
* @handle: Pointer to SCMI entity handle
|
|
* @minfo: Pointer to Tx/Rx Message management info based on channel type
|
|
*
|
|
* Helper function which is used by various message functions that are
|
|
* exposed to clients of this driver for allocating a message traffic event.
|
|
*
|
|
* This function can sleep depending on pending requests already in the system
|
|
* for the SCMI entity. Further, this also holds a spinlock to maintain
|
|
* integrity of internal data structures.
|
|
*
|
|
* Return: 0 if all went fine, else corresponding error.
|
|
*/
|
|
static struct scmi_xfer *scmi_xfer_get(const struct scmi_handle *handle,
|
|
struct scmi_xfers_info *minfo)
|
|
{
|
|
u16 xfer_id;
|
|
struct scmi_xfer *xfer;
|
|
unsigned long flags, bit_pos;
|
|
struct scmi_info *info = handle_to_scmi_info(handle);
|
|
|
|
/* Keep the locked section as small as possible */
|
|
spin_lock_irqsave(&minfo->xfer_lock, flags);
|
|
bit_pos = find_first_zero_bit(minfo->xfer_alloc_table,
|
|
info->desc->max_msg);
|
|
if (bit_pos == info->desc->max_msg) {
|
|
spin_unlock_irqrestore(&minfo->xfer_lock, flags);
|
|
return ERR_PTR(-ENOMEM);
|
|
}
|
|
set_bit(bit_pos, minfo->xfer_alloc_table);
|
|
spin_unlock_irqrestore(&minfo->xfer_lock, flags);
|
|
|
|
xfer_id = bit_pos;
|
|
|
|
xfer = &minfo->xfer_block[xfer_id];
|
|
xfer->hdr.seq = xfer_id;
|
|
reinit_completion(&xfer->done);
|
|
|
|
return xfer;
|
|
}
|
|
|
|
/**
|
|
* __scmi_xfer_put() - Release a message
|
|
*
|
|
* @minfo: Pointer to Tx/Rx Message management info based on channel type
|
|
* @xfer: message that was reserved by scmi_xfer_get
|
|
*
|
|
* This holds a spinlock to maintain integrity of internal data structures.
|
|
*/
|
|
static void
|
|
__scmi_xfer_put(struct scmi_xfers_info *minfo, struct scmi_xfer *xfer)
|
|
{
|
|
unsigned long flags;
|
|
|
|
/*
|
|
* Keep the locked section as small as possible
|
|
* NOTE: we might escape with smp_mb and no lock here..
|
|
* but just be conservative and symmetric.
|
|
*/
|
|
spin_lock_irqsave(&minfo->xfer_lock, flags);
|
|
clear_bit(xfer->hdr.seq, minfo->xfer_alloc_table);
|
|
spin_unlock_irqrestore(&minfo->xfer_lock, flags);
|
|
}
|
|
|
|
/**
|
|
* scmi_rx_callback() - mailbox client callback for receive messages
|
|
*
|
|
* @cl: client pointer
|
|
* @m: mailbox message
|
|
*
|
|
* Processes one received message to appropriate transfer information and
|
|
* signals completion of the transfer.
|
|
*
|
|
* NOTE: This function will be invoked in IRQ context, hence should be
|
|
* as optimal as possible.
|
|
*/
|
|
static void scmi_rx_callback(struct mbox_client *cl, void *m)
|
|
{
|
|
u8 msg_type;
|
|
u32 msg_hdr;
|
|
u16 xfer_id;
|
|
struct scmi_xfer *xfer;
|
|
struct scmi_chan_info *cinfo = client_to_scmi_chan_info(cl);
|
|
struct device *dev = cinfo->dev;
|
|
struct scmi_info *info = handle_to_scmi_info(cinfo->handle);
|
|
struct scmi_xfers_info *minfo = &info->tx_minfo;
|
|
struct scmi_shared_mem __iomem *mem = cinfo->payload;
|
|
|
|
msg_hdr = ioread32(&mem->msg_header);
|
|
msg_type = MSG_XTRACT_TYPE(msg_hdr);
|
|
xfer_id = MSG_XTRACT_TOKEN(msg_hdr);
|
|
|
|
if (msg_type == MSG_TYPE_NOTIFICATION)
|
|
return; /* Notifications not yet supported */
|
|
|
|
/* Are we even expecting this? */
|
|
if (!test_bit(xfer_id, minfo->xfer_alloc_table)) {
|
|
dev_err(dev, "message for %d is not expected!\n", xfer_id);
|
|
return;
|
|
}
|
|
|
|
xfer = &minfo->xfer_block[xfer_id];
|
|
|
|
scmi_dump_header_dbg(dev, &xfer->hdr);
|
|
|
|
scmi_fetch_response(xfer, mem);
|
|
|
|
if (msg_type == MSG_TYPE_DELAYED_RESP)
|
|
complete(xfer->async_done);
|
|
else
|
|
complete(&xfer->done);
|
|
}
|
|
|
|
/**
|
|
* scmi_xfer_put() - Release a transmit message
|
|
*
|
|
* @handle: Pointer to SCMI entity handle
|
|
* @xfer: message that was reserved by scmi_xfer_get
|
|
*/
|
|
void scmi_xfer_put(const struct scmi_handle *handle, struct scmi_xfer *xfer)
|
|
{
|
|
struct scmi_info *info = handle_to_scmi_info(handle);
|
|
|
|
__scmi_xfer_put(&info->tx_minfo, xfer);
|
|
}
|
|
|
|
static bool
|
|
scmi_xfer_poll_done(const struct scmi_chan_info *cinfo, struct scmi_xfer *xfer)
|
|
{
|
|
struct scmi_shared_mem __iomem *mem = cinfo->payload;
|
|
u16 xfer_id = MSG_XTRACT_TOKEN(ioread32(&mem->msg_header));
|
|
|
|
if (xfer->hdr.seq != xfer_id)
|
|
return false;
|
|
|
|
return ioread32(&mem->channel_status) &
|
|
(SCMI_SHMEM_CHAN_STAT_CHANNEL_ERROR |
|
|
SCMI_SHMEM_CHAN_STAT_CHANNEL_FREE);
|
|
}
|
|
|
|
#define SCMI_MAX_POLL_TO_NS (100 * NSEC_PER_USEC)
|
|
|
|
static bool scmi_xfer_done_no_timeout(const struct scmi_chan_info *cinfo,
|
|
struct scmi_xfer *xfer, ktime_t stop)
|
|
{
|
|
ktime_t __cur = ktime_get();
|
|
|
|
return scmi_xfer_poll_done(cinfo, xfer) || ktime_after(__cur, stop);
|
|
}
|
|
|
|
/**
|
|
* scmi_do_xfer() - Do one transfer
|
|
*
|
|
* @handle: Pointer to SCMI entity handle
|
|
* @xfer: Transfer to initiate and wait for response
|
|
*
|
|
* Return: -ETIMEDOUT in case of no response, if transmit error,
|
|
* return corresponding error, else if all goes well,
|
|
* return 0.
|
|
*/
|
|
int scmi_do_xfer(const struct scmi_handle *handle, struct scmi_xfer *xfer)
|
|
{
|
|
int ret;
|
|
int timeout;
|
|
struct scmi_info *info = handle_to_scmi_info(handle);
|
|
struct device *dev = info->dev;
|
|
struct scmi_chan_info *cinfo;
|
|
|
|
cinfo = idr_find(&info->tx_idr, xfer->hdr.protocol_id);
|
|
if (unlikely(!cinfo))
|
|
return -EINVAL;
|
|
|
|
ret = mbox_send_message(cinfo->chan, xfer);
|
|
if (ret < 0) {
|
|
dev_dbg(dev, "mbox send fail %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
/* mbox_send_message returns non-negative value on success, so reset */
|
|
ret = 0;
|
|
|
|
if (xfer->hdr.poll_completion) {
|
|
ktime_t stop = ktime_add_ns(ktime_get(), SCMI_MAX_POLL_TO_NS);
|
|
|
|
spin_until_cond(scmi_xfer_done_no_timeout(cinfo, xfer, stop));
|
|
|
|
if (ktime_before(ktime_get(), stop))
|
|
scmi_fetch_response(xfer, cinfo->payload);
|
|
else
|
|
ret = -ETIMEDOUT;
|
|
} else {
|
|
/* And we wait for the response. */
|
|
timeout = msecs_to_jiffies(info->desc->max_rx_timeout_ms);
|
|
if (!wait_for_completion_timeout(&xfer->done, timeout)) {
|
|
dev_err(dev, "mbox timed out in resp(caller: %pS)\n",
|
|
(void *)_RET_IP_);
|
|
ret = -ETIMEDOUT;
|
|
}
|
|
}
|
|
|
|
if (!ret && xfer->hdr.status)
|
|
ret = scmi_to_linux_errno(xfer->hdr.status);
|
|
|
|
/*
|
|
* NOTE: we might prefer not to need the mailbox ticker to manage the
|
|
* transfer queueing since the protocol layer queues things by itself.
|
|
* Unfortunately, we have to kick the mailbox framework after we have
|
|
* received our message.
|
|
*/
|
|
mbox_client_txdone(cinfo->chan, ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
#define SCMI_MAX_RESPONSE_TIMEOUT (2 * MSEC_PER_SEC)
|
|
|
|
/**
|
|
* scmi_do_xfer_with_response() - Do one transfer and wait until the delayed
|
|
* response is received
|
|
*
|
|
* @handle: Pointer to SCMI entity handle
|
|
* @xfer: Transfer to initiate and wait for response
|
|
*
|
|
* Return: -ETIMEDOUT in case of no delayed response, if transmit error,
|
|
* return corresponding error, else if all goes well, return 0.
|
|
*/
|
|
int scmi_do_xfer_with_response(const struct scmi_handle *handle,
|
|
struct scmi_xfer *xfer)
|
|
{
|
|
int ret, timeout = msecs_to_jiffies(SCMI_MAX_RESPONSE_TIMEOUT);
|
|
DECLARE_COMPLETION_ONSTACK(async_response);
|
|
|
|
xfer->async_done = &async_response;
|
|
|
|
ret = scmi_do_xfer(handle, xfer);
|
|
if (!ret && !wait_for_completion_timeout(xfer->async_done, timeout))
|
|
ret = -ETIMEDOUT;
|
|
|
|
xfer->async_done = NULL;
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* scmi_xfer_get_init() - Allocate and initialise one message for transmit
|
|
*
|
|
* @handle: Pointer to SCMI entity handle
|
|
* @msg_id: Message identifier
|
|
* @prot_id: Protocol identifier for the message
|
|
* @tx_size: transmit message size
|
|
* @rx_size: receive message size
|
|
* @p: pointer to the allocated and initialised message
|
|
*
|
|
* This function allocates the message using @scmi_xfer_get and
|
|
* initialise the header.
|
|
*
|
|
* Return: 0 if all went fine with @p pointing to message, else
|
|
* corresponding error.
|
|
*/
|
|
int scmi_xfer_get_init(const struct scmi_handle *handle, u8 msg_id, u8 prot_id,
|
|
size_t tx_size, size_t rx_size, struct scmi_xfer **p)
|
|
{
|
|
int ret;
|
|
struct scmi_xfer *xfer;
|
|
struct scmi_info *info = handle_to_scmi_info(handle);
|
|
struct scmi_xfers_info *minfo = &info->tx_minfo;
|
|
struct device *dev = info->dev;
|
|
|
|
/* Ensure we have sane transfer sizes */
|
|
if (rx_size > info->desc->max_msg_size ||
|
|
tx_size > info->desc->max_msg_size)
|
|
return -ERANGE;
|
|
|
|
xfer = scmi_xfer_get(handle, minfo);
|
|
if (IS_ERR(xfer)) {
|
|
ret = PTR_ERR(xfer);
|
|
dev_err(dev, "failed to get free message slot(%d)\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
xfer->tx.len = tx_size;
|
|
xfer->rx.len = rx_size ? : info->desc->max_msg_size;
|
|
xfer->hdr.id = msg_id;
|
|
xfer->hdr.protocol_id = prot_id;
|
|
xfer->hdr.poll_completion = false;
|
|
|
|
*p = xfer;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* scmi_version_get() - command to get the revision of the SCMI entity
|
|
*
|
|
* @handle: Pointer to SCMI entity handle
|
|
* @protocol: Protocol identifier for the message
|
|
* @version: Holds returned version of protocol.
|
|
*
|
|
* Updates the SCMI information in the internal data structure.
|
|
*
|
|
* Return: 0 if all went fine, else return appropriate error.
|
|
*/
|
|
int scmi_version_get(const struct scmi_handle *handle, u8 protocol,
|
|
u32 *version)
|
|
{
|
|
int ret;
|
|
__le32 *rev_info;
|
|
struct scmi_xfer *t;
|
|
|
|
ret = scmi_xfer_get_init(handle, PROTOCOL_VERSION, protocol, 0,
|
|
sizeof(*version), &t);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = scmi_do_xfer(handle, t);
|
|
if (!ret) {
|
|
rev_info = t->rx.buf;
|
|
*version = le32_to_cpu(*rev_info);
|
|
}
|
|
|
|
scmi_xfer_put(handle, t);
|
|
return ret;
|
|
}
|
|
|
|
void scmi_setup_protocol_implemented(const struct scmi_handle *handle,
|
|
u8 *prot_imp)
|
|
{
|
|
struct scmi_info *info = handle_to_scmi_info(handle);
|
|
|
|
info->protocols_imp = prot_imp;
|
|
}
|
|
|
|
static bool
|
|
scmi_is_protocol_implemented(const struct scmi_handle *handle, u8 prot_id)
|
|
{
|
|
int i;
|
|
struct scmi_info *info = handle_to_scmi_info(handle);
|
|
|
|
if (!info->protocols_imp)
|
|
return false;
|
|
|
|
for (i = 0; i < MAX_PROTOCOLS_IMP; i++)
|
|
if (info->protocols_imp[i] == prot_id)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* scmi_handle_get() - Get the SCMI handle for a device
|
|
*
|
|
* @dev: pointer to device for which we want SCMI handle
|
|
*
|
|
* NOTE: The function does not track individual clients of the framework
|
|
* and is expected to be maintained by caller of SCMI protocol library.
|
|
* scmi_handle_put must be balanced with successful scmi_handle_get
|
|
*
|
|
* Return: pointer to handle if successful, NULL on error
|
|
*/
|
|
struct scmi_handle *scmi_handle_get(struct device *dev)
|
|
{
|
|
struct list_head *p;
|
|
struct scmi_info *info;
|
|
struct scmi_handle *handle = NULL;
|
|
|
|
mutex_lock(&scmi_list_mutex);
|
|
list_for_each(p, &scmi_list) {
|
|
info = list_entry(p, struct scmi_info, node);
|
|
if (dev->parent == info->dev) {
|
|
handle = &info->handle;
|
|
info->users++;
|
|
break;
|
|
}
|
|
}
|
|
mutex_unlock(&scmi_list_mutex);
|
|
|
|
return handle;
|
|
}
|
|
|
|
/**
|
|
* scmi_handle_put() - Release the handle acquired by scmi_handle_get
|
|
*
|
|
* @handle: handle acquired by scmi_handle_get
|
|
*
|
|
* NOTE: The function does not track individual clients of the framework
|
|
* and is expected to be maintained by caller of SCMI protocol library.
|
|
* scmi_handle_put must be balanced with successful scmi_handle_get
|
|
*
|
|
* Return: 0 is successfully released
|
|
* if null was passed, it returns -EINVAL;
|
|
*/
|
|
int scmi_handle_put(const struct scmi_handle *handle)
|
|
{
|
|
struct scmi_info *info;
|
|
|
|
if (!handle)
|
|
return -EINVAL;
|
|
|
|
info = handle_to_scmi_info(handle);
|
|
mutex_lock(&scmi_list_mutex);
|
|
if (!WARN_ON(!info->users))
|
|
info->users--;
|
|
mutex_unlock(&scmi_list_mutex);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int scmi_xfer_info_init(struct scmi_info *sinfo)
|
|
{
|
|
int i;
|
|
struct scmi_xfer *xfer;
|
|
struct device *dev = sinfo->dev;
|
|
const struct scmi_desc *desc = sinfo->desc;
|
|
struct scmi_xfers_info *info = &sinfo->tx_minfo;
|
|
|
|
/* Pre-allocated messages, no more than what hdr.seq can support */
|
|
if (WARN_ON(desc->max_msg >= MSG_TOKEN_MAX)) {
|
|
dev_err(dev, "Maximum message of %d exceeds supported %ld\n",
|
|
desc->max_msg, MSG_TOKEN_MAX);
|
|
return -EINVAL;
|
|
}
|
|
|
|
info->xfer_block = devm_kcalloc(dev, desc->max_msg,
|
|
sizeof(*info->xfer_block), GFP_KERNEL);
|
|
if (!info->xfer_block)
|
|
return -ENOMEM;
|
|
|
|
info->xfer_alloc_table = devm_kcalloc(dev, BITS_TO_LONGS(desc->max_msg),
|
|
sizeof(long), GFP_KERNEL);
|
|
if (!info->xfer_alloc_table)
|
|
return -ENOMEM;
|
|
|
|
/* Pre-initialize the buffer pointer to pre-allocated buffers */
|
|
for (i = 0, xfer = info->xfer_block; i < desc->max_msg; i++, xfer++) {
|
|
xfer->rx.buf = devm_kcalloc(dev, sizeof(u8), desc->max_msg_size,
|
|
GFP_KERNEL);
|
|
if (!xfer->rx.buf)
|
|
return -ENOMEM;
|
|
|
|
xfer->tx.buf = xfer->rx.buf;
|
|
init_completion(&xfer->done);
|
|
}
|
|
|
|
spin_lock_init(&info->xfer_lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int scmi_mailbox_check(struct device_node *np, int idx)
|
|
{
|
|
return of_parse_phandle_with_args(np, "mboxes", "#mbox-cells",
|
|
idx, NULL);
|
|
}
|
|
|
|
static int scmi_mbox_chan_setup(struct scmi_info *info, struct device *dev,
|
|
int prot_id, bool tx)
|
|
{
|
|
int ret, idx;
|
|
struct resource res;
|
|
resource_size_t size;
|
|
struct device_node *shmem, *np = dev->of_node;
|
|
struct scmi_chan_info *cinfo;
|
|
struct mbox_client *cl;
|
|
struct idr *idr;
|
|
const char *desc = tx ? "Tx" : "Rx";
|
|
|
|
/* Transmit channel is first entry i.e. index 0 */
|
|
idx = tx ? 0 : 1;
|
|
idr = tx ? &info->tx_idr : &info->rx_idr;
|
|
|
|
if (scmi_mailbox_check(np, idx)) {
|
|
cinfo = idr_find(idr, SCMI_PROTOCOL_BASE);
|
|
if (unlikely(!cinfo)) /* Possible only if platform has no Rx */
|
|
return -EINVAL;
|
|
goto idr_alloc;
|
|
}
|
|
|
|
cinfo = devm_kzalloc(info->dev, sizeof(*cinfo), GFP_KERNEL);
|
|
if (!cinfo)
|
|
return -ENOMEM;
|
|
|
|
cinfo->dev = dev;
|
|
|
|
cl = &cinfo->cl;
|
|
cl->dev = dev;
|
|
cl->rx_callback = scmi_rx_callback;
|
|
cl->tx_prepare = tx ? scmi_tx_prepare : NULL;
|
|
cl->tx_block = false;
|
|
cl->knows_txdone = tx;
|
|
|
|
shmem = of_parse_phandle(np, "shmem", idx);
|
|
ret = of_address_to_resource(shmem, 0, &res);
|
|
of_node_put(shmem);
|
|
if (ret) {
|
|
dev_err(dev, "failed to get SCMI %s payload memory\n", desc);
|
|
return ret;
|
|
}
|
|
|
|
size = resource_size(&res);
|
|
cinfo->payload = devm_ioremap(info->dev, res.start, size);
|
|
if (!cinfo->payload) {
|
|
dev_err(dev, "failed to ioremap SCMI %s payload\n", desc);
|
|
return -EADDRNOTAVAIL;
|
|
}
|
|
|
|
cinfo->chan = mbox_request_channel(cl, idx);
|
|
if (IS_ERR(cinfo->chan)) {
|
|
ret = PTR_ERR(cinfo->chan);
|
|
if (ret != -EPROBE_DEFER)
|
|
dev_err(dev, "failed to request SCMI %s mailbox\n",
|
|
desc);
|
|
return ret;
|
|
}
|
|
|
|
idr_alloc:
|
|
ret = idr_alloc(idr, cinfo, prot_id, prot_id + 1, GFP_KERNEL);
|
|
if (ret != prot_id) {
|
|
dev_err(dev, "unable to allocate SCMI idr slot err %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
cinfo->handle = &info->handle;
|
|
return 0;
|
|
}
|
|
|
|
static inline int
|
|
scmi_mbox_txrx_setup(struct scmi_info *info, struct device *dev, int prot_id)
|
|
{
|
|
int ret = scmi_mbox_chan_setup(info, dev, prot_id, true);
|
|
|
|
if (!ret) /* Rx is optional, hence no error check */
|
|
scmi_mbox_chan_setup(info, dev, prot_id, false);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static inline void
|
|
scmi_create_protocol_device(struct device_node *np, struct scmi_info *info,
|
|
int prot_id)
|
|
{
|
|
struct scmi_device *sdev;
|
|
|
|
sdev = scmi_device_create(np, info->dev, prot_id);
|
|
if (!sdev) {
|
|
dev_err(info->dev, "failed to create %d protocol device\n",
|
|
prot_id);
|
|
return;
|
|
}
|
|
|
|
if (scmi_mbox_txrx_setup(info, &sdev->dev, prot_id)) {
|
|
dev_err(&sdev->dev, "failed to setup transport\n");
|
|
scmi_device_destroy(sdev);
|
|
return;
|
|
}
|
|
|
|
/* setup handle now as the transport is ready */
|
|
scmi_set_handle(sdev);
|
|
}
|
|
|
|
static int scmi_probe(struct platform_device *pdev)
|
|
{
|
|
int ret;
|
|
struct scmi_handle *handle;
|
|
const struct scmi_desc *desc;
|
|
struct scmi_info *info;
|
|
struct device *dev = &pdev->dev;
|
|
struct device_node *child, *np = dev->of_node;
|
|
|
|
/* Only mailbox method supported, check for the presence of one */
|
|
if (scmi_mailbox_check(np, 0)) {
|
|
dev_err(dev, "no mailbox found in %pOF\n", np);
|
|
return -EINVAL;
|
|
}
|
|
|
|
desc = of_device_get_match_data(dev);
|
|
if (!desc)
|
|
return -EINVAL;
|
|
|
|
info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL);
|
|
if (!info)
|
|
return -ENOMEM;
|
|
|
|
info->dev = dev;
|
|
info->desc = desc;
|
|
INIT_LIST_HEAD(&info->node);
|
|
|
|
ret = scmi_xfer_info_init(info);
|
|
if (ret)
|
|
return ret;
|
|
|
|
platform_set_drvdata(pdev, info);
|
|
idr_init(&info->tx_idr);
|
|
idr_init(&info->rx_idr);
|
|
|
|
handle = &info->handle;
|
|
handle->dev = info->dev;
|
|
handle->version = &info->version;
|
|
|
|
ret = scmi_mbox_txrx_setup(info, dev, SCMI_PROTOCOL_BASE);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = scmi_base_protocol_init(handle);
|
|
if (ret) {
|
|
dev_err(dev, "unable to communicate with SCMI(%d)\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
mutex_lock(&scmi_list_mutex);
|
|
list_add_tail(&info->node, &scmi_list);
|
|
mutex_unlock(&scmi_list_mutex);
|
|
|
|
for_each_available_child_of_node(np, child) {
|
|
u32 prot_id;
|
|
|
|
if (of_property_read_u32(child, "reg", &prot_id))
|
|
continue;
|
|
|
|
if (!FIELD_FIT(MSG_PROTOCOL_ID_MASK, prot_id))
|
|
dev_err(dev, "Out of range protocol %d\n", prot_id);
|
|
|
|
if (!scmi_is_protocol_implemented(handle, prot_id)) {
|
|
dev_err(dev, "SCMI protocol %d not implemented\n",
|
|
prot_id);
|
|
continue;
|
|
}
|
|
|
|
scmi_create_protocol_device(child, info, prot_id);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int scmi_mbox_free_channel(int id, void *p, void *data)
|
|
{
|
|
struct scmi_chan_info *cinfo = p;
|
|
struct idr *idr = data;
|
|
|
|
if (!IS_ERR_OR_NULL(cinfo->chan)) {
|
|
mbox_free_channel(cinfo->chan);
|
|
cinfo->chan = NULL;
|
|
}
|
|
|
|
idr_remove(idr, id);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int scmi_remove(struct platform_device *pdev)
|
|
{
|
|
int ret = 0;
|
|
struct scmi_info *info = platform_get_drvdata(pdev);
|
|
struct idr *idr = &info->tx_idr;
|
|
|
|
mutex_lock(&scmi_list_mutex);
|
|
if (info->users)
|
|
ret = -EBUSY;
|
|
else
|
|
list_del(&info->node);
|
|
mutex_unlock(&scmi_list_mutex);
|
|
|
|
if (ret)
|
|
return ret;
|
|
|
|
/* Safe to free channels since no more users */
|
|
ret = idr_for_each(idr, scmi_mbox_free_channel, idr);
|
|
idr_destroy(&info->tx_idr);
|
|
|
|
idr = &info->rx_idr;
|
|
ret = idr_for_each(idr, scmi_mbox_free_channel, idr);
|
|
idr_destroy(&info->rx_idr);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static const struct scmi_desc scmi_generic_desc = {
|
|
.max_rx_timeout_ms = 30, /* We may increase this if required */
|
|
.max_msg = 20, /* Limited by MBOX_TX_QUEUE_LEN */
|
|
.max_msg_size = 128,
|
|
};
|
|
|
|
/* Each compatible listed below must have descriptor associated with it */
|
|
static const struct of_device_id scmi_of_match[] = {
|
|
{ .compatible = "arm,scmi", .data = &scmi_generic_desc },
|
|
{ /* Sentinel */ },
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(of, scmi_of_match);
|
|
|
|
static struct platform_driver scmi_driver = {
|
|
.driver = {
|
|
.name = "arm-scmi",
|
|
.of_match_table = scmi_of_match,
|
|
},
|
|
.probe = scmi_probe,
|
|
.remove = scmi_remove,
|
|
};
|
|
|
|
module_platform_driver(scmi_driver);
|
|
|
|
MODULE_ALIAS("platform: arm-scmi");
|
|
MODULE_AUTHOR("Sudeep Holla <sudeep.holla@arm.com>");
|
|
MODULE_DESCRIPTION("ARM SCMI protocol driver");
|
|
MODULE_LICENSE("GPL v2");
|