From: Marouene Boubakri marouene.boubakri@oss.nxp.com
An SBI MPXY message send is not queued in a hardware mailbox: it is an ecall executed on the calling hart with the calling hart's shared memory which returns once the SBI implementation has processed the message. For most RPMI service groups that means forwarding the message to a platform microcontroller, which takes a bounded time. Some message protocols are instead processed on the calling hart itself, for example when the SBI implementation forwards the message to another supervisor domain and switches the hart to it until it responds (this is the model of the TEE service group of RPMI v2.0, where TEE_CALL runs the target TEE on the hart of the caller). Such processing is unbounded and depends on interrupts reaching the other domain so that it can yield.
Sending such messages through mbox_send_message() is not an option: the mailbox core calls the controller send_data() callback from msg_submit() with the channel spinlock held and interrupts disabled. Every hart would then serialize on a single spinlock, spinning with interrupts disabled for the whole duration of a message processed on another hart, while the calling hart would run the other domain with the channel lock held.
Add riscv_sbi_mpxy_mbox_call() which performs the RPMI transfer directly in the calling context, bypassing the mailbox core queue and channel lock. The channel must still be requested through the mailbox core so that its ownership is tracked. Local interrupts are disabled around the ecall since the per-hart shared memory is also used from hard interrupt context by mbox_send_message() users such as the RPMI system MSI irqchip; calls from different harts proceed in parallel because each hart has its own shared memory.
Signed-off-by: Marouene Boubakri marouene.boubakri@oss.nxp.com --- MAINTAINERS | 1 + drivers/mailbox/riscv-sbi-mpxy-mbox.c | 60 +++++++++++++++++++++ include/linux/mailbox/riscv-sbi-mpxy-mbox.h | 23 ++++++++ 3 files changed, 84 insertions(+) create mode 100644 include/linux/mailbox/riscv-sbi-mpxy-mbox.h
diff --git a/MAINTAINERS b/MAINTAINERS index c392ded53..44860f991 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -23581,6 +23581,7 @@ F: drivers/clk/clk-rpmi.c F: drivers/irqchip/irq-riscv-rpmi-sysmsi.c F: drivers/mailbox/riscv-sbi-mpxy-mbox.c F: include/linux/mailbox/riscv-rpmi-message.h +F: include/linux/mailbox/riscv-sbi-mpxy-mbox.h
RISC-V SPACEMIT SoC Support M: Yixun Lan dlan@kernel.org diff --git a/drivers/mailbox/riscv-sbi-mpxy-mbox.c b/drivers/mailbox/riscv-sbi-mpxy-mbox.c index ea69c6b6b..2c80e6fd1 100644 --- a/drivers/mailbox/riscv-sbi-mpxy-mbox.c +++ b/drivers/mailbox/riscv-sbi-mpxy-mbox.c @@ -12,6 +12,7 @@ #include <linux/irqchip/riscv-imsic.h> #include <linux/mailbox_controller.h> #include <linux/mailbox/riscv-rpmi-message.h> +#include <linux/mailbox/riscv-sbi-mpxy-mbox.h> #include <linux/minmax.h> #include <linux/mm.h> #include <linux/module.h> @@ -719,6 +720,65 @@ static const struct mbox_chan_ops mpxy_mbox_ops = { .shutdown = mpxy_mbox_shutdown, };
+/** + * riscv_sbi_mpxy_mbox_call() - Send an RPMI message directly on an MPXY channel + * @chan: SBI MPXY mailbox channel owned by the caller + * @msg: RPMI message of type RPMI_MBOX_MSG_TYPE_SEND_WITH_RESPONSE or + * RPMI_MBOX_MSG_TYPE_SEND_WITHOUT_RESPONSE + * + * An SBI MPXY message send is not queued anywhere: it is an ecall executed + * on the calling hart, using the calling hart's shared memory, which only + * returns once the SBI implementation has processed the message. For some + * message protocols that processing is unbounded because it runs on the + * calling hart itself, for example when the SBI implementation forwards + * the message to another supervisor domain and switches the hart to it + * until it responds (the RPMI TEE service group's TEE_CALL does this). + * + * Such messages must not go through mbox_send_message(): the mailbox core + * invokes the controller send_data() callback with the channel spinlock + * held and interrupts disabled, which would serialize all harts on a single + * lock and keep interrupts disabled on the calling hart for the whole + * duration of the call. + * + * This helper bypasses the mailbox core queue and channel lock and performs + * the transfer directly in the calling context. Only local interrupts are + * disabled around the ecall, because the per-hart shared memory can be used + * from hard interrupt context through mbox_send_message() by other clients. + * Calls from different harts run concurrently since each hart has its own + * shared memory. + * + * The caller must own @chan through mbox_request_channel() (or a variant of + * it) so that no other client can use the channel, and must not use + * mbox_send_message() on it concurrently. + * + * Return: 0 on success or a negative error code. + */ +int riscv_sbi_mpxy_mbox_call(struct mbox_chan *chan, + struct rpmi_mbox_message *msg) +{ + struct mpxy_mbox_channel *mchan; + unsigned long flags; + + if (!chan || !chan->cl || !chan->mbox || !msg) + return -EINVAL; + if (chan->mbox->ops != &mpxy_mbox_ops) + return -EINVAL; + if (msg->type != RPMI_MBOX_MSG_TYPE_SEND_WITH_RESPONSE && + msg->type != RPMI_MBOX_MSG_TYPE_SEND_WITHOUT_RESPONSE) + return -EINVAL; + + mchan = chan->con_priv; + if (mchan->attrs.msg_proto_id != SBI_MPXY_MSGPROTO_RPMI_ID) + return -EOPNOTSUPP; + + local_irq_save(flags); + mpxy_mbox_send_rpmi_data(mchan, msg); + local_irq_restore(flags); + + return msg->error; +} +EXPORT_SYMBOL_GPL(riscv_sbi_mpxy_mbox_call); + /* ====== MPXY platform driver ===== */
static void mpxy_mbox_msi_write(struct msi_desc *desc, struct msi_msg *msg) diff --git a/include/linux/mailbox/riscv-sbi-mpxy-mbox.h b/include/linux/mailbox/riscv-sbi-mpxy-mbox.h new file mode 100644 index 000000000..4fb7b04cd --- /dev/null +++ b/include/linux/mailbox/riscv-sbi-mpxy-mbox.h @@ -0,0 +1,23 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* Copyright 2026 NXP */ + +#ifndef _LINUX_RISCV_SBI_MPXY_MBOX_H_ +#define _LINUX_RISCV_SBI_MPXY_MBOX_H_ + +#include <linux/errno.h> + +struct mbox_chan; +struct rpmi_mbox_message; + +#if IS_ENABLED(CONFIG_RISCV_SBI_MPXY_MBOX) +int riscv_sbi_mpxy_mbox_call(struct mbox_chan *chan, + struct rpmi_mbox_message *msg); +#else +static inline int riscv_sbi_mpxy_mbox_call(struct mbox_chan *chan, + struct rpmi_mbox_message *msg) +{ + return -ENODEV; +} +#endif + +#endif /* _LINUX_RISCV_SBI_MPXY_MBOX_H_ */