From 37bde95c8c3838dd775de04aa1724cd2b6ef1bb3 Mon Sep 17 00:00:00 2001 From: Oza Pawandeep Date: Wed, 18 Nov 2026 13:55:45 -0800 Subject: [PATCH] sbi_utils: mpxy:: Add MPXY RPMI bridge MM driver Add the MPXY MM source driver for forwarding RPMI Management Mode requests through the MPXY request-forwarding bridge. The driver: - Registers the `opensbi,rpmi-mpxy-reqfwd-mm` FDT-compatible source. - Defines MM service metadata for get attributes and communicate services. - Builds request-forwarding responses for MM GET_ATTRIBUTES and COMMUNICATE requests. - Handles MM response completion and copies response payloads back to the source buffer. - Extracts and stores the MM shared-memory address and size from the GET_ATTRIBUTES response. - Registers the MM source with the Management Mode RPMI service group. Reviewed-by: Anup Patel Signed-off-by: Oza Pawandeep Link: https://lore.kernel.org/r/20261118215549.2499040-5-pawandeep.oza@oss.qualcomm.com Signed-off-by: Anup Patel --- lib/utils/mpxy/Kconfig | 7 + lib/utils/mpxy/fdt_mpxy_rpmi_bridge_mm.c | 207 +++++++++++++++++++++++ lib/utils/mpxy/objects.mk | 2 + platform/generic/configs/defconfig | 1 + 4 files changed, 217 insertions(+) create mode 100644 lib/utils/mpxy/fdt_mpxy_rpmi_bridge_mm.c diff --git a/lib/utils/mpxy/Kconfig b/lib/utils/mpxy/Kconfig index bbf85be6..c4041358 100644 --- a/lib/utils/mpxy/Kconfig +++ b/lib/utils/mpxy/Kconfig @@ -46,6 +46,13 @@ config FDT_MPXY_RPMI_BRIDGE bool "MPXY bridge driver for interdomain communication" default n +if FDT_MPXY_RPMI_BRIDGE + +config FDT_MPXY_RPMI_BRIDGE_MM + bool "MPXY rpmi bridge mm driver for interdomain communication" + default n + +endif endif diff --git a/lib/utils/mpxy/fdt_mpxy_rpmi_bridge_mm.c b/lib/utils/mpxy/fdt_mpxy_rpmi_bridge_mm.c new file mode 100644 index 00000000..55b31872 --- /dev/null +++ b/lib/utils/mpxy/fdt_mpxy_rpmi_bridge_mm.c @@ -0,0 +1,207 @@ +/* + * SPDX-License-Identifier: BSD-2-Clause + * + * Copyright (c) 2026 Qualcomm, Inc + * + * Authors: + * Pawandeep Oza + */ + +#include +#include +#include +#include + +static struct mpxy_rpmi_service_data mm_srvcdata[] = { + [0] = { + .id = RPMI_MM_SRV_ENABLE_NOTIFICATION, + .min_tx_len = sizeof(struct rpmi_enable_notification_req), + .max_tx_len = sizeof(struct rpmi_enable_notification_req), + .min_rx_len = sizeof(struct rpmi_enable_notification_resp), + .max_rx_len = sizeof(struct rpmi_enable_notification_resp), + }, + [1] = { + .id = RPMI_MM_SRV_GET_ATTRIBUTES, + .min_tx_len = 0, + .max_tx_len = 0, + .min_rx_len = sizeof(struct rpmi_mm_get_attributes_rsp), + .max_rx_len = sizeof(struct rpmi_mm_get_attributes_rsp), + }, + [2] = { + .id = RPMI_MM_SRV_COMMUNICATE, + .min_tx_len = sizeof(struct rpmi_mm_communicate_req), + .max_tx_len = sizeof(struct rpmi_mm_communicate_req), + .min_rx_len = sizeof(struct rpmi_mm_communicate_rsp), + .max_rx_len = sizeof(struct rpmi_mm_communicate_rsp), + }, +}; + +static struct rpmi_mm_shmem_info { + u64 addr; + u32 size; +} mm_shmem; + +static int mpxy_rpmi_build_reqfwd_resp(struct mpxy_bridge_src_ctx *src, + struct mpxy_bridge_dst_ctx *dst, + const u8 *data, u32 data_len) +{ + struct rpmi_request_forward_resp *resp; + u32 hdr_len = sizeof(struct rpmi_message_header); + u32 avail; + u32 offset; + u32 returned; + int ret = SBI_OK; + + do { + resp = (struct rpmi_request_forward_resp *)dst->respbuf; + offset = dst->start_index; + avail = dst->resp_bufsize - sizeof(*resp); + + if (offset > data_len) { + ret = SBI_EINVAL; + break; + } + + if (offset == 0) { + if (avail <= hdr_len) { + ret = SBI_EINVAL; + break; + } + avail -= hdr_len; + } + + returned = data_len - offset; + if (returned > avail) + returned = avail; + + resp->status = RPMI_SUCCESS; + + if (offset == 0) { + sbi_memcpy(resp->data, (u8 *)&src->header, hdr_len); + sbi_memcpy(resp->data + hdr_len, data, returned); + resp->returned = hdr_len + returned; + resp->remaining = data_len - returned; + *dst->resp_len_ptr = sizeof(*resp) + hdr_len + returned; + } else { + sbi_memcpy(resp->data, data + offset, returned); + resp->returned = returned; + resp->remaining = data_len - offset - returned; + *dst->resp_len_ptr = sizeof(*resp) + returned; + } + } while (0); + + if (ret) { + resp->status = RPMI_ERR_INVALID_PARAM; + resp->returned = 0; + resp->remaining = 0; + } + + return ret; +} + +static int mpxy_rpmi_mm_xfer(struct mpxy_bridge_src_ctx *src, + struct mpxy_bridge_dst_ctx *dst) +{ + if (!src || !src->msgbuf || !dst || !dst->respbuf || !dst->resp_len_ptr) + return SBI_EINVAL; + + switch (src->header.service_id) { + case RPMI_MM_SRV_GET_ATTRIBUTES: + return mpxy_rpmi_build_reqfwd_resp(src, dst, NULL, + mm_srvcdata[RPMI_MM_SRV_GET_ATTRIBUTES - 1].min_tx_len); + + case RPMI_MM_SRV_COMMUNICATE: + return mpxy_rpmi_build_reqfwd_resp(src, dst, (const u8 *)src->msgbuf, + mm_srvcdata[RPMI_MM_SRV_COMMUNICATE - 1].min_tx_len); + + default: + return SBI_ENOTSUPP; + } +} + +static int mpxy_rpmi_get_payload(void *msgbuf, u32 msg_len, + const u8 **payload, u32 *payload_len) +{ + struct rpmi_message_header *hdr; + u32 len; + + hdr = (struct rpmi_message_header *)msgbuf; + len = (u32)le16_to_cpu(hdr->datalen); + + *payload = (const u8 *)msgbuf + sizeof(struct rpmi_message_header); + *payload_len = len; + + return SBI_OK; +} + +static int mpxy_rpmi_copy_payload(struct mpxy_bridge_src_ctx *src, + const u8 *payload, u32 payload_len) +{ + sbi_memcpy((u8 *)src->respbuf, payload, payload_len); + src->resp_length = payload_len; + + return SBI_OK; +} + +static int mpxy_rpmi_mm_complete(struct mpxy_bridge_src_ctx *src, + void *msgbuf, u32 msg_len) +{ + const u8 *payload; + u32 payload_len; + int ret; + + ret = mpxy_rpmi_get_payload(msgbuf, msg_len, + &payload, &payload_len); + if (ret) + return ret; + + switch (src->header.service_id) { + case RPMI_MM_SRV_GET_ATTRIBUTES: + struct rpmi_mm_get_attributes_rsp *attr_rsp; + attr_rsp = (struct rpmi_mm_get_attributes_rsp *)payload; + + mm_shmem.addr = ((u64)le32_to_cpu(attr_rsp->mma.shmem_addr_hi) << 32) | + (u64)le32_to_cpu(attr_rsp->mma.shmem_addr_lo); + mm_shmem.size = le32_to_cpu(attr_rsp->mma.shmem_size); + attr_rsp->status = RPMI_SUCCESS; + break; + + case RPMI_MM_SRV_COMMUNICATE: + break; + + default: + return SBI_ENOTSUPP; + } + + ret = mpxy_rpmi_copy_payload(src, payload, payload_len); + if (ret) + return ret; + + return SBI_OK; +} + +static const struct mpxy_bridge_source_ops mm_ops = { + .xfer = mpxy_rpmi_mm_xfer, + .complete = mpxy_rpmi_mm_complete, +}; + +static const struct fdt_match mm_match[] = { + { + .compatible = "opensbi,rpmi-mpxy-reqfwd-mm", + }, + { } +}; + +static int mpxy_rpmi_mm_probe(const void *fdt, int nodeoff, + const struct fdt_match *match) +{ + (void)match; + + return mpxy_bridge_register_source(fdt, nodeoff, &mm_ops, mm_srvcdata, + array_size(mm_srvcdata), RPMI_SRVGRP_MANAGEMENT_MODE); +} + +const struct mpxy_bridge_source_driver fdt_mpxy_rpmi_bridge_mm = { + .match_table = mm_match, + .probe = mpxy_rpmi_mm_probe, +}; diff --git a/lib/utils/mpxy/objects.mk b/lib/utils/mpxy/objects.mk index 488116da..6fc68099 100644 --- a/lib/utils/mpxy/objects.mk +++ b/lib/utils/mpxy/objects.mk @@ -37,3 +37,5 @@ carray-fdt_mpxy_drivers-$(CONFIG_FDT_MPXY_RPMI_BRIDGE) += fdt_mpxy_rpmi_bridge libsbiutils-objs-$(CONFIG_FDT_MPXY_RPMI_BRIDGE) += mpxy/fdt_mpxy_rpmi_bridge.o libsbiutils-objs-$(CONFIG_FDT_MPXY_RPMI_BRIDGE) += mpxy/fdt_mpxy_rpmi_bridge_sources.carray.o +carray-fdt_mpxy_rpmi_bridge_sources-$(CONFIG_FDT_MPXY_RPMI_BRIDGE_MM) += fdt_mpxy_rpmi_bridge_mm +libsbiutils-objs-$(CONFIG_FDT_MPXY_RPMI_BRIDGE_MM) += mpxy/fdt_mpxy_rpmi_bridge_mm.o \ No newline at end of file diff --git a/platform/generic/configs/defconfig b/platform/generic/configs/defconfig index 8b42446f..750ad5a9 100644 --- a/platform/generic/configs/defconfig +++ b/platform/generic/configs/defconfig @@ -88,4 +88,5 @@ CONFIG_FDT_MPXY_RPMI_SYSMSI=y CONFIG_FDT_MPXY_RPMI_MM=y CONFIG_FDT_MPXY_RPMI_LOGGING=y CONFIG_FDT_MPXY_RPMI_BRIDGE=y +CONFIG_FDT_MPXY_RPMI_BRIDGE_MM=y