Files
opensbi/lib/utils/mpxy/fdt_mpxy_rpmi.c
T
Anup Patel 8c04100096 lib: utils/mpxy: Use domain notifier for deferred creation of MPXY RPMI
The owner domain may not be available at the time of creating MPXY RPMI
instance so use domain notifier for deferred creation.

Signed-off-by: Anup Patel <anup.patel@oss.qualcomm.com>
Reviewed-by: Pawandeep Oza <pawandeep.oza@oss.qualcomm.com>
Tested-by: Pawandeep Oza <pawandeep.oza@oss.qualcomm.com>
Link: https://lore.kernel.org/r/20260923032359.4041876-12-anup.patel@oss.qualcomm.com
Signed-off-by: Anup Patel <anup@brainfault.org>
2026-10-25 14:32:38 +05:30

540 lines
14 KiB
C

/*
* SPDX-License-Identifier: BSD-2-Clause
*
* Copyright (c) 2024 Ventana Micro Systems Inc.
*
* Authors:
* Rahul Pathak <rpathak@ventanamicro.com>
* Anup Patel <apatel@ventanamicro.com>
*/
#include <libfdt.h>
#include <sbi/sbi_domain.h>
#include <sbi/sbi_error.h>
#include <sbi/sbi_heap.h>
#include <sbi/sbi_mpxy.h>
#include <sbi_utils/fdt/fdt_helper.h>
#include <sbi_utils/mailbox/fdt_mailbox.h>
#include <sbi_utils/mpxy/fdt_mpxy.h>
#include <sbi_utils/mpxy/fdt_mpxy_rpmi.h>
/** Convert the mpxy attribute ID to attribute array index */
#define attr_id2index(attr_id) (attr_id - SBI_MPXY_ATTR_MSGPROTO_ATTR_START)
enum mpxy_msgprot_rpmi_attr_id {
MPXY_MSGPROT_RPMI_ATTR_SERVICEGROUP_ID = SBI_MPXY_ATTR_MSGPROTO_ATTR_START,
MPXY_MSGPROT_RPMI_ATTR_SERVICEGROUP_VERSION,
MPXY_MSGPROT_RPMI_ATTR_IMPL_ID,
MPXY_MSGPROT_RPMI_ATTR_IMPL_VERSION,
MPXY_MSGPROT_RPMI_ATTR_MAX_ID
};
/**
* MPXY message protocol attributes for RPMI
* Order of attribute fields must follow the
* attribute IDs in `enum mpxy_msgprot_rpmi_attr_id`
*/
struct mpxy_rpmi_channel_attrs {
u32 servicegrp_id;
u32 servicegrp_ver;
u32 impl_id;
u32 impl_ver;
};
/** Make sure all attributes are packed for direct memcpy */
#define assert_field_offset(field, attr_offset) \
_Static_assert( \
((offsetof(struct mpxy_rpmi_channel_attrs, field)) / \
sizeof(u32)) == (attr_offset - SBI_MPXY_ATTR_MSGPROTO_ATTR_START),\
"field " #field \
" from struct mpxy_rpmi_channel_attrs invalid offset, expected " #attr_offset)
assert_field_offset(servicegrp_id, MPXY_MSGPROT_RPMI_ATTR_SERVICEGROUP_ID);
assert_field_offset(servicegrp_ver, MPXY_MSGPROT_RPMI_ATTR_SERVICEGROUP_VERSION);
assert_field_offset(impl_id, MPXY_MSGPROT_RPMI_ATTR_IMPL_ID);
assert_field_offset(impl_ver, MPXY_MSGPROT_RPMI_ATTR_IMPL_VERSION);
/**
* MPXY RPMI instance per MPXY channel. This ties
* an MPXY channel with an RPMI Service group.
*/
struct mpxy_rpmi {
struct mbox_chan *chan;
const struct mpxy_rpmi_data *data;
struct mpxy_rpmi_channel_attrs msgprot_attrs;
struct sbi_mpxy_channel channel;
void *group_context;
};
/**
* Discover the RPMI service data using message_id
* MPXY message_id == RPMI service_id
*/
static const struct mpxy_rpmi_service_data *mpxy_find_rpmi_srvid(u32 message_id,
const struct mpxy_rpmi_data *data)
{
const struct mpxy_rpmi_service_data *srv = data->service_data;
int mid = 0;
for (mid = 0; srv[mid].id < data->num_services; mid++) {
if (srv[mid].id == (u8)message_id)
return &srv[mid];
}
return NULL;
}
/** Copy attributes word size */
static void mpxy_copy_attrs(u32 *outmem, u32 *inmem, u32 count)
{
u32 idx;
for (idx = 0; idx < count; idx++)
outmem[idx] = cpu_to_le32(inmem[idx]);
}
static int mpxy_read_attributes(struct sbi_mpxy_channel *channel,
u32 *outmem, u32 base_attr_id, u32 attr_count)
{
struct mpxy_rpmi *rmb = container_of(channel, struct mpxy_rpmi, channel);
u32 *attr_array = (u32 *)&rmb->msgprot_attrs;
u32 end_id = base_attr_id + attr_count - 1;
if (end_id >= MPXY_MSGPROT_RPMI_ATTR_MAX_ID)
return SBI_EBAD_RANGE;
mpxy_copy_attrs(outmem, &attr_array[attr_id2index(base_attr_id)],
attr_count);
return SBI_OK;
}
/**
* Verify the channel standard attribute wrt to write permission
* and the value to be set if valid or not.
* Only attributes needs to be checked which are defined Read/Write
* permission. Other with Readonly permission will result in error.
*
* Attributes values to be written must also be checked because
* before writing a range of attributes, we need to make sure that
* either complete range of attributes is written successfully or not
* at all.
*/
static int mpxy_check_write_attr(u32 attr_id, u32 attr_val)
{
int ret = SBI_OK;
switch(attr_id) {
/** All RO access attributes falls under default */
default:
ret = SBI_EBAD_RANGE;
};
return ret;
}
static void mpxy_write_attr(struct mpxy_rpmi_channel_attrs *attrs,
u32 attr_id, u32 attr_val)
{
/* No writable attributes in RPMI */
}
static int mpxy_write_attributes(struct sbi_mpxy_channel *channel,
u32 *outmem, u32 base_attr_id,
u32 attr_count)
{
struct mpxy_rpmi *rmb = container_of(channel, struct mpxy_rpmi, channel);
u32 end_id = base_attr_id + attr_count - 1;
u32 attr_val, idx;
int ret, mem_idx;
if (end_id >= MPXY_MSGPROT_RPMI_ATTR_MAX_ID)
return SBI_EBAD_RANGE;
mem_idx = 0;
for (idx = base_attr_id; idx <= end_id; idx++) {
attr_val = le32_to_cpu(outmem[mem_idx++]);
ret = mpxy_check_write_attr(idx, attr_val);
if (ret)
return ret;
}
mem_idx = 0;
for (idx = base_attr_id; idx <= end_id; idx++) {
attr_val = le32_to_cpu(outmem[mem_idx++]);
mpxy_write_attr(&rmb->msgprot_attrs, idx, attr_val);
}
return SBI_OK;
}
static int __mpxy_send_message(struct sbi_mpxy_channel *channel,
u32 message_id, void *tx, u32 tx_len,
void *rx, u32 rx_max_len, unsigned long *ack_len)
{
struct mpxy_rpmi *rmb = container_of(channel, struct mpxy_rpmi, channel);
const struct mpxy_rpmi_data *data = rmb->data;
const struct mpxy_rpmi_service_data *srv =
mpxy_find_rpmi_srvid(message_id, data);
struct rpmi_message_args args = {0};
struct mbox_xfer xfer;
u32 rx_len = 0;
int ret;
if (!srv)
return SBI_ENOTSUPP;
/** message data size to be sent is in the
* supported service data size range */
if (tx_len < srv->min_tx_len || tx_len > srv->max_tx_len)
return SBI_EFAIL;
if (ack_len) {
/** MPXY buffer cannnot hold service min response data */
if (rx_max_len < srv->min_rx_len)
return SBI_EFAIL;
/* Max rx data size it can expect */
if (srv->max_rx_len < channel->attrs.msg_data_maxlen)
rx_len = srv->max_rx_len;
else
rx_len = channel->attrs.msg_data_maxlen;
args.type = RPMI_MSG_NORMAL_REQUEST;
args.flags = (rx) ? 0 : RPMI_MSG_FLAGS_NO_RX;
args.service_id = srv->id;
mbox_xfer_init_txrx(&xfer, &args,
tx, tx_len, RPMI_DEF_TX_TIMEOUT,
rx, rx_len, RPMI_DEF_RX_TIMEOUT);
}
else {
args.type = RPMI_MSG_POSTED_REQUEST;
args.flags = RPMI_MSG_FLAGS_NO_RX;
args.service_id = srv->id;
mbox_xfer_init_tx(&xfer, &args,
tx, tx_len, RPMI_DEF_TX_TIMEOUT);
}
if (data->xfer_group)
ret = data->xfer_group(rmb->group_context, rmb->chan, &xfer);
else
ret = mbox_chan_xfer(rmb->chan, &xfer);
if (ret)
return ret;
if (ack_len)
*ack_len = args.rx_data_len;
return SBI_OK;
}
static int mpxy_send_message_withresp(struct sbi_mpxy_channel *channel,
u32 message_id, void *tx, u32 tx_len,
void *rx, u32 rx_max_len,
unsigned long *ack_len)
{
return __mpxy_send_message(channel, message_id, tx, tx_len,
rx, rx_max_len, ack_len);
}
static int mpxy_send_message_withoutresp(struct sbi_mpxy_channel *channel,
u32 message_id, void *tx, u32 tx_len)
{
return __mpxy_send_message(channel, message_id, tx, tx_len,
NULL, 0, NULL);
}
static int mpxy_rpmi_get_attribute(struct mpxy_rpmi *rmb,
enum rpmi_channel_attribute_id attr_id,
u32 *out_value)
{
const struct mpxy_rpmi_data *data = rmb->data;
struct mbox_chan *chan = rmb->chan;
int rc;
if (data->get_attribute_group)
rc = data->get_attribute_group(rmb->group_context, chan, attr_id, out_value);
else
rc = mbox_chan_get_attribute(chan, attr_id, out_value);
return rc;
}
static int __mpxy_rpmi_init(const struct mpxy_rpmi_data *data,
struct mbox_chan *chan, u32 mpxy_channel_id,
struct sbi_domain *dom)
{
u32 servicegrp_ver, pro_ver, max_data_len, tx_tout, rx_tout;
struct mpxy_rpmi *rmb;
u32 impl_id, impl_ver;
int rc;
if (!data || !dom)
return SBI_EINVAL;
/*
* When mailbox channel is not available, both get_attribute_group() and
* xfer_group() callbacks must be available.
*/
if (!chan && (!data->get_attribute_group || !data->xfer_group))
return SBI_EINVAL;
/* Allocate context for MPXY RPMI instance */
rmb = sbi_zalloc(sizeof(*rmb));
if (!rmb)
return SBI_ENOMEM;
rmb->data = data;
rmb->chan = chan;
/* Setup RPMI service group context */
if (data->setup_group) {
rc = data->setup_group(&rmb->group_context, chan, dom, data);
if (rc)
goto fail_free_client;
}
/* Get channel protocol version */
rc = mpxy_rpmi_get_attribute(rmb, RPMI_CHANNEL_ATTR_PROTOCOL_VERSION,
&pro_ver);
if (rc)
goto fail_cleanup_group;
/* Get channel maximum data length */
rc = mpxy_rpmi_get_attribute(rmb, RPMI_CHANNEL_ATTR_MAX_DATA_LEN,
&max_data_len);
if (rc)
goto fail_cleanup_group;
/* Get channel Tx timeout */
rc = mpxy_rpmi_get_attribute(rmb, RPMI_CHANNEL_ATTR_TX_TIMEOUT,
&tx_tout);
if (rc)
goto fail_cleanup_group;
/* Get channel Rx timeout */
rc = mpxy_rpmi_get_attribute(rmb, RPMI_CHANNEL_ATTR_RX_TIMEOUT,
&rx_tout);
if (rc)
goto fail_cleanup_group;
/* Get channel service group version */
rc = mpxy_rpmi_get_attribute(rmb, RPMI_CHANNEL_ATTR_SERVICEGROUP_VERSION,
&servicegrp_ver);
if (rc)
goto fail_cleanup_group;
/* Get channel implementation id */
rc = mpxy_rpmi_get_attribute(rmb, RPMI_CHANNEL_ATTR_IMPL_ID,
&impl_id);
if (rc)
goto fail_cleanup_group;
/* Get channel implementation version */
rc = mpxy_rpmi_get_attribute(rmb, RPMI_CHANNEL_ATTR_IMPL_VERSION,
&impl_ver);
if (rc)
goto fail_cleanup_group;
/* Setup MPXY RPMI channel */
/* Channel ID*/
rmb->channel.channel_id = mpxy_channel_id;
/* Set the owner domain */
rmb->channel.owner_domain = dom;
/* Callback for read RPMI attributes */
rmb->channel.read_attributes = mpxy_read_attributes;
/* Callback for write RPMI attributes */
rmb->channel.write_attributes = mpxy_write_attributes;
/* Callback for sending RPMI message */
rmb->channel.send_message_with_response = mpxy_send_message_withresp;
rmb->channel.send_message_without_response = mpxy_send_message_withoutresp;
/* RPMI Message Protocol ID */
rmb->channel.attrs.msg_proto_id = SBI_MPXY_MSGPROTO_RPMI_ID;
/* RPMI Message Protocol Version */
rmb->channel.attrs.msg_proto_version = pro_ver;
/*
* RPMI supported max message data length(bytes), same for
* all service groups
*/
rmb->channel.attrs.msg_data_maxlen = max_data_len;
/*
* RPMI message send timeout(milliseconds)
* same for all service groups
*/
rmb->channel.attrs.msg_send_timeout = tx_tout;
rmb->channel.attrs.msg_completion_timeout = tx_tout + rx_tout;
/* RPMI service group attributes */
rmb->msgprot_attrs.servicegrp_id = data->servicegrp_id;
rmb->msgprot_attrs.servicegrp_ver = servicegrp_ver;
rmb->msgprot_attrs.impl_id = impl_id;
rmb->msgprot_attrs.impl_ver = impl_ver;
/* Register RPMI service group */
rc = sbi_mpxy_register_channel(&rmb->channel);
if (rc)
goto fail_cleanup_group;
return SBI_OK;
fail_cleanup_group:
if (data->cleanup_group)
data->cleanup_group(rmb->group_context);
fail_free_client:
sbi_free(rmb);
return rc;
}
struct __mpxy_rpmi_defer_init_priv {
const struct mpxy_rpmi_data *data;
struct mbox_chan *chan;
u32 mpxy_channel_id;
const char *dom_name;
};
static int __mpxy_rpmi_defer_notif(struct sbi_domain *dom,
enum sbi_domain_notify_event event,
void *priv)
{
struct __mpxy_rpmi_defer_init_priv *ipriv = priv;
int rc = 0;
/* Do nothing if domain name does not match */
if (sbi_strcmp(dom->name, ipriv->dom_name))
return 0;
/* Unregister notifier */
rc = sbi_domain_unregister_notifier(__mpxy_rpmi_defer_notif,
SBI_DOMAIN_NOTIFY_EVENT_REGISTER, ipriv);
if (rc)
goto done;
/* Create MPXY RPMI instance */
rc = __mpxy_rpmi_init(ipriv->data, ipriv->chan, ipriv->mpxy_channel_id, dom);
done:
sbi_free(ipriv);
return rc;
}
static int __mpxy_rpmi_defer_init(const struct mpxy_rpmi_data *data,
struct mbox_chan *chan, u32 mpxy_channel_id,
const char *dom_name)
{
struct __mpxy_rpmi_defer_init_priv *ipriv;
int rc;
if (!data || !dom_name)
return SBI_EINVAL;
/* Allocate defer init private data */
ipriv = sbi_zalloc(sizeof(*ipriv));
if (!ipriv)
return SBI_ENOMEM;
ipriv->data = data;
ipriv->chan = chan;
ipriv->mpxy_channel_id = mpxy_channel_id;
ipriv->dom_name = dom_name;
/* Register notifier */
rc = sbi_domain_register_notifier(__mpxy_rpmi_defer_notif,
SBI_DOMAIN_NOTIFY_EVENT_REGISTER, ipriv);
if (rc) {
sbi_free(ipriv);
return rc;
}
return 0;
}
int mpxy_rpmi_no_mbox_init(const struct mpxy_rpmi_data *data, u32 mpxy_channel_id,
const char *dom_name)
{
struct sbi_domain *dom;
/* Direct/Deferred creation of MPXY RPMI instance with no mailbox channel */
dom = sbi_domain_find_by_name(dom_name);
if (dom)
return __mpxy_rpmi_init(data, NULL, mpxy_channel_id, dom);
else
return __mpxy_rpmi_defer_init(data, NULL, mpxy_channel_id, dom_name);
}
int fdt_mpxy_rpmi_init(const void *fdt, int nodeoff, const struct fdt_match *match)
{
const struct mpxy_rpmi_data *data = match->data;
struct mbox_chan *chan = NULL;
struct sbi_domain *dom;
const char *dom_name;
const fdt32_t *val;
int rc, noff, len;
u32 channel_id;
/* Request mailbox channel when available */
val = fdt_getprop(fdt, nodeoff, "mboxes", &len);
if (val) {
/*
* If channel request failed then other end does not support
* service group so do nothing.
*/
rc = fdt_mailbox_request_chan(fdt, nodeoff, 0, &chan);
if (rc)
return SBI_ENODEV;
/* Match channel service group id */
if (data->servicegrp_id != chan->chan_args[0]) {
rc = SBI_EINVAL;
goto fail_free_chan;
}
}
/*
* The "riscv,sbi-mpxy-channel-id" DT property is mandatory
* for MPXY RPMI drivers so if this is not present then try
* other drivers.
*/
val = fdt_getprop(fdt, nodeoff, "riscv,sbi-mpxy-channel-id", &len);
if (len > 0 && val) {
channel_id = fdt32_to_cpu(*val);
} else {
rc = SBI_ENODEV;
goto fail_free_chan;
}
/*
* The "riscv,domain" DT property is optional for MPXY RPMI
* for MPXY RPMI drivers so if this is not present then assume
* root domain.
*/
val = fdt_getprop(fdt, nodeoff, "riscv,domain", &len);
if (len > 0 && val) {
noff = fdt_node_offset_by_phandle(fdt, fdt32_to_cpu(*val));
if (noff < 0) {
rc = noff;
goto fail_free_chan;
}
dom_name = fdt_get_name(fdt, noff, NULL);
} else {
dom_name = "root";
}
/*
* Direct/Deferred creation of MPXY RPMI instance with optional
* mailbox channel discovered from DT
*/
dom = sbi_domain_find_by_name(dom_name);
if (dom)
rc = __mpxy_rpmi_init(data, chan, channel_id, dom);
else
rc = __mpxy_rpmi_defer_init(data, chan, channel_id, dom_name);
if (rc)
goto fail_free_chan;
return SBI_OK;
fail_free_chan:
if (chan)
mbox_controller_free_chan(chan);
return rc;
}