From nobody Tue Dec 2 01:30:16 2025 Received: from esa.microchip.iphmx.com (esa.microchip.iphmx.com [68.232.153.233]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 761D713D2B2; Fri, 21 Nov 2025 14:23:34 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=68.232.153.233 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763735016; cv=none; b=Y5wTqj37vv64VjIe7Wrdq/DZPn0yaL2XnJQO5L5RmN3R+f7URwT4Kyx2Eam+3XhEjeGhEEIK+yU7DDUahmyMK1T4qwGf+1WzZZJZXLjwjHmsvbxcm7QvJJ9+xj0pG8tIaMdh/qKXJdYFkYPX/8yrwxhEYzkCJ0s9sAyKwwLo4Tk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763735016; c=relaxed/simple; bh=RFyZjpBNatxBQivso0cNp/3Lx9sWRyFCzpK28LJ9vrw=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=L9QDX8jHTOKk5EwWFjUbuft4ZQJeTN0XJyN2Yi/mZLQKpx+5PZZSss40kVioeKSo9h4+0lvKkZ+M8OtFNXDm0X4PCIHKSGoDGRfABnIVrsup7zut7ZKbx91Q2CfNr56WRkRJ4Ml62O0rKs2MCLErU4aGjSRXr/siZA3BUcRPqxc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=microchip.com; spf=pass smtp.mailfrom=microchip.com; dkim=pass (2048-bit key) header.d=microchip.com header.i=@microchip.com header.b=OY9cznM7; arc=none smtp.client-ip=68.232.153.233 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=microchip.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=microchip.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=microchip.com header.i=@microchip.com header.b="OY9cznM7" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=microchip.com; i=@microchip.com; q=dns/txt; s=mchp; t=1763735013; x=1795271013; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=RFyZjpBNatxBQivso0cNp/3Lx9sWRyFCzpK28LJ9vrw=; b=OY9cznM7E6IUVnQHAm5+l9RIzGBZEYbvlqQKP51bhj1qZ3/s32yd+Zbs 0AoSpFdS0Uiwu/i1nc3P7gDwUFL/Oizm1Yg/wZ41bNn+U0V5X8SVCrOip q+kSbpMz+dqk0DVt91krHLk2mBhGooM4CSx0kL6Exrv9FoC/yn/nTEWwU Kq86nvQ3pKOZ5X5wnmrxmmhFpMUhu36BAJk9TVOIiA6e3lPv+qUvmljir I1TZHRGgCrb6LXYXe+pwKSNHy6t8EaE7QuvXpDYYiwJovdHardBHvwxsU USN3w1/JJmXSbNnnAIbHxuUPA2uGGt4iQltX+WIJekLoc84JVHA4YnPEY Q==; X-CSE-ConnectionGUID: 4DZCiQy3SkG8XDg7u9KRRg== X-CSE-MsgGUID: C7mIcXaBTzWhKScVqYC/yA== X-IronPort-AV: E=Sophos;i="6.20,216,1758610800"; d="scan'208";a="56050813" X-Amp-Result: SKIPPED(no attachment in message) Received: from unknown (HELO email.microchip.com) ([170.129.1.10]) by esa1.microchip.iphmx.com with ESMTP/TLS/ECDHE-RSA-AES128-GCM-SHA256; 21 Nov 2025 07:23:27 -0700 Received: from chn-vm-ex02.mchp-main.com (10.10.85.144) by chn-vm-ex03.mchp-main.com (10.10.85.151) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.58; Fri, 21 Nov 2025 07:22:37 -0700 Received: from valentina.microchip.com (10.10.85.11) by chn-vm-ex02.mchp-main.com (10.10.85.144) with Microsoft SMTP Server id 15.1.2507.58 via Frontend Transport; Fri, 21 Nov 2025 07:22:35 -0700 From: Valentina Fernandez To: , , , , , CC: , , Subject: [PATCH v2 1/2] dt-bindings: remoteproc: add Microchip IPC remoteproc Date: Fri, 21 Nov 2025 14:21:56 +0000 Message-ID: <20251121142157.3582463-2-valentina.fernandezalanis@microchip.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20251121142157.3582463-1-valentina.fernandezalanis@microchip.com> References: <20251121142157.3582463-1-valentina.fernandezalanis@microchip.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Microchip family of RISC-V SoCs typically have one or more application clusters. These clusters can be configured to run in an Asymmetric Multi Processing (AMP) mode. Add a dt-binding for these application clusters. Signed-off-by: Valentina Fernandez --- .../microchip,ipc-sbi-remoteproc.yaml | 95 +++++++++++++++++++ 1 file changed, 95 insertions(+) create mode 100644 Documentation/devicetree/bindings/remoteproc/microchip,= ipc-sbi-remoteproc.yaml diff --git a/Documentation/devicetree/bindings/remoteproc/microchip,ipc-sbi= -remoteproc.yaml b/Documentation/devicetree/bindings/remoteproc/microchip,i= pc-sbi-remoteproc.yaml new file mode 100644 index 000000000000..348902f9a202 --- /dev/null +++ b/Documentation/devicetree/bindings/remoteproc/microchip,ipc-sbi-remote= proc.yaml @@ -0,0 +1,95 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/remoteproc/microchip,ipc-sbi-remoteproc= .yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Microchip IPC Remote Processor + +description: + Microchip family of RISC-V SoCs typically have one or more + clusters. These clusters can be configured to run in an Asymmetric + Multi Processing (AMP) mode where clusters are split in independent + software contexts. + +maintainers: + - Valentina Fernandez + +properties: + compatible: + const: microchip,ipc-sbi-remoteproc + + mboxes: + description: + Microchip IPC mailbox specifier. To be used for communication with + a remote cluster. The specifier format is as per the bindings, + Documentation/devicetree/bindings/mailbox/microchip,sbi-ipc.yaml + maxItems: 1 + + memory-region: + minItems: 1 + maxItems: 5 + description: + List of phandles to the reserved memory regions associated wih the r= emoteproc + device. This is variable and describes the memories shared with the = remote cluster + (e.g. firmware, resource table, rpmsg vrings, etc.) + items: + anyOf: + - description: region used for the resource table when firmware is= started by the bootloader + - description: region used for the remote cluster firmware image s= ection + - description: virtio device (vdev) buffer + - description: virtqueue for sending messages to the remote cluste= r (vring0) + - description: virtqueue for receiving messages from the remote cl= uster (vring1) + + memory-region-names: + minItems: 1 + maxItems: 5 + items: + anyOf: + - const: rsc-table + - const: firmware + - const: buffer + - const: vring0 + - const: vring1 + +required: + - compatible + - mboxes + - memory-region + - memory-region-names + +additionalProperties: false + +examples: + - | + // Early boot mode example - firmware started by bootloader + soc { + #address-cells =3D <2>; + #size-cells =3D <2>; + + remoteproc { + compatible =3D "microchip,ipc-sbi-remoteproc"; + mboxes=3D <&ihc 8>; + memory-region =3D <&rsctable>, <&vdev0buffer>, + <&vdev0vring0>, <&vdev0vring1>; + memory-region-names =3D "rsc-table", "buffer", + "vring0", "vring1"; + }; + }; + + - | + // Late boot mode example - firmware started by Linux (remoteproc) + soc { + #address-cells =3D <2>; + #size-cells =3D <2>; + + remoteproc { + compatible =3D "microchip,ipc-sbi-remoteproc"; + mboxes=3D <&ihc 8>; + memory-region =3D <&cluster_firmware>, <&vdev0buffer>, + <&vdev0vring0>, <&vdev0vring1>; + memory-region-names =3D "firmware", "buffer", + "vring0", "vring1"; + }; + }; +... --=20 2.34.1 From nobody Tue Dec 2 01:30:16 2025 Received: from esa.microchip.iphmx.com (esa.microchip.iphmx.com [68.232.154.123]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 49FE433BBB7; Fri, 21 Nov 2025 14:23:43 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=68.232.154.123 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763735026; cv=none; b=qNC/0kwHMV9h0tSAR19uHbW4Hs18/aWymgccf/WzkU6FJJxSL1eSdALzrkoaTQbjkgkeyceuwVU2X5+meAtSw4dwd9txdr8rFCjGV5wh7PeqJWGyhXGEQwv3ufY2lhDKIbtC0vFMhgVD25yOrSZoGInIqWkacTl+KFdoQDLILK8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1763735026; c=relaxed/simple; bh=omMiT7pbMoA+dkdGJLVHzTNHrr6qMPU8BTC52NWXAKE=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=EdeDoVcJsL4Cvn8/1uEXh7rP8VF1UkIunYz2SpbNxQQRugb5leZ1qL0E5b4P+KXGiKYFv1jMjklC67V+UHUywwTTIhpe3AQCpnbb/9cw3LAEvSPyrnrQrWfjWtBfeG0z6SeNo6qZqGcKZ29Bh/HVdYWm0EhEe8I5GJO/ff2ZyWc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=microchip.com; spf=pass smtp.mailfrom=microchip.com; dkim=pass (2048-bit key) header.d=microchip.com header.i=@microchip.com header.b=ZP79mZEW; arc=none smtp.client-ip=68.232.154.123 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=microchip.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=microchip.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=microchip.com header.i=@microchip.com header.b="ZP79mZEW" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=microchip.com; i=@microchip.com; q=dns/txt; s=mchp; t=1763735023; x=1795271023; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=omMiT7pbMoA+dkdGJLVHzTNHrr6qMPU8BTC52NWXAKE=; b=ZP79mZEWMevuV/SXi/Xzzod4S16cKumCmH7SUpWP5x+LAvs3wE+jf+T5 KGrntJvQ+brFuaIJvHswV1Gt8Duzw35/kijRjFRWJm5+8/9DImQtEAyhW 8qLyEcMJiqyONR088NNN7WWeI7t7e5eWOFS7hrz23hvzicEV4UpsZExd9 TGdnr3HfC+mnYJ185bhWi2bdbFncsgHDgPpuBgiqCPLpIkKvjx2yK/An1 p841oqDdCQqbQCg1wzCxJZwIsO7NzcuJS/81mZaqgbPclC9RYH6zcykZr DTUGOhK1gnegW8+vAHFx3p9ejTEnHF1a4EA38A1A3bwVDx2AF9xAWqppg g==; X-CSE-ConnectionGUID: y2gBB57rQ7Cqsaw/h91kwQ== X-CSE-MsgGUID: VRmkWkxjTcaGSucjyNojfQ== X-IronPort-AV: E=Sophos;i="6.20,216,1758610800"; d="scan'208";a="216836379" X-Amp-Result: SKIPPED(no attachment in message) Received: from unknown (HELO email.microchip.com) ([170.129.1.10]) by esa6.microchip.iphmx.com with ESMTP/TLS/ECDHE-RSA-AES128-GCM-SHA256; 21 Nov 2025 07:23:42 -0700 Received: from chn-vm-ex02.mchp-main.com (10.10.85.144) by chn-vm-ex03.mchp-main.com (10.10.85.151) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.58; Fri, 21 Nov 2025 07:22:40 -0700 Received: from valentina.microchip.com (10.10.85.11) by chn-vm-ex02.mchp-main.com (10.10.85.144) with Microsoft SMTP Server id 15.1.2507.58 via Frontend Transport; Fri, 21 Nov 2025 07:22:38 -0700 From: Valentina Fernandez To: , , , , , CC: , , Subject: [PATCH v2 2/2] remoteproc: add support for Microchip IPC remoteproc platform driver Date: Fri, 21 Nov 2025 14:21:57 +0000 Message-ID: <20251121142157.3582463-3-valentina.fernandezalanis@microchip.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20251121142157.3582463-1-valentina.fernandezalanis@microchip.com> References: <20251121142157.3582463-1-valentina.fernandezalanis@microchip.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Microchip family of RISC-V SoCs typically have one or more clusters. These clusters can be configured to run in an Asymmetric Multi Processing (AMP) mode where clusters are split in independent software contexts. Add a remoteproc platform driver to be able to load and boot firmware to remote processors. The driver uses SBI (RISC-V Supervisor Binary Interface) ecalls to request software running in machine privilege mode (M-mode) to start/stop the remote processor. Inter-processor communication is supported through the virtio rpmsg stack using shared memory and the Microchip IPC mailbox driver. Currently, the driver the following features are supported: - Start/stop a remote software context - Kick function implementation for RPMsg Communication - Attach to a remote context loaded by another entity (bootloader) Error Recovery and Power Management features are not currently supported. Signed-off-by: Valentina Fernandez --- drivers/remoteproc/Kconfig | 12 + drivers/remoteproc/Makefile | 1 + drivers/remoteproc/mchp_ipc_sbi_remoteproc.c | 465 +++++++++++++++++++ 3 files changed, 478 insertions(+) create mode 100644 drivers/remoteproc/mchp_ipc_sbi_remoteproc.c diff --git a/drivers/remoteproc/Kconfig b/drivers/remoteproc/Kconfig index 48a0d3a69ed0..68bd68f553ea 100644 --- a/drivers/remoteproc/Kconfig +++ b/drivers/remoteproc/Kconfig @@ -54,6 +54,18 @@ config INGENIC_VPU_RPROC This can be either built-in or a loadable module. If unsure say N. =20 +config MCHP_IPC_SBI_REMOTEPROC + tristate "Microchip IPC remoteproc support" + depends on MCHP_SBI_IPC_MBOX || COMPILE_TEST + depends on ARCH_MICROCHIP + help + Say y here to support booting and loading firmware to remote + processors on various Microchip family of RISC-V SoCs via the + remote processor framework. + This can be either built-in or a loadable module. + If compiled as module, the module will be called mchp_ipc_remoteproc. + If unsure say N. + config MTK_SCP tristate "Mediatek SCP support" depends on ARCH_MEDIATEK || COMPILE_TEST diff --git a/drivers/remoteproc/Makefile b/drivers/remoteproc/Makefile index 1c7598b8475d..afb28dff5666 100644 --- a/drivers/remoteproc/Makefile +++ b/drivers/remoteproc/Makefile @@ -14,6 +14,7 @@ obj-$(CONFIG_REMOTEPROC_CDEV) +=3D remoteproc_cdev.o obj-$(CONFIG_IMX_REMOTEPROC) +=3D imx_rproc.o obj-$(CONFIG_IMX_DSP_REMOTEPROC) +=3D imx_dsp_rproc.o obj-$(CONFIG_INGENIC_VPU_RPROC) +=3D ingenic_rproc.o +obj-$(CONFIG_MCHP_IPC_SBI_REMOTEPROC) +=3D mchp_ipc_sbi_remoteproc.o obj-$(CONFIG_MTK_SCP) +=3D mtk_scp.o mtk_scp_ipi.o obj-$(CONFIG_OMAP_REMOTEPROC) +=3D omap_remoteproc.o obj-$(CONFIG_WKUP_M3_RPROC) +=3D wkup_m3_rproc.o diff --git a/drivers/remoteproc/mchp_ipc_sbi_remoteproc.c b/drivers/remotep= roc/mchp_ipc_sbi_remoteproc.c new file mode 100644 index 000000000000..55d182c1eee7 --- /dev/null +++ b/drivers/remoteproc/mchp_ipc_sbi_remoteproc.c @@ -0,0 +1,465 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Microchip IPC Remoteproc driver + * + * Copyright (c) 2021 - 2025 Microchip Technology Inc. All rights reserved. + * + * Author: Valentina Fernandez + * + * Derived from the imx_rproc implementation: + * Copyright (c) 2017 Pengutronix, Oleksij Rempel + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "remoteproc_internal.h" + +#define SBI_EXT_MICROCHIP_TECHNOLOGY (SBI_EXT_VENDOR_START | \ + MICROCHIP_VENDOR_ID) + +#define MIV_RPROC_MEM_MAX 2 + +enum { + SBI_EXT_RPROC_STATE =3D 0x3, + SBI_EXT_RPROC_START, + SBI_EXT_RPROC_STOP, +}; + +/** + * enum mchp_ipc_rproc_mbox_messages - predefined mailbox messages + * + * @MCHP_IPC_RPROC_MBOX_READY: a ready message response from a remote cont= ext indicating + * that the remote context is up and running. + * + * @MCHP_IPC_RPROC_MBOX_PENDING_MSG: Not currently in use, but reserved fo= r future use + * to inform the receiver that there is a message awaiting in its receive-= side + * vring. At the moment, one can explicitly send the index of the triggered + * virtqueue as a payload. + * + * @MCHP_IPC_RPROC_MBOX_STOP: a stop request for the remote context + * + * @MCHP_IPC_RPROC_MBOX_END_MSG: Indicates end of known/defined messages. + * This should be the last definition. + * + */ +enum mchp_ipc_rproc_mbox_messages { + MCHP_IPC_RPROC_MBOX_READY =3D 0xFFFFFF00, + MCHP_IPC_RPROC_MBOX_PENDING_MSG =3D 0xFFFFFF01, + MCHP_IPC_RPROC_MBOX_STOP =3D 0xFFFFFF02, + MCHP_IPC_RPROC_MBOX_END_MSG =3D 0xFFFFFF03, +}; + +enum { + MCHP_IPC_RPROC_RSC_TABLE_REGION, + MCHP_IPC_RPROC_FW_REGION, + MCHP_IPC_RPROC_BUFF_REGION, + MCHP_IPC_RPROC_VRING0_REGION, + MCHP_IPC_RPROC_VRING1_REGION, + MCHP_IPC_RPROC_REGION_MAX, +}; + +struct mchp_ipc_rproc_mem_region { + const char *name; + const char *prefix; +}; + +struct mchp_ipc_rproc { + struct device *dev; + struct rproc *rproc; + struct mbox_chan *mbox_channel; + struct workqueue_struct *workqueue; + struct mbox_client mbox_client; + struct completion start_done; + struct work_struct rproc_work; + struct mchp_ipc_msg message; + void __iomem *rsc_table; + bool initialized; + u32 chan_id; +}; + +static struct mchp_ipc_rproc_mem_region mchp_rproc_mem_regions[] =3D { + [MCHP_IPC_RPROC_RSC_TABLE_REGION] =3D { + .name =3D "rsc-table", + .prefix =3D NULL, + }, + [MCHP_IPC_RPROC_FW_REGION] =3D { + .name =3D "firmware", + .prefix =3D NULL, + }, + [MCHP_IPC_RPROC_BUFF_REGION] =3D { + .name =3D "buffer", + .prefix =3D "vdev0", + }, + [MCHP_IPC_RPROC_VRING0_REGION] =3D { + .name =3D "vring0", + .prefix =3D "vdev0", + }, + [MCHP_IPC_RPROC_VRING1_REGION] =3D { + .name =3D "vring1", + .prefix =3D "vdev0", + }, +}; + +static int mchp_ipc_rproc_start(struct rproc *rproc) +{ + struct mchp_ipc_rproc *priv =3D rproc->priv; + struct sbiret ret; + + ret =3D sbi_ecall(SBI_EXT_MICROCHIP_TECHNOLOGY, SBI_EXT_RPROC_START, + priv->chan_id, rproc->bootaddr, 0, 0, 0, 0); + + if (ret.error) + return sbi_err_map_linux_errno(ret.error); + + if (!wait_for_completion_timeout(&priv->start_done, + msecs_to_jiffies(5000))) { + dev_err(priv->dev, "timeout waiting for ready notification\n"); + return -ETIMEDOUT; + } + + return 0; +} + +static int mchp_ipc_rproc_stop(struct rproc *rproc) +{ + struct mchp_ipc_rproc *priv =3D rproc->priv; + struct sbiret ret; + + ret =3D sbi_ecall(SBI_EXT_MICROCHIP_TECHNOLOGY, SBI_EXT_RPROC_STOP, + priv->chan_id, MCHP_IPC_RPROC_MBOX_STOP, 0, 0, 0, 0); + + if (ret.error) + return sbi_err_map_linux_errno(ret.error); + + return ret.value; +} + +static int mchp_ipc_rproc_mem_alloc(struct rproc *rproc, struct rproc_mem_= entry *mem) +{ + struct device *dev =3D rproc->dev.parent; + void *va; + + dev_dbg(dev, "map memory: %pad+%zx\n", &mem->dma, mem->len); + va =3D ioremap_wc(mem->dma, mem->len); + if (IS_ERR_OR_NULL(va)) { + dev_err(dev, "Unable to map memory region: %p+%zx\n", + &mem->dma, mem->len); + return -ENOMEM; + } + + mem->va =3D va; + + return 0; +} + +static int mchp_ipc_rproc_mem_release(struct rproc *rproc, + struct rproc_mem_entry *mem) +{ + dev_dbg(rproc->dev.parent, "unmap memory: %pad\n", &mem->dma); + iounmap(mem->va); + + return 0; +} + +static int mchp_ipc_rproc_prepare(struct rproc *rproc) +{ + struct mchp_ipc_rproc *priv =3D rproc->priv; + struct device_node *np =3D priv->dev->of_node; + struct rproc_mem_entry *mem; + struct resource res; + int i, ret; + + reinit_completion(&priv->start_done); + + for (i =3D 0; i < ARRAY_SIZE(mchp_rproc_mem_regions); i++) { + char *mem_region_name =3D devm_kstrdup(priv->dev, + mchp_rproc_mem_regions[i].name, GFP_KERNEL); + int index =3D of_property_match_string(np, "memory-region-names", mem_re= gion_name); + + if (index < 0) + continue; + + ret =3D of_reserved_mem_region_to_resource_byname(np, mem_region_name, &= res); + if (ret) + return ret; + + if (mchp_rproc_mem_regions[i].prefix) { + mem_region_name =3D devm_kasprintf(priv->dev, GFP_KERNEL, "%s%s", + mchp_rproc_mem_regions[i].prefix, + mem_region_name); + } + + if (i =3D=3D MCHP_IPC_RPROC_BUFF_REGION) { + mem =3D rproc_of_resm_mem_entry_init(priv->dev, index, resource_size(&r= es), + res.start, mem_region_name); + } else { + mem =3D rproc_mem_entry_init(priv->dev, NULL, + (dma_addr_t)res.start, + resource_size(&res), res.start, + mchp_ipc_rproc_mem_alloc, + mchp_ipc_rproc_mem_release, + mem_region_name); + } + rproc_add_carveout(rproc, mem); + } + + return 0; +} + +static int mchp_ipc_rproc_parse_fw(struct rproc *rproc, const struct firmw= are *fw) +{ + int ret; + + ret =3D rproc_elf_load_rsc_table(rproc, fw); + if (ret) + dev_info(&rproc->dev, "No resource table in elf\n"); + + return 0; +} + +static void mchp_ipc_rproc_kick(struct rproc *rproc, int vqid) +{ + struct mchp_ipc_rproc *priv =3D (struct mchp_ipc_rproc *)rproc->priv; + struct mchp_ipc_msg msg; + int ret; + + msg.buf =3D (void *)&vqid; + msg.size =3D sizeof(vqid); + + ret =3D mbox_send_message(priv->mbox_channel, (void *)&msg); + if (ret < 0) + dev_err(priv->dev, + "failed to send mbox message, status =3D %d\n", ret); +} + +static int mchp_ipc_rproc_attach(struct rproc *rproc) +{ + return 0; +} + +static struct resource_table +*mchp_ipc_rproc_get_loaded_rsc_table(struct rproc *rproc, size_t *table_sz) +{ + struct mchp_ipc_rproc *priv =3D rproc->priv; + + if (!priv->rsc_table) + return NULL; + + *table_sz =3D SZ_1K; + return (struct resource_table *)priv->rsc_table; +} + +static const struct rproc_ops mchp_ipc_rproc_ops =3D { + .prepare =3D mchp_ipc_rproc_prepare, + .start =3D mchp_ipc_rproc_start, + .get_loaded_rsc_table =3D mchp_ipc_rproc_get_loaded_rsc_table, + .attach =3D mchp_ipc_rproc_attach, + .stop =3D mchp_ipc_rproc_stop, + .kick =3D mchp_ipc_rproc_kick, + .load =3D rproc_elf_load_segments, + .parse_fw =3D mchp_ipc_rproc_parse_fw, + .find_loaded_rsc_table =3D rproc_elf_find_loaded_rsc_table, + .sanity_check =3D rproc_elf_sanity_check, + .get_boot_addr =3D rproc_elf_get_boot_addr, +}; + +static void mchp_ipc_rproc_vq_work(struct work_struct *work) +{ + struct mchp_ipc_rproc *priv =3D container_of(work, struct mchp_ipc_rproc,= rproc_work); + struct device *dev =3D priv->rproc->dev.parent; + + u32 msg =3D priv->message.buf[0]; + + /* + * Currently, we are expected to receive the following messages + * from the remote cluster: a ready message or receive the index + * of the triggered virtqueue as a payload. + * We can silently ignore any other type of mailbox messages since + * they are not meant for us and are meant to be received by the + * remote cluster only. + */ + switch (msg) { + case MCHP_IPC_RPROC_MBOX_READY: + complete(&priv->start_done); + break; + default: + if (msg >=3D MCHP_IPC_RPROC_MBOX_READY && msg < MCHP_IPC_RPROC_MBOX_END_= MSG) + return; + if (msg > priv->rproc->max_notifyid) { + dev_info(dev, "dropping unknown message 0x%x", msg); + return; + } + /* msg contains the index of the triggered vring */ + if (rproc_vq_interrupt(priv->rproc, msg) =3D=3D IRQ_NONE) + dev_dbg(dev, "no message was found in vqid %d\n", msg); + } +} + +static void mchp_ipc_rproc_rx_callback(struct mbox_client *mbox_client, vo= id *msg) +{ + struct rproc *rproc =3D dev_get_drvdata(mbox_client->dev); + struct mchp_ipc_rproc *priv =3D rproc->priv; + + priv->message =3D *(struct mchp_ipc_msg *)msg; + queue_work(priv->workqueue, &priv->rproc_work); +} + +static int mchp_ipc_rproc_mbox_init(struct rproc *rproc) +{ + struct mchp_ipc_rproc *priv =3D rproc->priv; + struct device *dev =3D priv->dev; + struct mchp_ipc_sbi_chan *chan_priv; + struct mbox_client *mbox_client; + + mbox_client =3D &priv->mbox_client; + mbox_client->dev =3D dev; + mbox_client->tx_block =3D true; + mbox_client->tx_tout =3D 100; + mbox_client->knows_txdone =3D false; + mbox_client->rx_callback =3D mchp_ipc_rproc_rx_callback; + + priv->mbox_channel =3D mbox_request_channel(mbox_client, 0); + if (IS_ERR(priv->mbox_channel)) + return dev_err_probe(mbox_client->dev, + PTR_ERR(priv->mbox_channel), + "failed to request mailbox channel\n"); + + chan_priv =3D (struct mchp_ipc_sbi_chan *)priv->mbox_channel->con_priv; + priv->chan_id =3D chan_priv->id; + + return 0; +} + +static int mchp_ipc_rproc_get_state(u32 chan) +{ + struct sbiret ret; + + ret =3D sbi_ecall(SBI_EXT_MICROCHIP_TECHNOLOGY, SBI_EXT_RPROC_STATE, + chan, 0, 0, 0, 0, 0); + + if (ret.error) + return sbi_err_map_linux_errno(ret.error); + + return ret.value; +} + +static int mchp_ipc_rproc_probe(struct platform_device *pdev) +{ + struct device *dev =3D &pdev->dev; + struct device_node *np =3D dev->of_node; + struct mchp_ipc_rproc *priv; + struct rproc *rproc; + struct resource res; + int num_rmems, ret; + + rproc =3D devm_rproc_alloc(dev, np->name, &mchp_ipc_rproc_ops, + NULL, sizeof(*priv)); + if (!rproc) + return -ENOMEM; + + priv =3D rproc->priv; + priv->rproc =3D rproc; + priv->dev =3D dev; + + num_rmems =3D of_property_count_elems_of_size(np, "memory-region", + sizeof(phandle)); + if (num_rmems < 1) + return dev_err_probe(dev, -EINVAL, + "device needs at least one memory regions to be defined\n"); + + ret =3D of_reserved_mem_region_to_resource_byname(np, "rsc-table", &res); + if (!ret) { + priv->rsc_table =3D devm_ioremap_resource(dev, &res); + if (IS_ERR(priv->rsc_table)) { + return dev_err_probe(dev, PTR_ERR(priv->rsc_table), + "failed to map resource table\n"); + } + } + + priv->workqueue =3D create_workqueue(dev_name(dev)); + if (!priv->workqueue) + return dev_err_probe(dev, -ENOMEM, "cannot create workqueue\n"); + + INIT_WORK(&priv->rproc_work, mchp_ipc_rproc_vq_work); + init_completion(&priv->start_done); + + ret =3D mchp_ipc_rproc_mbox_init(rproc); + if (ret) + goto err_put_wkq; + + /* + * Check if the remote cluster has been booted by another entity + * (i.e. bootloader) and set rproc state accordingly + */ + rproc->state =3D mchp_ipc_rproc_get_state(priv->chan_id); + if (ret < 0) { + dev_err_probe(dev, ret, "Couldn't get cluster boot mode\n"); + goto err_put_mbox; + } + + if (rproc->state !=3D RPROC_DETACHED) + rproc->auto_boot =3D false; + + /* error recovery is not supported at present */ + rproc->recovery_disabled =3D true; + + dev_set_drvdata(dev, rproc); + + ret =3D devm_rproc_add(dev, rproc); + if (ret) { + dev_err_probe(dev, ret, "rproc_add failed\n"); + goto err_put_mbox; + } + + return 0; + +err_put_mbox: + mbox_free_channel(priv->mbox_channel); +err_put_wkq: + destroy_workqueue(priv->workqueue); + + return ret; +} + +static void mchp_ipc_rproc_remove(struct platform_device *pdev) +{ + struct rproc *rproc =3D platform_get_drvdata(pdev); + struct mchp_ipc_rproc *priv =3D rproc->priv; + + mbox_free_channel(priv->mbox_channel); + destroy_workqueue(priv->workqueue); +} + +static const struct of_device_id mchp_ipc_rproc_of_match[] __maybe_unused = =3D { + { .compatible =3D "microchip,ipc-sbi-remoteproc", }, + {} +}; +MODULE_DEVICE_TABLE(of, mchp_ipc_rproc_of_match); + +static struct platform_driver mchp_ipc_rproc_driver =3D { + .probe =3D mchp_ipc_rproc_probe, + .remove =3D mchp_ipc_rproc_remove, + .driver =3D { + .name =3D "microchip-ipc-rproc", + .of_match_table =3D of_match_ptr(mchp_ipc_rproc_of_match), + }, +}; + +module_platform_driver(mchp_ipc_rproc_driver); + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Valentina Fernandez "); +MODULE_DESCRIPTION("Microchip IPC Remote Processor control driver"); --=20 2.34.1