From nobody Thu Dec 18 05:19:30 2025 Received: from mailgw02.mediatek.com (unknown [210.61.82.184]) (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 11D5C1459F7; Mon, 17 Mar 2025 11:03:39 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=210.61.82.184 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742209423; cv=none; b=GbTJNWGpEFH8Jqouw1YU7C72DQ4hXPc1B8w4sGycnJg6a2bOp/gFBsYACXAmnDX3LnxraUhyZbXapGDwpISAn7V/c2iecaSYkqErKV5ERGGnVSN0mezTykBBfa3ZrTNwJAIUJcK71rIzAtq/dBtp6cYxsEI7wvXlr4ze3/kGoTQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742209423; c=relaxed/simple; bh=fj1FE5NV2NNyngy7h9nxMOqaPIZ8/KKlYiSO5enXDlw=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=KZ1EJxEnWL6N9Cvkfw7fCopXjt1fe2OUv5fAuNwQlRD/okoSVQ8augdeYIBsaQCCxAtMsJV0yELiDospXUVF77khbE9tDNKwQNrR33OVBFYl5R4I1KL98KInLDXSvQ41r/HXQF+2YHPpromglwggsn6RM4tYa6sLZaL+fjY1pcA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=mediatek.com; spf=pass smtp.mailfrom=mediatek.com; dkim=pass (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b=udTMsGkC; arc=none smtp.client-ip=210.61.82.184 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=mediatek.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=mediatek.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="udTMsGkC" X-UUID: 793f9c32031f11f08eb9c36241bbb6fb-20250317 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=Content-Type:Content-Transfer-Encoding:MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:CC:To:From; bh=InaeS8/UkU8eLyrlVZZUnJa6Ghra5rWqfYuQwgP38JU=; b=udTMsGkCISTHhSSNkG3heTg16J3Gx/GP7LaaJDQqRiCD0ODwvoDw5QoXjDe8KuOKj2RpMNDsjzmilQxh+yZzbHhPViQGm6Wx27HDQwGoJVtmysUg733E4pU39mO+92+AxvIRCzSn3PgtjTTGEr23GaSmWBsifHO9QOzFB5+vvz8=; X-CID-P-RULE: Release_Ham X-CID-O-INFO: VERSION:1.2.1,REQID:cba0e340-bb2b-4653-889c-d87e45ca336f,IP:0,UR L:0,TC:0,Content:0,EDM:0,RT:0,SF:0,FILE:0,BULK:0,RULE:Release_Ham,ACTION:r elease,TS:0 X-CID-META: VersionHash:0ef645f,CLOUDID:84f870c6-16da-468a-87f7-8ca8d6b3b9f7,B ulkID:nil,BulkQuantity:0,Recheck:0,SF:81|82|102,TC:nil,Content:0|50,EDM:-3 ,IP:nil,URL:0,File:nil,RT:nil,Bulk:nil,QS:nil,BEC:nil,COL:0,OSI:0,OSA:0,AV :0,LES:1,SPR:NO,DKR:0,DKP:0,BRR:0,BRE:0,ARC:0 X-CID-BVR: 0,NGT X-CID-BAS: 0,NGT,0,_ X-CID-FACTOR: TF_CID_SPAM_SNR X-UUID: 793f9c32031f11f08eb9c36241bbb6fb-20250317 Received: from mtkmbs10n2.mediatek.inc [(172.21.101.183)] by mailgw02.mediatek.com (envelope-from ) (Generic MTA with TLSv1.2 ECDHE-RSA-AES256-GCM-SHA384 256/256) with ESMTP id 1409398073; Mon, 17 Mar 2025 19:03:36 +0800 Received: from mtkmbs11n2.mediatek.inc (172.21.101.187) by mtkmbs11n1.mediatek.inc (172.21.101.185) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1258.39; Mon, 17 Mar 2025 19:03:35 +0800 Received: from mhfsdcap04.gcn.mediatek.inc (10.17.3.154) by mtkmbs11n2.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.2.1258.39 via Frontend Transport; Mon, 17 Mar 2025 19:03:34 +0800 From: Jjian Zhou To: Jassi Brar , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Matthias Brugger , AngeloGioacchino Del Regno CC: , , , , , Chen-Yu Tsai , Jjian Zhou Subject: [PATCH RFC v3 1/3] mailbox: mediatek: Add mtk-vcp-mailbox driver Date: Mon, 17 Mar 2025 19:03:23 +0800 Message-ID: <20250317110331.2776-2-jjian.zhou@mediatek.com> X-Mailer: git-send-email 2.46.0 In-Reply-To: <20250317110331.2776-1-jjian.zhou@mediatek.com> References: <20250317110331.2776-1-jjian.zhou@mediatek.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 X-MTK: N Content-Type: text/plain; charset="utf-8" Add mtk-vcp-mailbox driver to support the communication with VCP remote microprocessor. Signed-off-by: Jjian Zhou --- drivers/mailbox/Kconfig | 9 ++ drivers/mailbox/Makefile | 2 + drivers/mailbox/mtk-vcp-mailbox.c | 179 ++++++++++++++++++++++++ include/linux/mailbox/mtk-vcp-mailbox.h | 34 +++++ 4 files changed, 224 insertions(+) create mode 100644 drivers/mailbox/mtk-vcp-mailbox.c create mode 100644 include/linux/mailbox/mtk-vcp-mailbox.h diff --git a/drivers/mailbox/Kconfig b/drivers/mailbox/Kconfig index ed52db272f4d..ffc4a5491462 100644 --- a/drivers/mailbox/Kconfig +++ b/drivers/mailbox/Kconfig @@ -275,6 +275,15 @@ config MTK_CMDQ_MBOX critical time limitation, such as updating display configuration during the vblank. =20 +config MTK_VCP_MBOX + tristate "MediaTek VCP Mailbox Support" + depends on ARCH_MEDIATEK || COMPILE_TEST + help + Say yes here to add support for the MediaTek VCP mailbox driver. + The mailbox implementation provides access from the application + processor to the MediaTek Video Processing Unit. + If unsure say N. + config ZYNQMP_IPI_MBOX tristate "Xilinx ZynqMP IPI Mailbox" depends on ARCH_ZYNQMP && OF diff --git a/drivers/mailbox/Makefile b/drivers/mailbox/Makefile index 9a1542b55539..75a200a9d2d2 100644 --- a/drivers/mailbox/Makefile +++ b/drivers/mailbox/Makefile @@ -59,6 +59,8 @@ obj-$(CONFIG_MTK_ADSP_MBOX) +=3D mtk-adsp-mailbox.o =20 obj-$(CONFIG_MTK_CMDQ_MBOX) +=3D mtk-cmdq-mailbox.o =20 +obj-$(CONFIG_MTK_VCP_MBOX) +=3D mtk-vcp-mailbox.o + obj-$(CONFIG_ZYNQMP_IPI_MBOX) +=3D zynqmp-ipi-mailbox.o =20 obj-$(CONFIG_SUN6I_MSGBOX) +=3D sun6i-msgbox.o diff --git a/drivers/mailbox/mtk-vcp-mailbox.c b/drivers/mailbox/mtk-vcp-ma= ilbox.c new file mode 100644 index 000000000000..fd7a123c71c8 --- /dev/null +++ b/drivers/mailbox/mtk-vcp-mailbox.c @@ -0,0 +1,179 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2025 MediaTek Corporation. All rights reserved. + * Author: Jjian Zhou + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +struct mtk_vcp_mbox_priv { + void __iomem *base; + struct device *dev; + struct mbox_controller mbox; + const struct mtk_vcp_mbox_cfg *cfg; + struct mtk_ipi_info ipi_recv; +}; + +struct mtk_vcp_mbox_cfg { + u32 set_in; + u32 clr_out; +}; + +static inline struct mtk_vcp_mbox_priv *get_mtk_vcp_mbox_priv(struct mbox_= controller *mbox) +{ + return container_of(mbox, struct mtk_vcp_mbox_priv, mbox); +} + +static irqreturn_t mtk_vcp_mbox_irq_thread(int irq, void *data) +{ + struct mbox_chan *chan =3D data; + struct mtk_vcp_mbox_priv *priv =3D get_mtk_vcp_mbox_priv(chan->mbox); + + /* get irq status */ + priv->ipi_recv.irq_status =3D readl(priv->base + priv->cfg->clr_out); + + __ioread32_copy(priv->ipi_recv.msg, priv->base, MAX_SLOT_NUM); + + mbox_chan_received_data(chan, &priv->ipi_recv); + + /* clear irq status */ + writel(priv->ipi_recv.irq_status, priv->base + priv->cfg->clr_out); + + return IRQ_HANDLED; +} + +static struct mbox_chan *mtk_vcp_mbox_xlate(struct mbox_controller *mbox, + const struct of_phandle_args *sp) +{ + if (sp->args_count) + return NULL; + + return mbox->chans; +} + +static int mtk_vcp_mbox_send_data(struct mbox_chan *chan, void *data) +{ + struct mtk_vcp_mbox_priv *priv =3D get_mtk_vcp_mbox_priv(chan->mbox); + struct mtk_ipi_info *ipi_info =3D data; + u32 status; + + if (!ipi_info->msg) { + dev_err(priv->dev, "msg buffer is NULL.\n"); + return -ENOMEM; + } + + status =3D readl(priv->base + priv->cfg->set_in) & BIT(ipi_info->index); + if (status) { + dev_err(priv->dev, "mailbox IPI %d is busy.\n", ipi_info->id); + return -EBUSY; + } + + if (ipi_info->slot_ofs + ipi_info->len > MBOX_SLOT_MAX_SIZE) + return -EINVAL; + __iowrite32_copy(priv->base + ipi_info->slot_ofs, ipi_info->msg, + ipi_info->len); + + writel(BIT(ipi_info->index), priv->base + priv->cfg->set_in); + + return 0; +} + +static bool mtk_vcp_mbox_last_tx_done(struct mbox_chan *chan) +{ + struct mtk_ipi_info *ipi_info =3D chan->active_req; + struct mtk_vcp_mbox_priv *priv =3D get_mtk_vcp_mbox_priv(chan->mbox); + u32 op; + + op =3D readl(priv->base + priv->cfg->set_in) & BIT(ipi_info->index); + return !op; +} + +static const struct mbox_chan_ops mtk_vcp_mbox_chan_ops =3D { + .send_data =3D mtk_vcp_mbox_send_data, + .last_tx_done =3D mtk_vcp_mbox_last_tx_done, +}; + +static int mtk_vcp_mbox_probe(struct platform_device *pdev) +{ + struct device *dev =3D &pdev->dev; + struct mtk_vcp_mbox_priv *priv; + struct mbox_controller *mbox; + int ret, irq; + + priv =3D devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); + if (!priv) + return -ENOMEM; + + priv->dev =3D dev; + mbox =3D &priv->mbox; + mbox->dev =3D dev; + mbox->ops =3D &mtk_vcp_mbox_chan_ops; + mbox->txdone_irq =3D false; + mbox->txdone_poll =3D true; + mbox->of_xlate =3D mtk_vcp_mbox_xlate; + mbox->num_chans =3D 1; + mbox->chans =3D devm_kzalloc(dev, sizeof(*mbox->chans), GFP_KERNEL); + if (!mbox->chans) + return -ENOMEM; + + priv->ipi_recv.msg =3D devm_kzalloc(dev, sizeof(u8) * MBOX_SLOT_MAX_SIZE, + GFP_KERNEL); + if (!priv->ipi_recv.msg) + return -ENOMEM; + + priv->base =3D devm_platform_ioremap_resource(pdev, 0); + if (IS_ERR(priv->base)) + return PTR_ERR(priv->base); + + priv->cfg =3D of_device_get_match_data(dev); + if (!priv->cfg) + return -EINVAL; + + irq =3D platform_get_irq(pdev, 0); + if (irq < 0) + return irq; + + ret =3D devm_request_threaded_irq(dev, irq, NULL, + mtk_vcp_mbox_irq_thread, IRQF_ONESHOT, + dev_name(dev), mbox->chans); + if (ret < 0) + return ret; + + platform_set_drvdata(pdev, priv); + + dev_dbg(dev, "MTK VCP mailbox initialized\n"); + + return devm_mbox_controller_register(dev, &priv->mbox); +} + +static const struct mtk_vcp_mbox_cfg mt8196_cfg =3D { + .set_in =3D 0x100, + .clr_out =3D 0x10C, +}; + +static const struct of_device_id mtk_vcp_mbox_of_match[] =3D { + { .compatible =3D "mediatek,mt8196-vcp-mbox", .data =3D &mt8196_cfg }, + {}, +}; +MODULE_DEVICE_TABLE(of, mtk_vcp_mbox_of_match); + +static struct platform_driver mtk_vcp_mbox_driver =3D { + .probe =3D mtk_vcp_mbox_probe, + .driver =3D { + .name =3D "mtk_vcp_mbox", + .of_match_table =3D mtk_vcp_mbox_of_match, + }, +}; +module_platform_driver(mtk_vcp_mbox_driver); + +MODULE_AUTHOR("Jjian Zhou "); +MODULE_DESCRIPTION("MTK VCP Mailbox Controller"); +MODULE_LICENSE("GPL"); diff --git a/include/linux/mailbox/mtk-vcp-mailbox.h b/include/linux/mailbo= x/mtk-vcp-mailbox.h new file mode 100644 index 000000000000..953499b7cfeb --- /dev/null +++ b/include/linux/mailbox/mtk-vcp-mailbox.h @@ -0,0 +1,34 @@ +/* SPDX-License-Identifier: (GPL-2.0 OR MIT) */ +/* + * Copyright (c) 2024 MediaTek Inc. + */ + +#ifndef __MTK_VCP_MAILBOX_H__ +#define __MTK_VCP_MAILBOX_H__ + +#define MBOX_SLOT_MAX_SIZE 0x100 /* mbox max slot size */ +#define MAX_SLOT_NUM 64 + +/** + * struct mtk_ipi_info - channel table that belong to mtk_ipi_device + * @msg: The share buffer between IPC and mailbox driver + * @len: Message length + * @id: IPI number + * @recv_opt: Recv option, 0:receive ,1: response + * @index: The pin groups number of the mailbox channel + * @slot_ofs: Slot offset of the mailbox channel + * @irq_status: Indicate which pin groups triggered the interrupt + * + * It is used between IPC with mailbox driver. + */ +struct mtk_ipi_info { + void *msg; + u32 len; + u32 id; + u32 recv_opt; + u32 index; + u32 slot_ofs; + u32 irq_status; +}; + +#endif --=20 2.45.2 From nobody Thu Dec 18 05:19:30 2025 Received: from mailgw01.mediatek.com (unknown [60.244.123.138]) (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 D48DC23816F; Mon, 17 Mar 2025 11:03:45 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=60.244.123.138 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742209428; cv=none; b=OhSPu6Q/+sxI4bpidp0chtPyTGP1daf2tUNFDM84p1kI+W49ZwMg7EWcx1EHzYSaIBqArfW4eQjR3KkySp+IBPTHojqYshtODS4XpkbNv4ytoPhm2pRg7YF9tvpFyXJcfyHrIzM+lZVPq0d0Isf/vohd6tBGtCBL56+mBErPbRo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742209428; c=relaxed/simple; bh=HEpc7JIvk72vctzHAfJT3CPmFQXnw7VrjOURa7esXFc=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=tyvDzvllnrdEhDqcBabxP6l4mrOuXasD3PRzfcmSTNch6lMW9gHt4VL4VQ3R+EkS5o22P+aCJGu3TllRKyr9Z8WoCH1kg15QhB87cfEzKpTBZc8HxyG109hze7EDr7GaZV9/irFbpruSyp5MWY7XeIZIos7rGSU4Y+xqkB8/qIE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=mediatek.com; spf=pass smtp.mailfrom=mediatek.com; dkim=pass (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b=QPF8oICe; arc=none smtp.client-ip=60.244.123.138 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=mediatek.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=mediatek.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="QPF8oICe" X-UUID: 7a4673a8031f11f0aae1fd9735fae912-20250317 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=Content-Type:Content-Transfer-Encoding:MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:CC:To:From; bh=eVHnTPYD1NqFriz6eCLRMpMNlPKKVwGPxqrltINJC1o=; b=QPF8oICeDWcM+vCIN4NcXl9Wx6VKf2tOhlPR4xEWxG8YssZJsh5V4pYtm5IzonowY5RVloC2cVSbihJG/7YbRVqq60IjVx+8lQOG5d1zV9oLYXXV+6oAXC6Sq8rLJjpXT9R+C7vG6RWJChAvY6JVr5b7vIoNxX5AVxX29sWMqcY=; X-CID-P-RULE: Release_Ham X-CID-O-INFO: VERSION:1.2.1,REQID:8c551dc5-ce1a-4786-9388-7bd197856c36,IP:0,UR L:0,TC:0,Content:0,EDM:0,RT:0,SF:0,FILE:0,BULK:0,RULE:Release_Ham,ACTION:r elease,TS:0 X-CID-META: VersionHash:0ef645f,CLOUDID:5c8c798c-f5b8-47d5-8cf3-b68fe7530c9a,B ulkID:nil,BulkQuantity:0,Recheck:0,SF:81|82|102,TC:nil,Content:0|50,EDM:-3 ,IP:nil,URL:0,File:nil,RT:nil,Bulk:nil,QS:nil,BEC:nil,COL:0,OSI:0,OSA:0,AV :0,LES:1,SPR:NO,DKR:0,DKP:0,BRR:0,BRE:0,ARC:0 X-CID-BVR: 0,NGT X-CID-BAS: 0,NGT,0,_ X-CID-FACTOR: TF_CID_SPAM_SNR X-UUID: 7a4673a8031f11f0aae1fd9735fae912-20250317 Received: from mtkmbs09n2.mediatek.inc [(172.21.101.94)] by mailgw01.mediatek.com (envelope-from ) (Generic MTA with TLSv1.2 ECDHE-RSA-AES256-GCM-SHA384 256/256) with ESMTP id 1981424841; Mon, 17 Mar 2025 19:03:37 +0800 Received: from mtkmbs11n2.mediatek.inc (172.21.101.187) by MTKMBS14N1.mediatek.inc (172.21.101.75) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1258.39; Mon, 17 Mar 2025 19:03:36 +0800 Received: from mhfsdcap04.gcn.mediatek.inc (10.17.3.154) by mtkmbs11n2.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.2.1258.39 via Frontend Transport; Mon, 17 Mar 2025 19:03:36 +0800 From: Jjian Zhou To: Jassi Brar , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Matthias Brugger , AngeloGioacchino Del Regno CC: , , , , , Chen-Yu Tsai , Jjian Zhou Subject: [PATCH RFC v3 2/3] firmware: mediatek: Add vcp ipc protocol interface Date: Mon, 17 Mar 2025 19:03:24 +0800 Message-ID: <20250317110331.2776-3-jjian.zhou@mediatek.com> X-Mailer: git-send-email 2.46.0 In-Reply-To: <20250317110331.2776-1-jjian.zhou@mediatek.com> References: <20250317110331.2776-1-jjian.zhou@mediatek.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 X-MTK: N Content-Type: text/plain; charset="utf-8" Some of mediatek processors contain the Risc-V coprocessor. The communication between Host CPU and vcp firmware is taking place using a shared memory area for message passing. VCP IPC protocol offers (send/recv) interfaces using mediatek-mailbox APIs. Signed-off-by: Jjian Zhou --- drivers/firmware/Kconfig | 9 + drivers/firmware/Makefile | 1 + drivers/firmware/mtk-vcp-ipc.c | 481 ++++++++++++++++++ include/linux/firmware/mediatek/mtk-vcp-ipc.h | 151 ++++++ 4 files changed, 642 insertions(+) create mode 100644 drivers/firmware/mtk-vcp-ipc.c create mode 100644 include/linux/firmware/mediatek/mtk-vcp-ipc.h diff --git a/drivers/firmware/Kconfig b/drivers/firmware/Kconfig index 37e43f287e78..98c4ff667836 100644 --- a/drivers/firmware/Kconfig +++ b/drivers/firmware/Kconfig @@ -179,6 +179,15 @@ config MTK_ADSP_IPC ADSP exists on some mtk processors. Client might use shared memory to exchange information with ADSP. =20 +config MTK_VCP_IPC + tristate "MTK VCP IPC Protocol driver" + depends on MTK_VCP_MBOX + help + Say yes here to add support for the MediaTek VCP IPC + between host AP (Linux) and the firmware running on VCP. + VCP exists on some mtk processors. + Client might use shared memory to exchange information with VCP. + config SYSFB bool select BOOT_VESA_SUPPORT diff --git a/drivers/firmware/Makefile b/drivers/firmware/Makefile index 91efcc868a05..2b9894e5169a 100644 --- a/drivers/firmware/Makefile +++ b/drivers/firmware/Makefile @@ -14,6 +14,7 @@ obj-$(CONFIG_ISCSI_IBFT_FIND) +=3D iscsi_ibft_find.o obj-$(CONFIG_ISCSI_IBFT) +=3D iscsi_ibft.o obj-$(CONFIG_FIRMWARE_MEMMAP) +=3D memmap.o obj-$(CONFIG_MTK_ADSP_IPC) +=3D mtk-adsp-ipc.o +obj-$(CONFIG_MTK_VCP_IPC) +=3D mtk-vcp-ipc.o obj-$(CONFIG_RASPBERRYPI_FIRMWARE) +=3D raspberrypi.o obj-$(CONFIG_FW_CFG_SYSFS) +=3D qemu_fw_cfg.o obj-$(CONFIG_SYSFB) +=3D sysfb.o diff --git a/drivers/firmware/mtk-vcp-ipc.c b/drivers/firmware/mtk-vcp-ipc.c new file mode 100644 index 000000000000..744937c56b67 --- /dev/null +++ b/drivers/firmware/mtk-vcp-ipc.c @@ -0,0 +1,481 @@ +// SPDX-License-Identifier: (GPL-2.0 OR MIT) +/* + * Copyright (c) 2024 MediaTek Inc. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/** + * struct mtk_ipi_chan_table - channel table that belong to mtk_ipi_device + * @mbox: the mbox channel number + * @mbox_pin_cb: callback function + * @holder: keep 1 if there are ipi waiters (to wait the reply) + * @ipi_record: timestamp of each ipi transmission stage + * @pin_buf: buffer point + * @prdata: private data + * @recv_opt: recv option, 0:receive ,1: response + * @notify: completion notify process + * @send_ofs: message offset in the slots of a mbox + * @send_index: bit offset in the mbox + * @msg_zie: slot size of the ipi message + * + * All of these data should be initialized by mtk_ipi_device_register() + */ +struct mtk_ipi_chan_table { + u32 mbox; + mbox_pin_cb_t mbox_pin_cb; + atomic_t holder; + void *pin_buf; + void *prdata; + u32 recv_opt; + struct completion notify; + /* define a mutex for remote response */ + struct mutex mutex_send; + u32 send_ofs; + u32 send_index; + u32 msg_size; +}; + +/** + * mbox information + * + * @mbdev: mbox device + * @mbox_id: mbox id + * @slot: how many slots that mbox used + * @opt: option for tx mode, 0:mbox, 1:share memory 2:queue + * @base: mbox base address + * @mbox_client: mbox client + * @mbox_chan: mbox channel + */ +struct mtk_mbox_info { + struct mtk_vcp_ipc *vcp_ipc; + u32 mbox_id; + u32 slot; + u32 opt; + /* lock of mbox */ + spinlock_t mbox_lock; + struct mbox_client cl; + struct mbox_chan *ch; + struct mtk_ipi_info ipi_info; +}; + +static const char * const mbox_names[VCP_MBOX_NUM] =3D { + "mbox0", "mbox1", "mbox2", "mbox3", "mbox4" +}; + +/** + * mtk_vcp_ipc_recv - recv callback used by MTK VCP mailbox + * + * @c: mbox client + * @msg: message received + * + * Users of VCP IPC will need to provide handle_reply and handle_request + * callbacks. + */ +static void mtk_vcp_ipc_recv(struct mbox_client *c, void *msg) +{ + struct mtk_mbox_info *minfo =3D container_of(c, struct mtk_mbox_info, cl); + struct mtk_vcp_ipc *vcp_ipc =3D minfo->vcp_ipc; + struct mtk_ipi_info *ipi_info =3D msg; + struct mtk_ipi_device *ipidev =3D vcp_ipc->ipi_priv; + struct mtk_ipi_chan_table *table; + struct mtk_mbox_recv_table *mbox_recv; + u32 id; + + /* execute all receive pin handler */ + for (id =3D 0; id < vcp_ipc->mbdev->recv_count; id++) { + mbox_recv =3D &vcp_ipc->mbdev->recv_table[id]; + if (mbox_recv->mbox_id !=3D minfo->mbox_id) + continue; + + if (!(BIT(mbox_recv->pin_index) & ipi_info->irq_status)) + continue; + + table =3D &ipidev->table[mbox_recv->ipi_id]; + if (!table->pin_buf) { + dev_err(vcp_ipc->dev, "IPI%d buf is null.\n", + mbox_recv->ipi_id); + continue; + } + + memcpy(table->pin_buf, + ipi_info->msg + mbox_recv->offset * MBOX_SLOT_SIZE, + mbox_recv->msg_size * MBOX_SLOT_SIZE); + + if (!mbox_recv->recv_opt && table->mbox_pin_cb) + table->mbox_pin_cb(mbox_recv->ipi_id, + table->prdata, + table->pin_buf, + mbox_recv->msg_size * MBOX_SLOT_SIZE); + + /* notify task */ + if (table->recv_opt =3D=3D MBOX_RECV_MESSAGE || + atomic_read(&table->holder)) + complete(&table->notify); + } +} + +/* + * mtk_vcp_ipc_send - send ipc command to MTK VCP + * + * @ipidev: VCP struct mtk_ipi_device handle + * @id: id of the feature IPI + * @data: message address + * @len: message length + * + * Return: Zero for success from mbox_send_message + * negative value for error + */ +int mtk_vcp_ipc_send(struct mtk_ipi_device *ipidev, u32 id, void *data, u3= 2 len) +{ + struct device *dev; + struct mtk_mbox_info *minfo; + struct mtk_ipi_chan_table *table; + struct mtk_vcp_ipc *vcp_ipc; + int ret; + + if (!ipidev || !ipidev->ipi_inited || !data) + return IPI_UNAVAILABLE; + vcp_ipc =3D ipidev->vcp_ipc; + if (!vcp_ipc) + return IPI_UNAVAILABLE; + + table =3D ipidev->table; + dev =3D ipidev->vcp_ipc->dev; + minfo =3D &ipidev->vcp_ipc->info_table[table[id].mbox]; + if (!minfo) { + dev_err(dev, "%s IPI%d minfo is invalid.\n", ipidev->name, id); + return IPI_UNAVAILABLE; + } + + if (len > table[id].msg_size) + return IPI_MSG_TOO_BIG; + else if (!len) + len =3D table[id].msg_size; + + mutex_lock(&table[id].mutex_send); + + minfo->ipi_info.msg =3D data; + minfo->ipi_info.len =3D len; + minfo->ipi_info.id =3D id; + minfo->ipi_info.index =3D table[id].send_index; + minfo->ipi_info.slot_ofs =3D table[id].send_ofs * MBOX_SLOT_SIZE; + + ret =3D mbox_send_message(minfo->ch, &minfo->ipi_info); + mutex_unlock(&table[id].mutex_send); + if (ret < 0) { + dev_err(dev, "%s IPI%d send failed.\n", ipidev->name, id); + return IPI_MBOX_ERR; + } + + return IPI_ACTION_DONE; +} +EXPORT_SYMBOL(mtk_vcp_ipc_send); + +/* + * mtk_vcp_ipc_send_compl - send ipc command to MTK VCP + * + * @ipidev: VCP struct mtk_ipi_device handle + * @id: id of the feature IPI + * @data: message address + * @len: message length + * @timeout_ms: + * + * Return: Zero for success from mbox_send_message + * negative value for error + */ +int mtk_vcp_ipc_send_compl(struct mtk_ipi_device *ipidev, u32 id, + void *data, u32 len, u32 timeout_ms) +{ + struct device *dev; + struct mtk_mbox_info *minfo; + struct mtk_ipi_chan_table *table; + struct mtk_vcp_ipc *vcp_ipc; + int ret; + + if (!ipidev || !ipidev->ipi_inited || !data) + return IPI_UNAVAILABLE; + vcp_ipc =3D ipidev->vcp_ipc; + if (!vcp_ipc) + return IPI_UNAVAILABLE; + + table =3D ipidev->table; + dev =3D ipidev->vcp_ipc->dev; + minfo =3D &ipidev->vcp_ipc->info_table[table[id].mbox]; + if (!minfo) { + dev_err(dev, "%s IPI%d minfo is invalid.\n", ipidev->name, id); + return IPI_UNAVAILABLE; + } + + if (len > table[id].msg_size) + return IPI_MSG_TOO_BIG; + else if (!len) + len =3D table[id].msg_size; + + mutex_lock(&table[id].mutex_send); + + minfo->ipi_info.msg =3D data; + minfo->ipi_info.len =3D len; + minfo->ipi_info.id =3D id; + minfo->ipi_info.index =3D table[id].send_index; + minfo->ipi_info.slot_ofs =3D table[id].send_ofs * MBOX_SLOT_SIZE; + + atomic_inc(&table[id].holder); + + ret =3D mbox_send_message(minfo->ch, &minfo->ipi_info); + if (ret < 0) { + atomic_set(&table[id].holder, 0); + mutex_unlock(&table[id].mutex_send); + dev_err(dev, "%s IPI%d send failed.\n", ipidev->name, id); + return IPI_MBOX_ERR; + } + + /* wait for completion */ + ret =3D wait_for_completion_timeout(&table[id].notify, + msecs_to_jiffies(timeout_ms)); + atomic_set(&table[id].holder, 0); + if (ret > 0) + ret =3D IPI_ACTION_DONE; + + mutex_unlock(&table[id].mutex_send); + + return ret; +} +EXPORT_SYMBOL(mtk_vcp_ipc_send_compl); + +int mtk_vcp_mbox_ipc_register(struct mtk_ipi_device *ipidev, int id, + mbox_pin_cb_t cb, void *prdata, void *msg) +{ + if (!ipidev || !ipidev->ipi_inited) + return IPI_DEV_ILLEGAL; + if (!msg) + return IPI_NO_MSGBUF; + + if (ipidev->table[id].pin_buf) + return IPI_ALREADY_USED; + ipidev->table[id].mbox_pin_cb =3D cb; + ipidev->table[id].pin_buf =3D msg; + ipidev->table[id].prdata =3D prdata; + + return IPI_ACTION_DONE; +} +EXPORT_SYMBOL(mtk_vcp_mbox_ipc_register); + +int mtk_vcp_mbox_ipc_unregister(struct mtk_ipi_device *ipidev, int id) +{ + if (!ipidev || !ipidev->ipi_inited) + return IPI_DEV_ILLEGAL; + + /* Drop the ipi and reset the record */ + complete(&ipidev->table[id].notify); + + ipidev->table[id].mbox_pin_cb =3D NULL; + ipidev->table[id].pin_buf =3D NULL; + ipidev->table[id].prdata =3D NULL; + + return IPI_ACTION_DONE; +} +EXPORT_SYMBOL(mtk_vcp_mbox_ipc_unregister); + +static void mtk_fill_in_entry(struct mtk_ipi_chan_table *entry, const u32 = ipi_id, + const struct mtk_mbox_table *mbdev) +{ + const struct mtk_mbox_send_table *mbox_send =3D mbdev->send_table; + u32 index; + + for (index =3D 0; index < mbdev->send_count; index++) { + if (ipi_id !=3D mbox_send[index].ipi_id) + continue; + + entry->send_ofs =3D mbox_send[index].offset; + entry->send_index =3D mbox_send[index].pin_index; + entry->msg_size =3D mbox_send[index].msg_size; + entry->mbox =3D mbox_send[index].mbox_id; + return; + } + + entry->mbox =3D -ENOENT; +} + +int mtk_vcp_ipc_device_register(struct mtk_ipi_device *ipidev, + u32 ipi_chan_count, struct mtk_vcp_ipc *vcp_ipc) +{ + struct mtk_ipi_chan_table *ipi_chan_table; + struct mtk_mbox_table *mbdev; + u32 index; + + if (!vcp_ipc || !ipidev) + return -EINVAL; + + ipi_chan_table =3D kcalloc(ipi_chan_count, + sizeof(struct mtk_ipi_chan_table), GFP_KERNEL); + if (!ipi_chan_table) + return -ENOMEM; + + mbdev =3D vcp_ipc->mbdev; + vcp_ipc->ipi_priv =3D (void *)ipidev; + ipidev->table =3D ipi_chan_table; + ipidev->vcp_ipc =3D vcp_ipc; + + for (index =3D 0; index < ipi_chan_count; index++) { + atomic_set(&ipi_chan_table[index].holder, 0); + mutex_init(&ipi_chan_table[index].mutex_send); + init_completion(&ipi_chan_table[index].notify); + mtk_fill_in_entry(&ipi_chan_table[index], index, mbdev); + } + + ipidev->ipi_inited =3D 1; + + dev_dbg(vcp_ipc->dev, "%s (with %d IPI) has registered.\n", + ipidev->name, ipi_chan_count); + + return IPI_ACTION_DONE; +} +EXPORT_SYMBOL(mtk_vcp_ipc_device_register); + +static int setup_mbox_table(struct mtk_mbox_table *mbdev, u32 mbox) +{ + struct mtk_mbox_send_table *mbox_send =3D &mbdev->send_table[0]; + struct mtk_mbox_recv_table *mbox_recv =3D &mbdev->recv_table[0]; + u32 i, last_ofs =3D 0, last_idx =3D 0, last_slot =3D 0, last_sz =3D 0; + + for (i =3D 0; i < mbdev->send_count; i++) { + if (mbox =3D=3D mbox_send[i].mbox_id) { + mbox_send[i].offset =3D last_ofs + last_slot; + mbox_send[i].pin_index =3D last_idx + last_sz; + last_idx =3D mbox_send[i].pin_index; + last_sz =3D DIV_ROUND_UP(mbox_send[i].msg_size, MBOX_SLOT_ALIGN); + last_ofs =3D last_sz * MBOX_SLOT_ALIGN; + last_slot =3D last_idx * MBOX_SLOT_ALIGN; + } else if (mbox < mbox_send[i].mbox_id) { + /* no need to search the rest id */ + break; + } + } + + for (i =3D 0; i < mbdev->recv_count; i++) { + if (mbox =3D=3D mbox_recv[i].mbox_id) { + mbox_recv[i].offset =3D last_ofs + last_slot; + mbox_recv[i].pin_index =3D last_idx + last_sz; + last_idx =3D mbox_recv[i].pin_index; + last_sz =3D DIV_ROUND_UP(mbox_recv[i].msg_size, MBOX_SLOT_ALIGN); + last_ofs =3D last_sz * MBOX_SLOT_ALIGN; + last_slot =3D last_idx * MBOX_SLOT_ALIGN; + } else if (mbox < mbox_recv[i].mbox_id) { + /* no need to search the rest id */ + break; + } + } + + if (last_idx > MBOX_MAX_PIN || (last_ofs + last_slot) > MAX_SLOT_NUM) + return -EINVAL; + + return 0; +} + +static int mtk_vcp_ipc_probe(struct platform_device *pdev) +{ + struct device *dev =3D &pdev->dev; + struct mtk_vcp_ipc *vcp_ipc; + struct mbox_client *cl; + struct mtk_mbox_info *minfo; + int ret; + u32 mbox, i; + struct mtk_mbox_table *mbox_data =3D dev_get_platdata(dev); + + device_set_of_node_from_dev(&pdev->dev, pdev->dev.parent); + + vcp_ipc =3D devm_kzalloc(dev, sizeof(*vcp_ipc), GFP_KERNEL); + if (!vcp_ipc) + return -ENOMEM; + + if (!mbox_data) { + dev_err(dev, "No platform data available\n"); + return -EINVAL; + } + vcp_ipc->mbdev =3D mbox_data; + + /* alloc and init mmup_mbox_info */ + vcp_ipc->info_table =3D vzalloc(sizeof(*vcp_ipc->info_table) * VCP_MBOX_N= UM); + if (!vcp_ipc->info_table) + return -ENOMEM; + + /* create mbox dev */ + for (mbox =3D 0; mbox < VCP_MBOX_NUM; mbox++) { + minfo =3D &vcp_ipc->info_table[mbox]; + minfo->mbox_id =3D mbox; + minfo->vcp_ipc =3D vcp_ipc; + spin_lock_init(&minfo->mbox_lock); + + ret =3D setup_mbox_table(vcp_ipc->mbdev, mbox); + if (ret) + return ret; + + cl =3D &minfo->cl; + cl->dev =3D &pdev->dev; + cl->tx_block =3D false; + cl->knows_txdone =3D false; + cl->tx_prepare =3D NULL; + cl->rx_callback =3D mtk_vcp_ipc_recv; + minfo->ch =3D mbox_request_channel_byname(cl, mbox_names[mbox]); + if (IS_ERR(minfo->ch)) { + ret =3D PTR_ERR(minfo->ch); + if (ret !=3D -EPROBE_DEFER) + dev_err(dev, "Failed to request mbox channel %s ret %d\n", + mbox_names[mbox], ret); + + for (i =3D 0; i < mbox; i++) { + minfo =3D &vcp_ipc->info_table[i]; + mbox_free_channel(minfo->ch); + } + + vfree(vcp_ipc->info_table); + return ret; + } + } + + vcp_ipc->dev =3D dev; + dev_set_drvdata(dev, vcp_ipc); + dev_dbg(dev, "MTK VCP IPC initialized\n"); + + return 0; +} + +static void mtk_vcp_ipc_remove(struct platform_device *pdev) +{ + struct mtk_vcp_ipc *vcp_ipc =3D dev_get_drvdata(&pdev->dev); + struct mtk_mbox_info *minfo; + int i; + + for (i =3D 0; i < VCP_MBOX_NUM; i++) { + minfo =3D &vcp_ipc->info_table[i]; + mbox_free_channel(minfo->ch); + } + + vfree(vcp_ipc->info_table); +} + +static struct platform_driver mtk_vcp_ipc_driver =3D { + .probe =3D mtk_vcp_ipc_probe, + .remove =3D mtk_vcp_ipc_remove, + .driver =3D { + .name =3D "mtk-vcp-ipc", + }, +}; +builtin_platform_driver(mtk_vcp_ipc_driver); + +MODULE_AUTHOR("Jjian Zhou "); +MODULE_DESCRIPTION("MediaTek VCP IPC Controller"); +MODULE_LICENSE("GPL"); diff --git a/include/linux/firmware/mediatek/mtk-vcp-ipc.h b/include/linux/= firmware/mediatek/mtk-vcp-ipc.h new file mode 100644 index 000000000000..dc34b0ba9dd8 --- /dev/null +++ b/include/linux/firmware/mediatek/mtk-vcp-ipc.h @@ -0,0 +1,151 @@ +/* SPDX-License-Identifier: (GPL-2.0 OR MIT) */ +/* + * Copyright (c) 2024 MediaTek Inc. + */ + +#ifndef __MTK_VCP_IPC_H__ +#define __MTK_VCP_IPC_H__ + +#include +#include +#include +#include +#include +#include + +/* IPI result definition */ +#define IPI_ACTION_DONE 0 +#define IPI_DEV_ILLEGAL -1 /* ipi device is not initialized */ +#define IPI_ALREADY_USED -2 /* the ipi has be registered */ +#define IPI_UNAVAILABLE -3 /* the ipi can't be found */ +#define IPI_NO_MSGBUF -4 /* receiver doesn't have message buffer */ +#define IPI_MSG_TOO_BIG -5 /* message length is larger than defined */ +#define IPI_MBOX_ERR -99 /* some error from rpmsg layer */ + +/* mbox recv action definition */ +enum mtk_ipi_recv_opt { + MBOX_RECV_MESSAGE =3D 0, + MBOX_RECV_ACK =3D 1, +}; + +/* mbox table item number definition */ +#define send_item_num 3 +#define recv_item_num 4 +#define VCP_MBOX_NUM 5 + +/* mbox slot size definition: 1 slot for 4 bytes */ +#define MBOX_SLOT_SIZE 0x4 +#define MBOX_MAX_PIN 32 +#define VCP_MBOX_NUM 5 +#define MBOX_SLOT_ALIGN 2 + +struct mtk_vcp_ipc; +struct mtk_ipi_chan_table; + +typedef int (*mbox_pin_cb_t)(u32 ipi_id, void *prdata, void *data, u32 len= ); + +/** + * mbox pin structure, this is for send definition, + * @offset: message offset in the slots of a mbox + * @msg_size: message used slots in the mbox, 4 bytes alignment + * @pin_index: bit offset in the mbox + * @ipi_id: ipi enum number + * @mbox_id: mbox number id + */ +struct mtk_mbox_send_table { + u32 offset; + u32 msg_size; + u32 pin_index; + u32 ipi_id; + u32 mbox_id; +}; + +/** + * mbox pin structure, this is for receive definition, + * @offset: message offset in the slots of a mbox + * @recv_opt: recv option, 0:receive ,1: response + * @msg_size: message used slots in the mbox, 4 bytes alignment + * @pin_index: bit offset in the mbox + * @ipi_id: ipi enum number + * @mbox_id: mbox number id + */ +struct mtk_mbox_recv_table { + u32 offset; + u32 recv_opt; + u32 msg_size; + u32 pin_index; + u32 ipi_id; + u32 mbox_id; +}; + +/** + * struct mtk_ipi_device - device for represent the tinysys using mtk ipi + * @name: name of tinysys device + * @id: device id (used to match between rpmsg drivers and devices) + * @vcp_ipc: vcp ipc structure for tinysys device + * @table: channel table with endpoint & channel_info & mbox_pin info + * @prdata: private data for the callback use + * @ipi_inited: set when vcp_ipi_device_register() done + */ +struct mtk_ipi_device { + const char *name; + struct mtk_vcp_ipc *vcp_ipc; + struct mtk_ipi_chan_table *table; + void *prdata; + int ipi_inited; +}; + +/** + * The mtk_mbox_table is a structure used to record the send + * table and recv table. The send table is used to record + * the feature ID and size of the sent data. The recv table + * is used to record the feature ID and size of the received + * data, and whether a callback needs to be invoked. + * + * Following are platform specific interfacer + * @recv_table: structure mtk_mbox_recv_table + * @send_table: structure mtk_mbox_send_table + * @recv_count: receive feature number in this channel + * @send_count: send feature number in this channel + */ +struct mtk_mbox_table { + struct mtk_mbox_recv_table recv_table[32]; + struct mtk_mbox_send_table send_table[32]; + u32 recv_count; + u32 send_count; +}; + +/** + * Mbox is a dedicate hardware of a tinysys consists of: + * 1) a share memory tightly coupled to the tinysys + * 2) several IRQs + * + * Following are platform specific interface + * @dev: vcp device + * @name: identity of the device + * @info_table: mbox info structure + * @ipi_priv: private data for synchronization layer + * @mbox_id: mbox number + * @mbdev: mtk_mbox_table structure + */ +struct mtk_vcp_ipc { + struct device *dev; + const char *name; + struct mtk_mbox_info *info_table; + void *ipi_priv; + void *mbox_id; + struct mtk_mbox_table *mbdev; +}; + +int mtk_vcp_ipc_device_register(struct mtk_ipi_device *ipidev, + u32 ipi_chan_count, + struct mtk_vcp_ipc *vcp_ipc); +int mtk_vcp_ipc_send(struct mtk_ipi_device *ipidev, u32 ipi_id, + void *data, u32 len); +int mtk_vcp_ipc_send_compl(struct mtk_ipi_device *ipidev, u32 ipi_id, + void *data, u32 len, u32 timeout_ms); +int mtk_vcp_mbox_ipc_register(struct mtk_ipi_device *ipidev, int ipi_id, + mbox_pin_cb_t cb, void *prdata, void *msg); +int mtk_vcp_mbox_ipc_unregister(struct mtk_ipi_device *ipidev, int ipi_id); + +#endif --=20 2.45.2 From nobody Thu Dec 18 05:19:30 2025 Received: from mailgw02.mediatek.com (unknown [210.61.82.184]) (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 BC3ED237179; Mon, 17 Mar 2025 11:03:44 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=210.61.82.184 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742209426; cv=none; b=YH5k3tQuTH8EuqlFMnlCw4m17iCbrj1G28drIeFWThFuE8/KnpYKJTvtFEZJpHNe6WFXoyzslP3CLKN9wjvcQL3UeWkOMS3cPa/lL4vjrL8QFreR0ZktGWnyvYqAX3ej9P+fUI5MMINjpjpRQa8TLSqqelwyy3dJgYNNltfE46g= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742209426; c=relaxed/simple; bh=ebNv1DgdatEgzntyZ95OdFIGUMhBrxkKUEyNQS6jUSE=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=TwfjYhYgiOL74bbT8P6GLmWrsZKx+E98JQSetFovKgY2uj1TmnQesDxTf3v0z+Vqmsl4hEPpowAVJ+rTlJUy0xtOfa3uov8B4K+ODzdokp8ABFkAebTeKyo4bohc8/UbGJ7v38k5i9mL8ELekH6L9yDfmHxQanHgkAnsPHd71JM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=mediatek.com; spf=pass smtp.mailfrom=mediatek.com; dkim=pass (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b=CXX9xCC9; arc=none smtp.client-ip=210.61.82.184 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=mediatek.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=mediatek.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="CXX9xCC9" X-UUID: 7b7b62b0031f11f08eb9c36241bbb6fb-20250317 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=Content-Type:Content-Transfer-Encoding:MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:CC:To:From; bh=abBZBbHSvhhu4hHLFKPdPw4jefnWaOmy4oNAIAImzV8=; b=CXX9xCC9DlWGXhh/uZpUPuc4qTQT4Ge7o9ev2PsBHQ9h0PW39HstmOsIlDfpMbvz5VErcYnyFWmbyPlpwHChVUSWzb+5wJ5rtLdGwIv3micTk5ZP6SiPukI6n02I+WGnaZ6Aa1ytJfFhm4YFI1zyci15gdITUyEDjb2BWWIGRqc=; X-CID-P-RULE: Release_Ham X-CID-O-INFO: VERSION:1.2.1,REQID:d6669980-94ad-4708-bcbb-07e98b164164,IP:0,UR L:25,TC:0,Content:0,EDM:0,RT:0,SF:0,FILE:0,BULK:0,RULE:Release_Ham,ACTION: release,TS:25 X-CID-META: VersionHash:0ef645f,CLOUDID:ae73354a-a527-43d8-8af6-bc8b32d9f5e9,B ulkID:nil,BulkQuantity:0,Recheck:0,SF:81|82|102,TC:nil,Content:0|50,EDM:-3 ,IP:nil,URL:11|83|1,File:nil,RT:nil,Bulk:nil,QS:nil,BEC:nil,COL:0,OSI:0,OS A:0,AV:0,LES:1,SPR:NO,DKR:0,DKP:0,BRR:0,BRE:0,ARC:0 X-CID-BVR: 0 X-CID-BAS: 0,_,0,_ X-CID-FACTOR: TF_CID_SPAM_SNR,TF_CID_SPAM_ULN X-UUID: 7b7b62b0031f11f08eb9c36241bbb6fb-20250317 Received: from mtkmbs14n1.mediatek.inc [(172.21.101.75)] by mailgw02.mediatek.com (envelope-from ) (Generic MTA with TLSv1.2 ECDHE-RSA-AES256-GCM-SHA384 256/256) with ESMTP id 1130110409; Mon, 17 Mar 2025 19:03:39 +0800 Received: from mtkmbs11n2.mediatek.inc (172.21.101.187) by mtkmbs13n1.mediatek.inc (172.21.101.193) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1258.39; Mon, 17 Mar 2025 19:03:38 +0800 Received: from mhfsdcap04.gcn.mediatek.inc (10.17.3.154) by mtkmbs11n2.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.2.1258.39 via Frontend Transport; Mon, 17 Mar 2025 19:03:37 +0800 From: Jjian Zhou To: Jassi Brar , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Matthias Brugger , AngeloGioacchino Del Regno CC: , , , , , Chen-Yu Tsai , Jjian Zhou Subject: [PATCH RFC v3 3/3] dt-bindings: mailbox: mtk,mt8196-vcp-mbox: add mtk vcp-mbox document Date: Mon, 17 Mar 2025 19:03:25 +0800 Message-ID: <20250317110331.2776-4-jjian.zhou@mediatek.com> X-Mailer: git-send-email 2.46.0 In-Reply-To: <20250317110331.2776-1-jjian.zhou@mediatek.com> References: <20250317110331.2776-1-jjian.zhou@mediatek.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 X-MTK: N Content-Type: text/plain; charset="utf-8" This patch adds document for mediatek vcp mbox. Signed-off-by: Jjian Zhou --- .../bindings/mailbox/mtk,mt8196-vcp-mbox.yaml | 49 +++++++++++++++++++ 1 file changed, 49 insertions(+) create mode 100644 Documentation/devicetree/bindings/mailbox/mtk,mt8196-vc= p-mbox.yaml diff --git a/Documentation/devicetree/bindings/mailbox/mtk,mt8196-vcp-mbox.= yaml b/Documentation/devicetree/bindings/mailbox/mtk,mt8196-vcp-mbox.yaml new file mode 100644 index 000000000000..bd1b024e22f1 --- /dev/null +++ b/Documentation/devicetree/bindings/mailbox/mtk,mt8196-vcp-mbox.yaml @@ -0,0 +1,49 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/mailbox/mtk,mt8196-vcp-mbox.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: MediaTek Video Companion Processor (VCP) mailbox + +maintainers: + - Jjian Zhou + +description: + The MTK VCP mailbox enables the SoC to communicate with the VCP by passi= ng + messages through 64 32-bit wide registers. It has 32 interrupt vectors in + either direction for signalling purposes. + +properties: + compatible: + enum: + - mediatek,mt8196-vcp-mbox + + reg: + maxItems: 1 + + interrupts: + maxItems: 1 + + "#mbox-cells": + const: 0 + +required: + - compatible + - reg + - interrupts + - "#mbox-cells" + +additionalProperties: false + +examples: + - | + #include + #include + + mailbox@31b80000 { + compatible =3D "mediatek,mt8196-vcp-mbox"; + reg =3D <0x31b80000 0x1000>; + interrupts =3D ; + #mbox-cells =3D <0>; + }; --=20 2.45.2