Requesting node to firmware can be used by multiple drivers. Move this API to firmware driver from power driver so others can use the same interface.

Signed-off-by: Tanmay Shah tanmay.shah@amd.com --- drivers/firmware/firmware-zynqmp.c | 7 +++++++ drivers/power/domain/zynqmp-power-domain.c | 7 ------- include/zynqmp_firmware.h | 14 ++++++++------ 3 files changed, 15 insertions(+), 13 deletions(-)

diff --git a/drivers/firmware/firmware-zynqmp.c b/drivers/firmware/firmware-zynqmp.c index ab4c4f1a69..0897992405 100644 --- a/drivers/firmware/firmware-zynqmp.c +++ b/drivers/firmware/firmware-zynqmp.c @@ -195,6 +195,13 @@ int zynqmp_pm_set_sd_config(u32 node, enum pm_sd_config_type config, u32 value) return ret; }

+int zynqmp_pm_request_node(const u32 node, const u32 capabilities, + const u32 qos, const enum zynqmp_pm_request_ack ack) +{ + return xilinx_pm_request(PM_REQUEST_NODE, node, capabilities, + qos, ack, NULL); +} + int zynqmp_pm_is_function_supported(const u32 api_id, const u32 id) { int ret; diff --git a/drivers/power/domain/zynqmp-power-domain.c b/drivers/power/domain/zynqmp-power-domain.c index 5ee9e020fb..d385dc5530 100644 --- a/drivers/power/domain/zynqmp-power-domain.c +++ b/drivers/power/domain/zynqmp-power-domain.c @@ -14,13 +14,6 @@

#include <zynqmp_firmware.h>

-static int zynqmp_pm_request_node(const u32 node, const u32 capabilities, - const u32 qos, const enum zynqmp_pm_request_ack ack) -{ - return xilinx_pm_request(PM_REQUEST_NODE, node, capabilities, - qos, ack, NULL); -} - static int zynqmp_power_domain_request(struct power_domain *power_domain) { int ret = 0; diff --git a/include/zynqmp_firmware.h b/include/zynqmp_firmware.h index 18a87d2749..ce086f48d4 100644 --- a/include/zynqmp_firmware.h +++ b/include/zynqmp_firmware.h @@ -444,12 +444,20 @@ enum pm_gem_config_type { */ #define PAYLOAD_ARG_CNT 5U

+enum zynqmp_pm_request_ack { + ZYNQMP_PM_REQUEST_ACK_NO = 1, + ZYNQMP_PM_REQUEST_ACK_BLOCKING = 2, + ZYNQMP_PM_REQUEST_ACK_NON_BLOCKING = 3, +}; + unsigned int zynqmp_firmware_version(void); int zynqmp_pmufw_node(u32 id); int zynqmp_pmufw_config_close(void); int zynqmp_pmufw_load_config_object(const void *cfg_obj, size_t size); int xilinx_pm_request(u32 api_id, u32 arg0, u32 arg1, u32 arg2, u32 arg3, u32 *ret_payload); +int zynqmp_pm_request_node(const u32 node, const u32 capabilities, + const u32 qos, enum zynqmp_pm_request_ack ack); int zynqmp_pm_set_sd_config(u32 node, enum pm_sd_config_type config, u32 value); int zynqmp_pm_set_gem_config(u32 node, enum pm_gem_config_type config, u32 value); @@ -474,12 +482,6 @@ int zynqmp_mmio_write(const u32 address, const u32 mask, const u32 value); #define PM_CONFIG_IPI_PSU_CORTEXR5_0_MASK 0x00000100 #define PM_CONFIG_IPI_PSU_CORTEXR5_1_MASK 0x00000200

-enum zynqmp_pm_request_ack { - ZYNQMP_PM_REQUEST_ACK_NO = 1, - ZYNQMP_PM_REQUEST_ACK_BLOCKING = 2, - ZYNQMP_PM_REQUEST_ACK_NON_BLOCKING = 3, -}; - /* Node capabilities */ #define ZYNQMP_PM_CAPABILITY_ACCESS 0x1U #define ZYNQMP_PM_CAPABILITY_CONTEXT 0x2U

RPMsg framework is used to communicate to remote processor using rpmsg protocol.

This framework is ported from the Linux kernel directory: drivers/rpmsg/ kernel version: 6.4-rc2 (d848a4819d85)

Signed-off-by: Tanmay Shah tanmay.shah@amd.com --- MAINTAINERS | 7 + arch/sandbox/dts/test.dts | 8 + drivers/Kconfig | 2 + drivers/Makefile | 1 + drivers/rpmsg/Kconfig | 31 +++ drivers/rpmsg/Makefile | 10 + drivers/rpmsg/rpmsg-uclass.c | 156 ++++++++++++ drivers/rpmsg/rpmsg_internal.h | 52 ++++ drivers/rpmsg/sandbox_test_rpmsg.c | 88 +++++++ drivers/rpmsg/virtio_rpmsg_bus.c | 384 +++++++++++++++++++++++++++++ drivers/virtio/virtio-uclass.c | 1 + include/dm/uclass-id.h | 1 + include/rpmsg.h | 140 +++++++++++ include/rproc_virtio.h | 8 +- include/virtio.h | 4 +- include/virtio_ring.h | 15 ++ test/dm/Makefile | 1 + test/dm/rpmsg.c | 41 +++ 18 files changed, 947 insertions(+), 3 deletions(-) create mode 100644 drivers/rpmsg/Kconfig create mode 100644 drivers/rpmsg/Makefile create mode 100644 drivers/rpmsg/rpmsg-uclass.c create mode 100644 drivers/rpmsg/rpmsg_internal.h create mode 100644 drivers/rpmsg/sandbox_test_rpmsg.c create mode 100644 drivers/rpmsg/virtio_rpmsg_bus.c create mode 100644 include/rpmsg.h create mode 100644 test/dm/rpmsg.c

diff --git a/MAINTAINERS b/MAINTAINERS index c4a32a0956..876a7fdbdf 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -1365,6 +1365,13 @@ F: drivers/usb/gadget/f_rockusb.c F: cmd/rockusb.c F: doc/README.rockusb

+RPMSG +M: Tanmay Shah tanmay.shah@amd.com +S: Maintained +F: drivers/rpmsg/* +F: include/rpmsg.h +F: test/dm/rpmsg.c + SANDBOX M: Simon Glass sjg@chromium.org S: Maintained diff --git a/arch/sandbox/dts/test.dts b/arch/sandbox/dts/test.dts index b5509eee8c..fca1a591fb 100644 --- a/arch/sandbox/dts/test.dts +++ b/arch/sandbox/dts/test.dts @@ -1247,6 +1247,14 @@ compatible = "sandbox,sandbox-rng"; };

+ rpmsg_1: rpmsg@1 { + compatible = "sandbox,test-rpmsg"; + }; + + rpmsg_2: rpmsg@2 { + compatible = "sandbox,test-rpmsg"; + }; + rproc_1: rproc@1 { compatible = "sandbox,test-processor"; remoteproc-name = "remoteproc-test-dev1"; diff --git a/drivers/Kconfig b/drivers/Kconfig index a25f6ae02f..69700f1f83 100644 --- a/drivers/Kconfig +++ b/drivers/Kconfig @@ -112,6 +112,8 @@ source "drivers/reset/Kconfig"

source "drivers/rng/Kconfig"

+source "drivers/rpmsg/Kconfig" + source "drivers/rtc/Kconfig"

source "drivers/scsi/Kconfig" diff --git a/drivers/Makefile b/drivers/Makefile index 3bc6d279d7..68e8d8b065 100644 --- a/drivers/Makefile +++ b/drivers/Makefile @@ -109,6 +109,7 @@ obj-y += mfd/ obj-y += mtd/ obj-y += pwm/ obj-y += reset/ +obj-y += rpmsg/ obj-y += input/ obj-y += iommu/ # SOC specific infrastructure drivers. diff --git a/drivers/rpmsg/Kconfig b/drivers/rpmsg/Kconfig new file mode 100644 index 0000000000..4efb8dfcd7 --- /dev/null +++ b/drivers/rpmsg/Kconfig @@ -0,0 +1,31 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# Copyright (C) 2023, Advanced Micro devices, Inc. + +menu "RPMsg drivers" + +# RPMsg gets selected by drivers as needed +# All users should depend on DM +config RPMSG + bool + depends on DM + +config VIRTIO_RPMSG_BUS + bool "virtio rpmsg bus" + depends on DM + select RPMSG + select REMOTEPROC_VIRTIO + help + Say 'y' here to enable virtio based RPMsg. RPMsg allows + U-Boot drivers to communicate with remote processors. + +config RPMSG_SANDBOX + bool "RPMsg driver for sandbox platform" + depends on DM + select RPMSG + depends on SANDBOX + help + Say 'y' here to add sandbox driver for RPMsg framework used + for dummy communication with remote processor on sandbox platform + +endmenu diff --git a/drivers/rpmsg/Makefile b/drivers/rpmsg/Makefile new file mode 100644 index 0000000000..21611725ea --- /dev/null +++ b/drivers/rpmsg/Makefile @@ -0,0 +1,10 @@ +# SPDX-License-Identifier: GPL-2.0 +# +# Copyright (C) 2023, Advanced Micro Devices, Inc. + +obj-$(CONFIG_RPMSG) += rpmsg-uclass.o + +obj-$(CONFIG_RPMSG_SANDBOX) += sandbox_test_rpmsg.o + +# virtio driver for rpmsg +obj-$(CONFIG_VIRTIO_RPMSG_BUS) += virtio_rpmsg_bus.o diff --git a/drivers/rpmsg/rpmsg-uclass.c b/drivers/rpmsg/rpmsg-uclass.c new file mode 100644 index 0000000000..3e749a5827 --- /dev/null +++ b/drivers/rpmsg/rpmsg-uclass.c @@ -0,0 +1,156 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * remote processor messaging bus + * + * Copyright (C) 2023, Advanced Micro Devices, Inc. + */ + +#include <common.h> +#include <dm.h> +#include <errno.h> +#include <log.h> +#include <malloc.h> +#include <rpmsg.h> +#include <virtio.h> +#include <dm/device_compat.h> +#include <dm/device-internal.h> +#include <dm/lists.h> +#include <dm/uclass.h> +#include <dm/uclass-internal.h> + +#include "rpmsg_internal.h" + +int rpmsg_init(int core_id) +{ + struct udevice *udev = NULL; + int ret; + + ret = uclass_find_device_by_seq(UCLASS_RPMSG, core_id, &udev); + if (ret) { + debug("can't find rpmsg dev for core_id %d\n", core_id); + return ret; + } + + ret = device_probe(udev); + if (ret) + debug("failed to probe rpmsg dev, ret = %d\n", ret); + + return ret; +} + +static int rpmsg_find_device(int core_id, struct udevice **rpdev) +{ + int core_count; + + core_count = uclass_id_count(UCLASS_RPMSG); + if (core_id >= core_count) { + debug("invalid core id = %d\n", core_id); + return -EINVAL; + } + + return uclass_find_device(UCLASS_RPMSG, core_id, rpdev); +} + +/** + * rpmsg_send() - send a message across to the remote processor + * @core_id: remote processor core id + * @data: payload of message + * @len: length of payload + * + * This function sends @data of length @len on the @core_id endpoint. + * The message will be sent to the remote processor which the @core_id + * belongs to, using @ept's address and its associated rpmsg + * device destination addresses. + * In case there are no TX buffers available, the function will fail + * immediately + * + * Return: 0 on success and an appropriate error value on failure. + */ +int rpmsg_send(int core_id, void *data, int len) +{ + struct udevice *rpdev = NULL; + const struct rpmsg_device_ops *ops; + int ret; + + ret = rpmsg_find_device(core_id, &rpdev); + if (ret) { + debug("no rpmsg device for core = %d, ret = %d\n", core_id, ret); + return ret; + } + if (!rpdev) + return -ENODEV; + + ops = (const struct rpmsg_device_ops *)device_get_ops(rpdev); + if (!ops) { + debug("send op not registered for device %s\n", rpdev->name); + return -EINVAL; + } + + return ops->send(rpdev, data, len); +} + +int rpmsg_recv(int core_id, rpmsg_rx_cb_t cb) +{ + struct udevice *rpdev = NULL; + const struct rpmsg_device_ops *ops; + int ret; + + ret = rpmsg_find_device(core_id, &rpdev); + if (ret) { + debug("no rpmsg device for core = %d, ret = %d\n", core_id, ret); + return ret; + } + if (!rpdev) + return -ENODEV; + + ops = (const struct rpmsg_device_ops *)device_get_ops(rpdev); + if (!ops) { + debug("recv op not registered for device %s\n", rpdev->name); + return -EINVAL; + } + + return ops->recv(rpdev, cb); +} + +void rpmsg_debug_data(int core_id, int vq_id) +{ + struct udevice *rpdev = NULL; + const struct rpmsg_device_ops *ops; + int ret; + + if (vq_id > 1) + debug("vq_id %d not supported\n", vq_id); + + ret = rpmsg_find_device(core_id, &rpdev); + if (ret || !rpdev) { + debug("no rpmsg device for core = %d, ret = %d\n", core_id, ret); + return; + } + + ops = (const struct rpmsg_device_ops *)device_get_ops(rpdev); + if (!ops || !ops->debug_data) { + debug("recv op not registered for device %s\n", rpdev->name); + return; + } + + ops->debug_data(rpdev, vq_id); +} + +int rpmsg_uclass_init(struct uclass *class) +{ + int ret; + + /* make sure virtio framework is initialized */ + ret = virtio_init(); + if (ret) + debug("virtio init failed, %d\n", ret); + + return ret; +} + +UCLASS_DRIVER(rpmsg_bus) = { + .name = "rpmsg_bus", + .id = UCLASS_RPMSG, + .init = rpmsg_uclass_init, + .flags = DM_UC_FLAG_SEQ_ALIAS, +}; diff --git a/drivers/rpmsg/rpmsg_internal.h b/drivers/rpmsg/rpmsg_internal.h new file mode 100644 index 0000000000..4f7bf9fb90 --- /dev/null +++ b/drivers/rpmsg/rpmsg_internal.h @@ -0,0 +1,52 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * remote processor messaging bus internals + * + * Copyright (C) 2011 Texas Instruments, Inc. + * Copyright (C) 2011 Google, Inc. + * Copyright (C) 2023, Advanced Micro Devices, Inc. + * + * Ohad Ben-Cohen ohad@wizery.com + * Brian Swetland swetland@google.com + */ + +#ifndef __RPMSG_INTERNAL_H__ +#define __RPMSG_INTERNAL_H__ + +#include <rpmsg.h> +#include <virtio.h> + +/** + * struct rpmsg_hdr - common header for all rpmsg messages + * @src: source address + * @dst: destination address + * @reserved: reserved for future use + * @len: length of payload (in bytes) + * @flags: message flags + * @data: @len bytes of message payload data + * + * Every message sent(/received) on the rpmsg bus begins with this header. + */ +struct rpmsg_hdr { + __rpmsg32 src; + __rpmsg32 dst; + __rpmsg32 reserved; + __rpmsg16 len; + __rpmsg16 flags; + u8 data[]; +} __packed; + +/** + * struct rpmsg_device_ops - indirection table for the rpmsg_device operations + * @send: send data to core + * @recv: recv data to buf. data limited to buf_len bytes and buf is expected + * to have that much memory allocated + * @debug_data: calls virtqueue_dump debug utility to print vq data + */ +struct rpmsg_device_ops { + int (*send)(struct udevice *rpdev, void *data, int len); + int (*recv)(struct udevice *rpdev, rpmsg_rx_cb_t cb); + void (*debug_data)(struct udevice *rpdev, int vq_id); +}; + +#endif diff --git a/drivers/rpmsg/sandbox_test_rpmsg.c b/drivers/rpmsg/sandbox_test_rpmsg.c new file mode 100644 index 0000000000..c94254aa4e --- /dev/null +++ b/drivers/rpmsg/sandbox_test_rpmsg.c @@ -0,0 +1,88 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (C) 2023, Advanced Micro Devices, Inc. + */ +#include <common.h> +#include <dm.h> +#include <errno.h> +#include <log.h> +#include <rpmsg.h> +#include <asm/io.h> + +#include "rpmsg_internal.h" + +#define TEST_RPMSG_BUF_SIZE 512 + +struct sandbox_test_devdata { + char rpmsg_data_buf[TEST_RPMSG_BUF_SIZE]; + int msg_len; +}; + +static int sandbox_test_rpmsg_send(struct udevice *rpdev, void *msg, int len) +{ + /* ToDo: (maintainer) Implement send functionality for sandbox drv */ + struct sandbox_test_devdata *data = dev_get_priv(rpdev); + + if (len > TEST_RPMSG_BUF_SIZE) + len = TEST_RPMSG_BUF_SIZE; + + data->msg_len = len; + memcpy(data->rpmsg_data_buf, msg, len); + + return 0; +} + +static int sandbox_test_rpmsg_recv(struct udevice *rpdev, rpmsg_rx_cb_t cb) +{ + /* ToDo: (maintainer) Implement recv functionality for sandbox drv */ + struct sandbox_test_devdata *data = dev_get_priv(rpdev); + int len; + + len = data->msg_len; + + /* as of now only 1 buffer is used for testing. so third arg is 1 */ + if (cb) + cb(&data->rpmsg_data_buf, len, 1); + + return 0; +} + +static void sandbox_test_rpmsg_debug_data(struct udevice *rpdev, int vq_id) +{ + /* + * ToDo: (maintainer) Implement debug_data functionality + * for sandbox drv + */ +} + +int sandbox_test_rpmsg_probe(struct udevice *dev) +{ + /* ToDo: (maintainer) any init work */ + debug("sandbox driver probbed\n"); + + return 0; +} + +static const struct rpmsg_device_ops sandbox_test_rpmsg_ops = { + .send = sandbox_test_rpmsg_send, + .recv = sandbox_test_rpmsg_recv, + .debug_data = sandbox_test_rpmsg_debug_data, +}; + +static const struct udevice_id sandbox_ids[] = { + {.compatible = "sandbox,test-rpmsg"}, + {} +}; + +U_BOOT_DRIVER(sandbox_test_rpmsg) = { + .name = "sandbox_test_rpmsg", + .of_match = sandbox_ids, + .id = UCLASS_RPMSG, + .ops = &sandbox_test_rpmsg_ops, + .probe = sandbox_test_rpmsg_probe, + .priv_auto = sizeof(struct sandbox_test_devdata), +}; + +U_BOOT_DRVINFO(sandbox_test_rpmsg) = { + .name = "sandbox_test_rpmsg", +}; diff --git a/drivers/rpmsg/virtio_rpmsg_bus.c b/drivers/rpmsg/virtio_rpmsg_bus.c new file mode 100644 index 0000000000..a41fab177d --- /dev/null +++ b/drivers/rpmsg/virtio_rpmsg_bus.c @@ -0,0 +1,384 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (C) 2011 Texas Instruments, Inc. + * Copyright (C) 2011 Google, Inc. + * Copyright (C) 2023, Advanced Micro Devices, Inc. + * + * RPMsg virtio driver + * File proted from the Linux kernel: + * drivers/rpmsg/virtio_rpmsg_bus + */ + +#include <common.h> +#include <asm/dma-mapping.h> +#include <dm.h> +#include <dm/device_compat.h> +#include <linux/compat.h> +#include <linux/errno.h> +#include <remoteproc.h> +#include <rproc_virtio.h> +#include <rpmsg.h> +#include <virtio_types.h> +#include <virtio.h> +#include <virtio_ring.h> + +#include "rpmsg_internal.h" + +/* + * Allocate buffers of 512 bytes each for communications. The + * number of buffers will be computed from the number of buffers supported + * by the vring, upto a maximum of 512 buffers (256 in each direction). + * + * Each buffer will have 16 bytes for the msg header and 496 bytes for + * the payload. + * + * This will utilize a maximum total space of 256KB for the buffers. + * + * In future add support for user-provided buffers. + * This will allow bigger buffer size flexibility, and can also be used + * to achieve zero-copy messaging. + * + * Note that these numbers are purely a decision of this driver - user + * can change this without changing anything in the firmware of the remote + * processor. + */ +#define MAX_RPMSG_NUM_BUFS (512) +#define MAX_RPMSG_BUF_SIZE (512) + +#define RPMSG_UBOOT_ADDR (1035) + +/* + * Local addresses are dynamically allocated on-demand. + * We do not dynamically assign addresses from the low 1024 range, + * in order to reserve that address range for predefined services. + */ +#define RPMSG_RESERVED_ADDRESSES (1024) + +/** + * struct virtproc_info - virtual remote processor state + * @vdev: the virtio device + * @vqs: rx and tx virtqueues + * @rvq: rx virtqueue + * @svq: tx virtqueue + * @rbufs: kernel address of rx buffers + * @sbufs: kernel address of tx buffers + * @num_bufs: total number of buffers for rx and tx + * @buf_size: size of one rx or tx buffer + * @last_sbuf: index of last tx buffer used + * @bufs_dma: dma base addr of the buffers + * + * This structure stores the rpmsg state of a given virtio remote processor + * device (there might be several virtio proc devices for each physical + * remote processor). + */ +struct virtproc_info { + struct udevice *vdev; + + union { + struct virtqueue *vqs[2]; + struct { + struct virtqueue *rvq; + struct virtqueue *svq; + }; + }; + void *rbufs, *sbufs; + unsigned int num_bufs; + unsigned int buf_size; + int last_sbuf; + unsigned long bufs_dma; +}; + +/* The feature bitmap for virtio rpmsg */ +#define VIRTIO_RPMSG_F_NS 0 /* RP doesn't support name service */ + +/** + * rpmsg_sg_init - initialize scatterlist according to cpu address location + * @sg: scatterlist to fill + * @cpu_addr: virtual address of the buffer + * @len: buffer length + * + * An internal function filling scatterlist according to virtual address + * location (in vmalloc or in kernel). + */ +static void +rpmsg_sg_init(struct virtio_sg *sg, void *cpu_addr, unsigned int len) +{ + sg->addr = cpu_addr; + sg->length = len; +} + +void *get_tx_buf(struct virtproc_info *vrp) +{ + unsigned int len; + void *ret; + + if (!vrp->svq) { + dev_err(vrp->vdev, "send vq not available for dev\n"); + return NULL; + } + + /* + * either pick the next unused tx buffer + * (half of our buffers are used for sending messages) + */ + if (vrp->last_sbuf < vrp->num_bufs / 2) + ret = vrp->sbufs + (vrp->buf_size * vrp->last_sbuf++); + /* or recycle a used one */ + else + ret = virtqueue_get_buf(vrp->svq, &len); + + return ret; +} + +int virtio_rpmsg_bus_send(struct udevice *vdev, void *data, int len) +{ + struct virtproc_info *vrp; + struct rpmsg_hdr *msg; + struct virtio_sg sg = {0}; + struct virtio_sg *sgs[] = { &sg }; + int msg_len, err = 0; + + vrp = dev_get_priv(vdev); + + if (len > (vrp->buf_size - sizeof(struct rpmsg_hdr))) { + dev_err(vdev, "msg len %d is out of bound\n", len); + return -EMSGSIZE; + } + + msg = get_tx_buf(vrp); + if (!msg) { + dev_err(vdev, "rpmsg can't get tx buffer\n"); + return -ENOMEM; + } + + msg->len = cpu_to_rpmsg16(len); + msg->src = cpu_to_rpmsg32(RPMSG_UBOOT_ADDR); + msg->dst = cpu_to_rpmsg32(RPMSG_UBOOT_ADDR); + msg->flags = 0; + msg->reserved = 0; + memcpy(msg->data, (char *)data, len); + msg_len = len + sizeof(*msg); + rpmsg_sg_init(&sg, msg, msg_len); + + /* add messages to the remote processor's virtqueue */ + err = virtqueue_add(vrp->svq, sgs, 1, 0); + if (err) { + /* + * need to reclaim the buffer or it's lost. + * memory won't lost but rpmsg won't use it for tx. + * this will wait for buffer management overhaul. + */ + dev_err(vdev, "failed to add out buf\n"); + return err; + } + + /* tell remote processor that it has pending message to read */ + virtqueue_kick(vrp->svq); + + return 0; +} + +static int rpmsg_recv_single(struct virtproc_info *vrp, struct rpmsg_hdr *msg, + unsigned int len, int msgs_received, + rpmsg_rx_cb_t cb) +{ + struct virtio_sg sg; + struct virtio_sg *sgs[] = { &sg }; + bool little_endian = virtio_is_little_endian(vrp->vdev); + unsigned int msg_len = __rpmsg16_to_cpu(little_endian, msg->len); + int err; + + debug("From: 0x%x, To: 0x%x, Len: %d, Flags: %d, Reserved: %d\n", + __rpmsg32_to_cpu(little_endian, msg->src), + __rpmsg32_to_cpu(little_endian, msg->dst), msg_len, + __rpmsg16_to_cpu(little_endian, msg->flags), + __rpmsg32_to_cpu(little_endian, msg->reserved)); + + /* + * We currently use fixed-sized buffers, so trivially sanitize + * the reported payload length. + */ + if (len > vrp->buf_size || + msg_len > (len - sizeof(struct rpmsg_hdr))) { + debug("inbound msg too big: (%d, %d)\n", len, msg_len); + return -EINVAL; + } + + /* call rpmsg callback */ + if (cb && msg->dst == RPMSG_UBOOT_ADDR) + cb(msg->data, msg_len, msgs_received); + + /* publish the real size of the buffer */ + rpmsg_sg_init(&sg, msg, vrp->buf_size); + + /* add the buffer back to the remote processor's virtqueue */ + err = virtqueue_add(vrp->rvq, sgs, 0, 1); + if (err < 0) { + dev_err(vrp->vdev, "failed to add a virtqueue buffer %d\n", err); + return err; + } + + return 0; +} + +int virtio_rpmsg_bus_recv(struct udevice *vdev, rpmsg_rx_cb_t cb) +{ + struct virtproc_info *vrp = dev_get_priv(vdev); + struct rpmsg_hdr *msg; + unsigned int len, msgs_received = 0; + int err; + + rproc_flush_dcache(vdev->parent); + + msg = virtqueue_get_buf(vrp->rvq, &len); + if (!msg) { + debug("uhm, incoming signal, but no used buffer ?\n"); + return -ENODATA; + } + + while (msg) { + err = rpmsg_recv_single(vrp, msg, len, msgs_received, cb); + if (err) { + debug("rpmsg failed to recv msg\n"); + return err; + } + + msgs_received++; + + msg = virtqueue_get_buf(vrp->rvq, &len); + } + + debug("rpmsg messages received = %d\n", msgs_received); + + return 0; +} + +static int virtio_rpmsg_bus_remove(struct udevice *vdev) +{ + virtio_reset(vdev); + + return 0; +} + +static int virtio_rpmsg_bus_probe(struct udevice *uvdev) +{ + struct rproc_rvdev_data *rvdev_data; + struct rproc_mem_entry *vdev_buf; + struct virtproc_info *vrp; + size_t total_buf_space; + int err = 0, i; + void *bufs_va; + + vrp = dev_get_priv(uvdev); + if (!vrp) { + dev_err(uvdev, "vrp not available\n"); + return -EINVAL; + } + + vrp->vdev = uvdev; + rvdev_data = (struct rproc_rvdev_data *)dev_get_plat(uvdev->parent); + vdev_buf = rvdev_data->vdev_buf; + if (!vdev_buf) { + dev_err(uvdev, "vdev buffer isn't availablne\n"); + return -ENOMEM; + } + + err = virtio_find_vqs(uvdev, 2, vrp->vqs); + if (err) { + dev_err(uvdev, "failed to find vqs with err = %d\n", err); + return -EINVAL; + } + + if (!vrp->vqs[0] || !vrp->vqs[1]) { + dev_err(uvdev, "failed to find vq\n"); + return -EINVAL; + } + + /* symmetric tx/rx vrings are expected */ + if (virtqueue_get_vring_size(vrp->rvq) != virtqueue_get_vring_size(vrp->svq)) + dev_warn(uvdev, "rx vq and tx vq are not same size\n"); + + /* less buffers are needed if vrings are small */ + if (virtqueue_get_vring_size(vrp->rvq) < MAX_RPMSG_NUM_BUFS / 2) + vrp->num_bufs = virtqueue_get_vring_size(vrp->rvq) * 2; + else + vrp->num_bufs = MAX_RPMSG_NUM_BUFS; + + vrp->buf_size = MAX_RPMSG_BUF_SIZE; + vrp->last_sbuf = 0; + + total_buf_space = vrp->num_bufs * vrp->buf_size; + + if (vdev_buf->len < total_buf_space) { + dev_err(uvdev, "not enough vdev buffer memory\n"); + return -EINVAL; + } + + /* allocate coherent memory for the buffers */ + bufs_va = vdev_buf->va; + if (!bufs_va) { + err = -ENOMEM; + goto vqs_del; + } + + /* half of the buffers is dedicated for RX */ + vrp->rbufs = bufs_va; + + /* and half is dedicated for TX */ + vrp->sbufs = bufs_va + (total_buf_space / 2); + + /* set up the receive buffers */ + for (i = 0; i < vrp->num_bufs / 2; i++) { + struct virtio_sg sg; + struct virtio_sg *sgs[] = { &sg }; + + void *cpu_addr = vrp->rbufs + i * vrp->buf_size; + + rpmsg_sg_init(&sg, cpu_addr, vrp->buf_size); + + err = virtqueue_add(vrp->rvq, sgs, 0, 1); + if (err) /* sanity check; this can't really happen */ + dev_warn(uvdev, "adding inbuf for dev %s, vq %d failed\n", + vrp->vdev->name, vrp->rvq->index); + } + + /* ToDo: Support Named service announcement */ + + /* let remote know that host can receive data */ + virtqueue_kick(vrp->rvq); + + return 0; + +vqs_del: + virtio_del_vqs(uvdev); + + return err; +} + +static void virtio_rpmsg_bus_debug_data(struct udevice *uvdev, int vq_id) +{ + struct virtproc_info *vrp; + + vrp = dev_get_priv(uvdev); + + if (vrp->vqs[vq_id]) + virtqueue_dump(vrp->vqs[vq_id]); + else + dev_info(uvdev, "virtqueue %d not found\n", vq_id); +} + +static const struct rpmsg_device_ops virtio_rpmsg_dev_ops = { + .send = virtio_rpmsg_bus_send, + .recv = virtio_rpmsg_bus_recv, + .debug_data = virtio_rpmsg_bus_debug_data, +}; + +U_BOOT_DRIVER(virtio_rpmsg_bus) = { + .name = VIRTIO_RPROC_DRV_NAME, + .id = UCLASS_RPMSG, + .probe = virtio_rpmsg_bus_probe, + .remove = virtio_rpmsg_bus_remove, + .ops = &virtio_rpmsg_dev_ops, + .priv_auto = sizeof(struct virtproc_info), + .flags = DM_FLAG_ACTIVE_DMA, +}; diff --git a/drivers/virtio/virtio-uclass.c b/drivers/virtio/virtio-uclass.c index 31bb21c534..0c76479c45 100644 --- a/drivers/virtio/virtio-uclass.c +++ b/drivers/virtio/virtio-uclass.c @@ -31,6 +31,7 @@ static const char *const virtio_drv_name[VIRTIO_ID_MAX_NUM] = { [VIRTIO_ID_NET] = VIRTIO_NET_DRV_NAME, [VIRTIO_ID_BLOCK] = VIRTIO_BLK_DRV_NAME, [VIRTIO_ID_RNG] = VIRTIO_RNG_DRV_NAME, + [VIRTIO_ID_RPROC] = VIRTIO_RPROC_DRV_NAME, };

int virtio_get_config(struct udevice *vdev, unsigned int offset, diff --git a/include/dm/uclass-id.h b/include/dm/uclass-id.h index 307ad6931c..a1a4746a63 100644 --- a/include/dm/uclass-id.h +++ b/include/dm/uclass-id.h @@ -114,6 +114,7 @@ enum uclass_id { UCLASS_REMOTEPROC, /* Remote Processor device */ UCLASS_RESET, /* Reset controller device */ UCLASS_RNG, /* Random Number Generator */ + UCLASS_RPMSG, /* RPMsg device */ UCLASS_RTC, /* Real time clock device */ UCLASS_SCMI_AGENT, /* Interface with an SCMI server */ UCLASS_SCSI, /* SCSI device */ diff --git a/include/rpmsg.h b/include/rpmsg.h new file mode 100644 index 0000000000..bed61240ca --- /dev/null +++ b/include/rpmsg.h @@ -0,0 +1,140 @@ +/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ +#ifndef _RPMSG_H_ +#define _RPMSG_H_ + +/** + * struct dm_rpmsg_uclass_pdata - platform data for a CPU + * @name: Platform-specific way of naming the RPMsg platform device + * @driver_plat_data: driver specific platform data that may be needed. + * + * This can be accessed with dev_get_uclass_plat() for any UCLASS_RPMSG + * device. + * + */ +struct dm_rpmsg_uclass_pdata { + const char *name; + void *driver_plat_data; +}; + +typedef __u16 __bitwise __rpmsg16; +typedef __u32 __bitwise __rpmsg32; +typedef __u64 __bitwise __rpmsg64; + +#define RPMSG_ADDR_ANY 0xFFFFFFFF + +#define RPMSG_NAME_SIZE 32 + +static inline bool rpmsg_is_little_endian(void) +{ +#ifdef __LITTLE_ENDIAN + return true; +#else + return false; +#endif +} + +static inline u16 __rpmsg16_to_cpu(bool little_endian, __rpmsg16 val) +{ + if (little_endian) + return le16_to_cpu((__force __le16)val); + else + return be16_to_cpu((__force __be16)val); +} + +static inline __rpmsg16 __cpu_to_rpmsg16(bool little_endian, u16 val) +{ + if (little_endian) + return (__force __rpmsg16)cpu_to_le16(val); + else + return (__force __rpmsg16)cpu_to_be16(val); +} + +static inline u32 __rpmsg32_to_cpu(bool little_endian, __rpmsg32 val) +{ + if (little_endian) + return le32_to_cpu((__force __le32)val); + else + return be32_to_cpu((__force __be32)val); +} + +static inline __rpmsg32 __cpu_to_rpmsg32(bool little_endian, u32 val) +{ + if (little_endian) + return (__force __rpmsg32)cpu_to_le32(val); + else + return (__force __rpmsg32)cpu_to_be32(val); +} + +static inline u64 __rpmsg64_to_cpu(bool little_endian, __rpmsg64 val) +{ + if (little_endian) + return le64_to_cpu((__force __le64)val); + else + return be64_to_cpu((__force __be64)val); +} + +static inline __rpmsg64 __cpu_to_rpmsg64(bool little_endian, u64 val) +{ + if (little_endian) + return (__force __rpmsg64)cpu_to_le64(val); + else + return (__force __rpmsg64)cpu_to_be64(val); +} + +static inline u16 rpmsg16_to_cpu(__rpmsg16 val) +{ + return __rpmsg16_to_cpu(rpmsg_is_little_endian(), val); +} + +static inline __rpmsg16 cpu_to_rpmsg16(u16 val) +{ + return __cpu_to_rpmsg16(rpmsg_is_little_endian(), val); +} + +static inline u32 rpmsg32_to_cpu(__rpmsg32 val) +{ + return __rpmsg32_to_cpu(rpmsg_is_little_endian(), val); +} + +static inline __rpmsg32 cpu_to_rpmsg32(u32 val) +{ + return __cpu_to_rpmsg32(rpmsg_is_little_endian(), val); +} + +static inline u64 rpmsg64_to_cpu(__rpmsg64 val) +{ + return __rpmsg64_to_cpu(rpmsg_is_little_endian(), val); +} + +static inline __rpmsg64 cpu_to_rpmsg64(u64 val) +{ + return __cpu_to_rpmsg64(rpmsg_is_little_endian(), val); +} + +typedef int (*rpmsg_rx_cb_t)(void *buf, int msg_len, u32 msgs_received); + +#if IS_ENABLED(CONFIG_RPMSG) + +int rpmsg_init(int core_id); +int rpmsg_send(int core_id, void *data, int len); +int rpmsg_recv(int core_id, rpmsg_rx_cb_t cb); + +#else +int rpmsg_init(int core_id) +{ + return -ENODEV; +} + +int rpmsg_send(int core_id, void *data, int len) +{ + return -ENODEV; +} + +int rpmsg_recv(int core_id, rpmsg_rx_cb_t cb) +{ + return -ENODEV; +} + +#endif /* IS_ENABLED(CONFIG_RPMSG) */ + +#endif /* _RPMSG_H */ diff --git a/include/rproc_virtio.h b/include/rproc_virtio.h index cbe8ff420f..96d0e3d15c 100644 --- a/include/rproc_virtio.h +++ b/include/rproc_virtio.h @@ -9,15 +9,19 @@ #include <remoteproc.h> #include <dm/device.h>

-void rproc_flush_dcache(struct udevice *dev); - #ifndef CONFIG_SANDBOX

+void rproc_flush_dcache(struct udevice *dev); + int rproc_virtio_create_dev(struct udevice *parent, struct fw_rsc_vdev *rsc, int offset);

#else

+void rproc_flush_dcache(struct udevice *dev) +{ +} + int rproc_virtio_create_dev(struct udevice *parent, struct fw_rsc_vdev *rsc, int offset) { diff --git a/include/virtio.h b/include/virtio.h index 16d0f8aa7f..35274a3593 100644 --- a/include/virtio.h +++ b/include/virtio.h @@ -26,11 +26,13 @@ #define VIRTIO_ID_NET 1 /* virtio net */ #define VIRTIO_ID_BLOCK 2 /* virtio block */ #define VIRTIO_ID_RNG 4 /* virtio rng */ -#define VIRTIO_ID_MAX_NUM 5 +#define VIRTIO_ID_RPROC 7 /* virtio rproc */ +#define VIRTIO_ID_MAX_NUM 8

#define VIRTIO_NET_DRV_NAME "virtio-net" #define VIRTIO_BLK_DRV_NAME "virtio-blk" #define VIRTIO_RNG_DRV_NAME "virtio-rng" +#define VIRTIO_RPROC_DRV_NAME "virtio-rpmsg-bus"

/* Status byte for guest to report progress, and synchronize features */

diff --git a/include/virtio_ring.h b/include/virtio_ring.h index 4a9b4078ee..e0cd773913 100644 --- a/include/virtio_ring.h +++ b/include/virtio_ring.h @@ -264,6 +264,21 @@ struct virtqueue *vring_create_virtqueue(unsigned int index, unsigned int num, unsigned int vring_align, struct udevice *udev);

+/** + * vring_new_virtqueue - create a virtqueue at user defined address + * + * @index: the index of the queue + * @vring: vring created at user defined address + * @udev: the virtio transport udevice + * @return: the virtqueue pointer or NULL if failed + * + * This creates a virtqueue using vring address decided by the user of API + * + * This API is supposed to be called by the virtio transport driver in the + * virtio find_vqs() uclass method. + */ +struct virtqueue *vring_new_virtqueue(unsigned int index, struct vring vring, + struct udevice *udev); /** * vring_del_virtqueue - destroy a virtqueue * diff --git a/test/dm/Makefile b/test/dm/Makefile index 3799b1ae8f..732c35a496 100644 --- a/test/dm/Makefile +++ b/test/dm/Makefile @@ -97,6 +97,7 @@ obj-$(CONFIG_RAM) += ram.o obj-y += regmap.o obj-$(CONFIG_REMOTEPROC) += remoteproc.o obj-$(CONFIG_DM_RESET) += reset.o +obj-$(CONFIG_RPMSG) += rpmsg.o obj-$(CONFIG_SYSRESET) += sysreset.o obj-$(CONFIG_DM_REGULATOR) += regulator.o obj-$(CONFIG_DM_RNG) += rng.o diff --git a/test/dm/rpmsg.c b/test/dm/rpmsg.c new file mode 100644 index 0000000000..ecd2ba3680 --- /dev/null +++ b/test/dm/rpmsg.c @@ -0,0 +1,41 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (C) 2023, Advanced Micro Devices, Inc. + */ +#include <common.h> +#include <dm.h> +#include <elf.h> +#include <errno.h> +#include <rpmsg.h> +#include <asm/io.h> +#include <dm/test.h> +#include <test/test.h> +#include <test/ut.h> + +static char test_buf[512]; + +static int rpmsg_rx_cb(void *buf, int msg_len, u32 msgs_received) +{ + memcpy(test_buf, buf, msg_len); + + return 0; +} + +/** + * dm_test_rpmsg() - test the operations after initializations + * @uts: unit test state + * + * @return: 0 if all test pass + */ +static int dm_test_rpmsg(struct unit_test_state *uts) +{ + ut_assertok(rpmsg_init(0)); + ut_assertok(rpmsg_send(0, "test rpmsg", strlen("test rpmsg"))); + ut_assertok(rpmsg_recv(0, rpmsg_rx_cb)); + + ut_asserteq_str(test_buf, "test rpmsg"); + + return 0; +} + +DM_TEST(dm_test_rpmsg, UT_TESTF_SCAN_PDATA | UT_TESTF_FLAT_TREE);

This patch introduces commands to use rpmsg framework

rpmsg init <core id> - Initialize rpmsg framework for remote core

rpmsg debug_data <core id> <"tx" / "rx"> - debug tx or rx virtqueues. This command simply uses virtqueue_dump_data and prints virtqueue for rpmsg device mapped to <core id>

Signed-off-by: Tanmay Shah tanmay.shah@amd.com --- MAINTAINERS | 1 + cmd/Kconfig | 6 +++++ cmd/Makefile | 1 + cmd/rpmsg.c | 61 +++++++++++++++++++++++++++++++++++++++++++++++++ include/rpmsg.h | 5 ++++ 5 files changed, 74 insertions(+) create mode 100644 cmd/rpmsg.c

diff --git a/MAINTAINERS b/MAINTAINERS index 876a7fdbdf..8e40da38e7 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -1368,6 +1368,7 @@ F: doc/README.rockusb RPMSG M: Tanmay Shah tanmay.shah@amd.com S: Maintained +F: cmd/rpmsg.c F: drivers/rpmsg/* F: include/rpmsg.h F: test/dm/rpmsg.c diff --git a/cmd/Kconfig b/cmd/Kconfig index 2d6e5f993f..355644a3fa 100644 --- a/cmd/Kconfig +++ b/cmd/Kconfig @@ -1450,6 +1450,12 @@ config CMD_REMOTEPROC help Support for Remote Processor control

+config CMD_RPMSG + bool "rpmsg" + help + Support for RPMsg protocol over virtio for data transfer between + U-Boot and remote processor firmware + config CMD_SATA bool "sata - Access SATA subsystem" select SATA diff --git a/cmd/Makefile b/cmd/Makefile index 9f8c0b058b..23838698ea 100644 --- a/cmd/Makefile +++ b/cmd/Makefile @@ -149,6 +149,7 @@ obj-$(CONFIG_CMD_REGINFO) += reginfo.o obj-$(CONFIG_CMD_REISER) += reiser.o obj-$(CONFIG_CMD_REMOTEPROC) += remoteproc.o obj-$(CONFIG_CMD_RNG) += rng.o +obj-$(CONFIG_CMD_RPMSG) += rpmsg.o obj-$(CONFIG_CMD_KASLRSEED) += kaslrseed.o obj-$(CONFIG_CMD_ROCKUSB) += rockusb.o obj-$(CONFIG_CMD_RTC) += rtc.o diff --git a/cmd/rpmsg.c b/cmd/rpmsg.c new file mode 100644 index 0000000000..da8aa05c9d --- /dev/null +++ b/cmd/rpmsg.c @@ -0,0 +1,61 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (C) 2023, Advanced Micro Devices, Inc. + */ +#include <common.h> +#include <command.h> +#include <dm.h> +#include <errno.h> +#include <malloc.h> +#include <rpmsg.h> + +static int do_rpmsg_init(struct cmd_tbl *cmdtp, int flag, int argc, + char *const argv[]) +{ + /* Expect args to <core id> <data string> */ + + int core_id, ret = CMD_RET_USAGE; + + if (argc != 2) + return ret; + + core_id = strtoul(argv[1], NULL, 16); + rpmsg_init(core_id); + + return 0; +} + +static int do_rpmsg_debug_data(struct cmd_tbl *cmdtp, int flag, int argc, + char *const argv[]) +{ + /* + * Expect args to <core id> <data string> + */ + int core_id, vq_id; + + if (argc != 3) + return CMD_RET_USAGE; + + core_id = strtoul(argv[1], NULL, 10); + if (!strcmp(argv[2], "rx")) + vq_id = 0; + else if (!strcmp(argv[2], "tx")) + vq_id = 1; + else + return CMD_RET_USAGE; + + rpmsg_debug_data(core_id, vq_id); + + return 0; +} + +static char rpmsg_cmd_help[] = + "Send/Recv data over RPMsg channel from U-Boot to remote processor.\n" + "commands:\n" + "rpmsg init <rproc core id>\n" + "rpmsg debug_data <rproc core id> <vq name (tx or rx)>\n"; + +U_BOOT_CMD_WITH_SUBCMDS(rpmsg, "rpmsg subsystem", rpmsg_cmd_help, + U_BOOT_SUBCMD_MKENT(init, 2, 0, do_rpmsg_init), + U_BOOT_SUBCMD_MKENT(debug_data, 3, 1, + do_rpmsg_debug_data)); diff --git a/include/rpmsg.h b/include/rpmsg.h index bed61240ca..18e8ee1ee2 100644 --- a/include/rpmsg.h +++ b/include/rpmsg.h @@ -118,6 +118,7 @@ typedef int (*rpmsg_rx_cb_t)(void *buf, int msg_len, u32 msgs_received); int rpmsg_init(int core_id); int rpmsg_send(int core_id, void *data, int len); int rpmsg_recv(int core_id, rpmsg_rx_cb_t cb); +void rpmsg_debug_data(int core_id, int vq_id);

#else int rpmsg_init(int core_id) @@ -135,6 +136,10 @@ int rpmsg_recv(int core_id, rpmsg_rx_cb_t cb) return -ENODEV; }

+void rpmsg_debug_data(int core_id, int vq_id) +{ +} + #endif /* IS_ENABLED(CONFIG_RPMSG) */

#endif /* _RPMSG_H */

ZynqMP platform has ARM Cortex-R5 dual core remote processor also known as RPU (Real-time Processing Unit). This remoteproc platform driver is responsible to configure the RPU and manages life-cycle of the RPU along with other platform specific operations.

Signed-off-by: Tanmay Shah tanmay.shah@amd.com --- MAINTAINERS | 1 + drivers/firmware/firmware-zynqmp.c | 20 ++ drivers/remoteproc/Kconfig | 9 + drivers/remoteproc/Makefile | 1 + drivers/remoteproc/xlnx_rproc.c | 411 +++++++++++++++++++++++++++++ include/zynqmp_firmware.h | 16 ++ 6 files changed, 458 insertions(+) create mode 100644 drivers/remoteproc/xlnx_rproc.c

diff --git a/MAINTAINERS b/MAINTAINERS index 8e40da38e7..feaf2ecd90 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -1323,6 +1323,7 @@ REMOTEPROC M: Tanmay Shah tanmay.shah@amd.com S: Maintained F: drivers/remoteproc/rproc_virtio.c +F: drivers/remoteproc/xlnx_rproc.c F: include/rproc_virtio.h

RISC-V diff --git a/drivers/firmware/firmware-zynqmp.c b/drivers/firmware/firmware-zynqmp.c index 0897992405..ec6057d4e3 100644 --- a/drivers/firmware/firmware-zynqmp.c +++ b/drivers/firmware/firmware-zynqmp.c @@ -202,6 +202,26 @@ int zynqmp_pm_request_node(const u32 node, const u32 capabilities, qos, ack, NULL); }

+/** + * zynqmp_pm_request_wake - PM call to wake up selected master or subsystem + * @node: Node ID of the master or subsystem + * @set_addr: Specifies whether the address argument is relevant + * @address: Address from which to resume when woken up + * @ack: Flag to specify whether acknowledge requested + * + * Return: status, either success or error+reason + */ +int zynqmp_pm_request_wake(const u32 node, + const bool set_addr, + const u64 address, + const enum zynqmp_pm_request_ack ack) +{ + /* set_addr flag is encoded into 1st bit of address */ + return xilinx_pm_request(PM_REQUEST_WAKEUP, node, + lower_32_bits(address | set_addr), + upper_32_bits(address), ack, NULL); +} + int zynqmp_pm_is_function_supported(const u32 api_id, const u32 id) { int ret; diff --git a/drivers/remoteproc/Kconfig b/drivers/remoteproc/Kconfig index b758c248e4..9fd8cda3c8 100644 --- a/drivers/remoteproc/Kconfig +++ b/drivers/remoteproc/Kconfig @@ -113,4 +113,13 @@ config REMOTEPROC_VIRTIO drivers provide a set of ops for the real virtio device driver to call.

+config REMOTEPROC_XLNX + bool "Support for AMD-Xilinx platform's remoteproc driver" + select REMOTEPROC_VIRTIO + depends on DM + depends on ZYNQMP_FIRMWARE + help + Say 'y' here to add support for remoteproc platform + driver for various AMD-Xilinx platforms + endmenu diff --git a/drivers/remoteproc/Makefile b/drivers/remoteproc/Makefile index 61fdb87efb..1d0c48820b 100644 --- a/drivers/remoteproc/Makefile +++ b/drivers/remoteproc/Makefile @@ -17,3 +17,4 @@ obj-$(CONFIG_REMOTEPROC_TI_POWER) += ti_power_proc.o obj-$(CONFIG_REMOTEPROC_TI_PRU) += pru_rproc.o obj-$(CONFIG_REMOTEPROC_TI_IPU) += ipu_rproc.o obj-$(CONFIG_REMOTEPROC_VIRTIO) += rproc_virtio.o +obj-$(CONFIG_REMOTEPROC_XLNX) += xlnx_rproc.o diff --git a/drivers/remoteproc/xlnx_rproc.c b/drivers/remoteproc/xlnx_rproc.c new file mode 100644 index 0000000000..f29b958b7f --- /dev/null +++ b/drivers/remoteproc/xlnx_rproc.c @@ -0,0 +1,411 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * AMD-Xilinx remoteproc driver + * + * Copyright (C) 2023, Advanced Micro Devices, Inc. + */ + +#include <common.h> +#include <dm.h> +#include <errno.h> +#include <remoteproc.h> +#include <rpmsg.h> +#include <zynqmp_firmware.h> +#include <asm/dma-mapping.h> +#include <asm/io.h> +#include <dm/device_compat.h> +#include <dm/device-internal.h> +#include <linux/ioport.h> + +#define MAX_CORE 2 +#define RSCTBL_PROP "xlnx,rsc-tbl" +#define RSC_TBL_SIZE 0x400 + +enum xlnx_cluster_mode_dt_prop { + split_mode = 0, + lockstep_mode = 1, + single_cpu_mode = 2, +}; + +enum xlnx_rpu_state { + INVALID_STATE = 0, + DRIVER_PROBE = 1, + RPU_INIT = 2, + RPU_ATTACH = 3, + RPU_DETACH = 4 +}; + +struct rproc xlnx_rproc_cfg_arr[2]; + +/** + * struct xlnx_rproc_core_privdata - contains private data of RPU core driver + * + * @cluster_dev: parent device of each core, device mapped to + * cluster node + * @rpu_mode: one of split, lockstep or single-cpu mode + * @tcm_mode: TCM configuration - split or lockstep + * @state: current state of RPU + * @rproc_cfg: core's corresponding remoteproc data + * @vdev: core's corresponding remoteproc virtio device + * @rsc_pa: core's physical resource table address + * @pd_node: power-domain id of core + * @index: core's child node index in cluster node in device-tree + */ +struct xlnx_rproc_core_privdata { + struct udevice *cluster_dev; + enum rpu_oper_mode rpu_mode; + enum rpu_tcm_comb tcm_mode; + enum xlnx_rpu_state state; + struct rproc rproc_cfg; + struct udevice *vdev; + phys_addr_t rsc_pa; + int pd_node; + int index; +}; + +/** + * struct xlnx_rproc_cluster_privdata - contains privdate data of cluster driver + * + * @cores: Array of pointers to R5 cores within the cluster + * @rpu_cluster_mode: xlnx,cluster-mode dt prop value to configure RPU + * @core_probed: keep count of number of cores probed + * @core_count: number of individual cores available based on cluster-mode + * for lockstep this is 1, for split this is 2. + */ +struct xlnx_rproc_cluster_privdata { + struct xlnx_rproc_core_privdata *cores[MAX_CORE]; + enum xlnx_cluster_mode_dt_prop rpu_cluster_mode; + int core_probed; + int core_count; +}; + +static int xlnx_rproc_detach(struct udevice *udev) +{ + struct xlnx_rproc_core_privdata *core = dev_get_priv(udev); + + if (core->state != RPU_ATTACH) { + debug("RPU %s isn't attached yet\n", udev->name); + return 0; + } + + core->state = RPU_DETACH; + + return 0; +} + +static int xlnx_rproc_attach(struct udevice *udev) +{ + struct xlnx_rproc_core_privdata *core = dev_get_priv(udev); + struct rproc *rproc = rproc_get_cfg(udev); + struct resource_table *rsctbl; + u32 rsc_tbl_start; + int ret; + + /* + * RPU attach will parse and alloc resources only after INIT state. + * Once the resources are allocated we won't be releasing them during + * detach, but we just change the state of RPU. So, during kick, based + * on state we can decided if RPU should be notified or not + */ + if (core->state == RPU_DETACH) { + core->state = RPU_ATTACH; + return 0; + } + + if (core->state != RPU_INIT) { + debug("RPU isn't initialized, can't attach\n"); + return 0; + } + + /* get rsc tbl carveout info */ + ret = dev_read_u32_index(udev, RSCTBL_PROP, 1, &rsc_tbl_start); + if (ret < 0) { + debug("failed to read phandle for prop %s", RSCTBL_PROP); + return ret; + } + + core->rsc_pa = (phys_addr_t)map_physmem(rsc_tbl_start, RSC_TBL_SIZE, + MAP_NOCACHE); + rproc->table_ptr = (struct resource_table *)core->rsc_pa; + + if (!core->rsc_pa) { + dev_info(udev, "rsc tbl not available\n"); + return -EINVAL; + } + + rsctbl = (struct resource_table *)core->rsc_pa; + if (rsctbl->ver != 1) { + debug("fw rsc table version %d not compatible\n", rsctbl->ver); + return -EINVAL; + } + + if (rsctbl->num < 1 || rsctbl->num > 255) { + debug("number of resources are invalid %d\n", rsctbl->num); + return -EINVAL; + } + + if (rproc_attach_resource_table(udev)) { + debug("rsc table not found\n"); + return -EINVAL; + } + + core->state = RPU_ATTACH; + + return 0; +} + +static void xlnx_remove_all_res(struct rproc_mem_entry *mapping) +{ + struct list_head *tmp, *head; + + head = &mapping->node; + if (!head) + return; + + /* remove the list */ + tmp = head; + while (tmp) { + head = head->next; + kfree(tmp); + tmp = head; + } +} + +static int xlnx_add_res(struct udevice *dev, struct rproc_mem_entry *mapping) +{ + struct rproc *rproc = rproc_get_cfg(dev); + + list_add_tail(&mapping->node, &rproc->mappings.node); + + return 0; +} + +static int zynqmp_r5_get_mem_region_node(struct udevice *udev) +{ + struct rproc_mem_entry *mapping; + int num_mem_region = 4, i, ret; + u32 mem_reg_vals[4] = {0}; + ofnode mem_reg_node; + struct rproc *rproc; + + rproc = rproc_get_cfg(udev); + if (!rproc) + return -EINVAL; + + ret = dev_read_u32_array(udev, "memory-region", mem_reg_vals, 4); + if (ret < 0) { + debug("Unable to read memory-region property\n"); + return -EINVAL; + } + + for (i = 0; i < num_mem_region; i++) { + mem_reg_node = ofnode_get_by_phandle(mem_reg_vals[i]); + if (!ofnode_valid(mem_reg_node)) { + debug("Could not parse mem region node\n"); + return -EINVAL; + } + + mapping = kzalloc(sizeof(*mapping), GFP_KERNEL); + if (!mapping) + goto remove_mem_region; + + mapping->dma = ofnode_get_addr(mem_reg_node); + mapping->len = ofnode_get_size(mem_reg_node); + mapping->da = mapping->dma; + mapping->va = map_physmem(mapping->da, mapping->len, MAP_NOCACHE); + + strlcpy(mapping->name, ofnode_get_name(mem_reg_node), + RPMSG_NAME_SIZE); + + debug("dev %s mapping %s: va=0x%p, da=0x%x, dma=0x%llx, len=0x%x\n", + udev->name, mapping->name, mapping->va, mapping->da, + mapping->dma, mapping->len); + xlnx_add_res(udev, mapping); + } + + return 0; + +remove_mem_region: + xlnx_remove_all_res(&rproc->mappings); + + return -EINVAL; +} + +static int xlnx_rproc_init(struct udevice *udev) +{ + struct xlnx_rproc_core_privdata *core = dev_get_priv(udev); + struct rproc *rproc = rproc_get_cfg(udev); + int ret; + + if (core->state != DRIVER_PROBE) + return 0; + + /* + * If for some reason, memory-region property fails then don't fail + * the command as memory-region is not required property + */ + ret = zynqmp_r5_get_mem_region_node(udev); + if (ret) + debug("adding memory-region failed with ret %d\n", ret); + + rproc->support_rpmsg_virtio = true; + + core->state = RPU_INIT; + + return 0; +} + +static int xlnx_rproc_probe(struct udevice *udev) +{ + struct xlnx_rproc_cluster_privdata *cluster = dev_get_priv(udev->parent); + struct xlnx_rproc_core_privdata *core = dev_get_priv(udev); + struct dm_rproc_uclass_pdata *pdata = dev_get_plat(udev); + + /* Assume primary core gets probed first */ + if (cluster->core_probed >= cluster->core_count) { + debug("core %d isn't used in mode %d\n", + cluster->core_probed, cluster->rpu_cluster_mode); + return -EINVAL; + } + + core->index = cluster->core_probed; + cluster->cores[core->index] = core; + + pdata->rproc = &xlnx_rproc_cfg_arr[core->index]; + pdata->rproc->rproc_id = core->index; + + INIT_LIST_HEAD(&pdata->rproc->mappings.node); + + if (cluster->rpu_cluster_mode == split_mode) { + core->tcm_mode = PM_RPU_TCM_SPLIT; + core->rpu_mode = PM_RPU_MODE_SPLIT; + } else if (cluster->rpu_cluster_mode == lockstep_mode) { + core->tcm_mode = PM_RPU_TCM_COMB; + core->rpu_mode = PM_RPU_MODE_LOCKSTEP; + } else if (cluster->rpu_cluster_mode == single_cpu_mode) { + debug("single cpu cluster mode not supported\n"); + return -EINVAL; + } + + pdata->rproc->support_rpmsg_virtio = true; + + cluster->core_probed++; + core->state = DRIVER_PROBE; + + cluster->cores[core->index] = core; + INIT_LIST_HEAD(&pdata->rproc->mappings.node); + + return 0; +} + +static struct resource_table * +xlnx_rpu_rproc_get_loaded_rsc_table(struct udevice *dev, int *table_sz) +{ + struct xlnx_rproc_core_privdata *core = dev_get_priv(dev); + + *table_sz = RSC_TBL_SIZE; + + return (struct resource_table *)core->rsc_pa; +} + +static int xlnx_rproc_kick(struct udevice *dev, int notify_id) +{ + struct xlnx_rproc_core_privdata *core = dev_get_priv(dev); + + if (core->state != RPU_ATTACH) { + debug("error: RPU %s state=%d\n", dev->name, core->state); + return -EINVAL; + } + + return 0; +} + +static int xlnx_rproc_of_to_plat(struct udevice *udev) +{ + struct xlnx_rproc_core_privdata *core = dev_get_priv(udev); + int ret; + + ret = dev_read_u32_index(udev, "power-domains", 1, &core->pd_node); + if (ret) { + debug("failed to read power-domains property\n"); + return -EINVAL; + } + + return 0; +} + +static const struct dm_rproc_ops xlnx_rproc_ops = { + .init = xlnx_rproc_init, + .attach = xlnx_rproc_attach, + .detach = xlnx_rproc_detach, + .get_loaded_rsc_table = xlnx_rpu_rproc_get_loaded_rsc_table, + .add_res = xlnx_add_res, + .kick = xlnx_rproc_kick, +}; + +static const struct udevice_id xlnx_rproc_ids[] = { + { .compatible = "xlnx,zynqmp-r5f" } +}; + +U_BOOT_DRIVER(xlnx_rproc) = { + .name = "xlnx-rproc", + .of_match = xlnx_rproc_ids, + .id = UCLASS_REMOTEPROC, + .ops = &xlnx_rproc_ops, + .probe = xlnx_rproc_probe, + .of_to_plat = xlnx_rproc_of_to_plat, + .priv_auto = sizeof(struct xlnx_rproc_core_privdata), + .flags = DM_FLAG_VITAL, +}; + +static int xlnx_rproc_cluster_probe(struct udevice *udev) +{ + struct xlnx_rproc_cluster_privdata *cluster = dev_get_priv(udev); + enum xlnx_cluster_mode_dt_prop cluster_mode; + int ret; + + if (device_get_child_count(udev) < MAX_CORE) { + dev_err(udev, "Invalid number of R5 cores for cluster %s\n", + udev->name); + return -EINVAL; + } + + /* set mode */ + ret = dev_read_u32(udev, "xlnx,cluster-mode", &cluster_mode); + if (ret < 0) + cluster_mode = 1; /* default is lockstep */ + + if (cluster->rpu_cluster_mode < split_mode || + cluster->rpu_cluster_mode > single_cpu_mode) { + debug("invalid cluster mode %d\n", cluster->rpu_cluster_mode); + return -EINVAL; + } + + cluster->rpu_cluster_mode = cluster_mode; + + if (cluster_mode == split_mode) { /* split */ + cluster->core_count = 2; + } else if (cluster_mode == lockstep_mode) { /* lockstep */ + cluster->core_count = 1; + } else if (cluster_mode == single_cpu_mode) { /* single-cpu not supported */ + debug("single cpu cluster mode not supported\n"); + return -EINVAL; + } + + cluster->core_probed = 0; + + return 0; +} + +static const struct udevice_id xlnx_cluster_ids[] = { + { .compatible = "xlnx,zynqmp-r5fss", }, + {} +}; + +U_BOOT_DRIVER(xlnx_cluster) = { + .name = "xlnx_cluster", + .of_match = xlnx_cluster_ids, + .id = UCLASS_MISC, + .probe = xlnx_rproc_cluster_probe, + .priv_auto = sizeof(struct xlnx_rproc_cluster_privdata), +}; diff --git a/include/zynqmp_firmware.h b/include/zynqmp_firmware.h index ce086f48d4..6419ca0c58 100644 --- a/include/zynqmp_firmware.h +++ b/include/zynqmp_firmware.h @@ -450,6 +450,21 @@ enum zynqmp_pm_request_ack { ZYNQMP_PM_REQUEST_ACK_NON_BLOCKING = 3, };

+enum rpu_boot_mem { + PM_RPU_BOOTMEM_LOVEC = 0, + PM_RPU_BOOTMEM_HIVEC = 1, +}; + +enum rpu_tcm_comb { + PM_RPU_TCM_SPLIT = 0, + PM_RPU_TCM_COMB = 1, +}; + +enum rpu_oper_mode { + PM_RPU_MODE_LOCKSTEP = 0, + PM_RPU_MODE_SPLIT = 1, +}; + unsigned int zynqmp_firmware_version(void); int zynqmp_pmufw_node(u32 id); int zynqmp_pmufw_config_close(void); @@ -461,6 +476,7 @@ int zynqmp_pm_request_node(const u32 node, const u32 capabilities, int zynqmp_pm_set_sd_config(u32 node, enum pm_sd_config_type config, u32 value); int zynqmp_pm_set_gem_config(u32 node, enum pm_gem_config_type config, u32 value); +int zynqmp_pm_set_rpu_mode(u32 node, int rpu_mode); int zynqmp_pm_is_function_supported(const u32 api_id, const u32 id); int zynqmp_mmio_read(const u32 address, u32 *value); int zynqmp_mmio_write(const u32 address, const u32 mask, const u32 value);

Enable configs required to test rpmsg on sandbox build. CMD_MISC is enabled to probe rpmsg_sample_client driver.

Test procedure: - boot sandbox build - command to run rpmsg tests: ut dm rpmsg - command to run sample driver: misc list

Signed-off-by: Tanmay Shah tanmay.shah@amd.com --- configs/sandbox_defconfig | 4 ++++ 1 file changed, 4 insertions(+)

diff --git a/configs/sandbox_defconfig b/configs/sandbox_defconfig index 19cc6701e6..cdada8c0b3 100644 --- a/configs/sandbox_defconfig +++ b/configs/sandbox_defconfig @@ -77,6 +77,7 @@ CONFIG_CMD_I2C=y CONFIG_CMD_LOADM=y CONFIG_CMD_LSBLK=y CONFIG_CMD_MBR=y +CONFIG_CMD_MISC=y CONFIG_CMD_MMC=y CONFIG_CMD_MUX=y CONFIG_CMD_OSD=y @@ -84,6 +85,7 @@ CONFIG_CMD_PCI=y CONFIG_CMD_PCI_MPS=y CONFIG_CMD_READ=y CONFIG_CMD_REMOTEPROC=y +CONFIG_CMD_RPMSG=y CONFIG_CMD_SPI=y CONFIG_CMD_TEMPERATURE=y CONFIG_CMD_USB=y @@ -274,6 +276,8 @@ CONFIG_REMOTEPROC_SANDBOX=y CONFIG_SANDBOX_RESET=y CONFIG_RESET_SYSCON=y CONFIG_RESET_SCMI=y +CONFIG_RPMSG_SANDBOX=y +CONFIG_RPMSG_SAMPLE_CLIENT=y CONFIG_DM_RTC=y CONFIG_RTC_MAX313XX=y CONFIG_RTC_RV8803=y