From patchwork Wed Dec 26 07:53:09 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Pi-Hsun Shih X-Patchwork-Id: 10742875 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 1391B1399 for ; Wed, 26 Dec 2018 07:54:51 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 03F58287C6 for ; Wed, 26 Dec 2018 07:54:51 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id EC26D288C4; Wed, 26 Dec 2018 07:54:50 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-5.2 required=2.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,MAILING_LIST_MULTI,RCVD_IN_DNSWL_MED autolearn=ham version=3.3.1 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.wl.linuxfoundation.org (Postfix) with ESMTPS id 941AD287C6 for ; Wed, 26 Dec 2018 07:54:46 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=M0BecDH9/7447MHoWe2jy6ujRz27QgAo68kOgLc+/I4=; b=oqc07wr0+WAhvr rpKDqjuMODSHn97DQgrntsk7ZCUPF+D/yFes9wAi+CRVOXCnQIwSn8C2F+Nd3KvCqKIzZgWAZDoJ6 YrYPIRMJqwe3ep0QYBeheuyN6jZUIAkmQIjuw/OviKDSPaM9fwbxKOc/wZycLyyctyDApGgsCTVpi KoA5ysrGpdZXBOL06V+YtMcwtbGvRUXKtOZz0BX8R9zo7ZoEgt+dFwtY4aogntme3/BFMqJAq+osH Q+jcGPuwSmQcG+Q59bVEa/GudBvklYOsPUuxUmZBr45oj7QLbHcs1On9ZgnNWKYqhTDATlnjZnqRA g79MaepRpPaOHFb+Dq0Q==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.90_1 #2 (Red Hat Linux)) id 1gc41c-0007AP-06; Wed, 26 Dec 2018 07:54:44 +0000 Received: from mail-pg1-x542.google.com ([2607:f8b0:4864:20::542]) by bombadil.infradead.org with esmtps (Exim 4.90_1 #2 (Red Hat Linux)) id 1gc410-0005xz-AF for linux-mediatek@lists.infradead.org; Wed, 26 Dec 2018 07:54:12 +0000 Received: by mail-pg1-x542.google.com with SMTP id s198so7303289pgs.2 for ; Tue, 25 Dec 2018 23:53:55 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=65wyOZIPtU/IC4Syfk+lbRQmeNVJWPwsPd+fkuL1h20=; b=cby0UWXrUTigFeVvS5JRp2oa2mLSVZiEwwKv/AjLG2Lc7DNtL89FIqqvi5W1x3Kjr4 exsN7EoGkDRljZV6kcGiSQn1JSX7clFKu2h5BlufKlz1NIm0/vIUc966lWk7Z9sHaVs4 yLavbyg2rij2FZHQ6AIE6i43kpVa2yJZQUXYg= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=65wyOZIPtU/IC4Syfk+lbRQmeNVJWPwsPd+fkuL1h20=; b=JtxM/quWr6dMEgV8hJ9qUIXHq3pazt6hDKeiShWmaSQ8zO0f+OivoZIKw8Fe6MVfzb 8gHJmUOWoSfpvrrRYnN42aowxVIfMFWK7g+r9a7b3neUBxbCfj5gT7d+S6dPRdTLKtwR OGEwkqAJiaT4p/XSMNRn1yU+yIIXlZuCyMHsTGdtUVwQg8Ume5byG0sSD1rYArOBvpAE PQ4zz3UFrzjtv0WR1J8wv9746B8ZKOvtc0qdU+idtx+wDW68hJQy8BYuN8oMqlFuhwQ+ EBSEoFrmyHtiUAWpjUGVc1VdTaKdgprgYEJmbLy5AkKHA+3Nje85gjpHLcbSZhwjPfFP aKRA== X-Gm-Message-State: AJcUukdM/WE9ioQ+3pNDqAP0etCYRSeFsIEgW4zRr3z0KgJvmAS5RM05 WF8Sd64mTR9id7gqp0m4B5N+Ag== X-Google-Smtp-Source: AFSGD/W8/ChF1oBPzNTLHIeaxxijBRcOH1+A7FnrYyaVwd+yBju+8AFmEtSD4GyYz1qrAnmcm06B2A== X-Received: by 2002:a62:868b:: with SMTP id x133mr20195061pfd.252.1545810835005; Tue, 25 Dec 2018 23:53:55 -0800 (PST) Received: from pihsun-z840.tpe.corp.google.com ([2401:fa00:1:10:7889:7a43:f899:134c]) by smtp.googlemail.com with ESMTPSA id 84sm107392395pfa.115.2018.12.25.23.53.52 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Tue, 25 Dec 2018 23:53:54 -0800 (PST) From: Pi-Hsun Shih To: Subject: [RFC,1/5] dt-bindings: Add a binding for Mediatek SCP Date: Wed, 26 Dec 2018 15:53:09 +0800 Message-Id: <20181226075330.82462-2-pihsun@chromium.org> X-Mailer: git-send-email 2.20.1.415.g653613c723-goog In-Reply-To: <20181226075330.82462-1-pihsun@chromium.org> References: <20181226075330.82462-1-pihsun@chromium.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20181225_235406_375792_56EBA942 X-CRM114-Status: GOOD ( 11.75 ) X-BeenThere: linux-mediatek@lists.infradead.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Ohad Ben-Cohen , Mark Rutland , Nicolas Boichat , "open list:OPEN FIRMWARE AND FLATTENED DEVICE TREE BINDINGS" , Erin Lo , "open list:REMOTE PROCESSOR REMOTEPROC SUBSYSTEM" , open list , Bjorn Andersson , Rob Herring , "moderated list:ARM/Mediatek SoC support" , Pi-Hsun Shih , Matthias Brugger , "moderated list:ARM/Mediatek SoC support" Sender: "Linux-mediatek" Errors-To: linux-mediatek-bounces+patchwork-linux-mediatek=patchwork.kernel.org@lists.infradead.org X-Virus-Scanned: ClamAV using ClamSMTP From: Erin Lo Add a DT binding documentation of SCP for the MT8183 SoC from Mediatek. Signed-off-by: Erin Lo --- .../devicetree/bindings/remoteproc/mtk,scp.txt | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 Documentation/devicetree/bindings/remoteproc/mtk,scp.txt diff --git a/Documentation/devicetree/bindings/remoteproc/mtk,scp.txt b/Documentation/devicetree/bindings/remoteproc/mtk,scp.txt new file mode 100644 index 0000000000000..b07e5c4ca9af1 --- /dev/null +++ b/Documentation/devicetree/bindings/remoteproc/mtk,scp.txt @@ -0,0 +1,9 @@ +Mediatek SCP Bindings +---------------------------------------- + +This binding provides support for ARM Cortex M4 Co-processor found on some +Mediatek SoCs. + +Required properties: +- compatible Should be "mediatek,mt8183-scp" +- clocks Clock for co-processor (See: ../clock/clock-bindings.txt) From patchwork Wed Dec 26 07:53:10 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Pi-Hsun Shih X-Patchwork-Id: 10742873 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 67E0B6C5 for ; Wed, 26 Dec 2018 07:54:47 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 54FCF288BE for ; Wed, 26 Dec 2018 07:54:47 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 48CAF288C5; Wed, 26 Dec 2018 07:54:47 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-5.2 required=2.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,MAILING_LIST_MULTI,RCVD_IN_DNSWL_MED autolearn=unavailable version=3.3.1 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.wl.linuxfoundation.org (Postfix) with ESMTPS id E923A288C4 for ; Wed, 26 Dec 2018 07:54:42 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=zBz7eS6Y8KgB6eT7pQI9qF33jcso/+XqhLOgHVWIpLs=; b=BS8bHBE9dfKEz6 lZ1froQlFk/pTYT68vnmtQi2vaM2BreYLtUU5uNFc2fCwPyj4PbeC6mVxYEgLw15pXUam7atTfDiv 5dLfcD69Kyc+YTbMWIJZ4S4wE+13xwXFELvKXKcQhbQG5XOVrAsSGh+JkC685fowyB7dbT7VHxO5y LDcG3DcbWBoeFMZZEjyoUQ4e6Uyr/LeJNqf9f/ZZ8ULT31UGcs4CE+3KOaMY6rcuziXdD9OkTvFm4 6vvRULrN2AV/QtwHvpRyabP21FpkKzYhw4iQtKTRhrxnYNsZ4GpuXkTCKQREknSUGEu8lUYKFPLdP V1NKMeY1gVs9ey7DeOSQ==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.90_1 #2 (Red Hat Linux)) id 1gc41Z-00077j-D8; Wed, 26 Dec 2018 07:54:41 +0000 Received: from mail-pg1-x542.google.com ([2607:f8b0:4864:20::542]) by bombadil.infradead.org with esmtps (Exim 4.90_1 #2 (Red Hat Linux)) id 1gc410-0006BU-AP for linux-mediatek@lists.infradead.org; Wed, 26 Dec 2018 07:54:12 +0000 Received: by mail-pg1-x542.google.com with SMTP id g189so7297462pgc.5 for ; Tue, 25 Dec 2018 23:54:04 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=guUndGHI9as4unbWozKREYottJLvM1HnccvkyY6x2t4=; b=J/dzFZknM8uiglzezfoBKKWIaXN6IK/z1fYu16zFkUtc+5i7lYnuLtL9lUTvBF/GOK XGjKQBd/PtwlmKgaRrJbnyeEVaqynoVfx+ANdYr4A0qMX1BHICnJRZLdS793AVPmVBcd 9F9Wjt25mi1sK7DK47ZM1avj94htxsP+B+iGo= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=guUndGHI9as4unbWozKREYottJLvM1HnccvkyY6x2t4=; b=C/0tuEGXHg9yjywG4WR9nU7k+4dpi4/W6mOZgMdwvOuByKpMnOXzn7b/DUz3/hbrtE f2G7y1DLmGFS6VYv0gULcrh+NxPQHD3C6VS3QazjjAgSkvUMEn8cruugI3fu33IYY6Cu A58g5DN5roGLMfbCDMOYdbw45qzHGqWwuI66dvMrzQAKMAei8xIYGr0Wsn/l6w6AMlTy 7svLvecPHnfdkKwAeklU5PWdzDdCb7vf7f8TyKibQI8yCOrXi0rtX+yb6GaCWnurh8ex kTj65pkPcPO57LAFoUfishjkKy22gdyPOwTlMSdNtqNfR93i6qbirP5iLfwHM7cl3xYV AzbQ== X-Gm-Message-State: AJcUukeHbH+gQku4qODuPDLb2FwIKxiQEgpm6rvaWEos5n+PvBfrTiE7 vXWGe8nxDxNHyFxyj26ISKbh+g== X-Google-Smtp-Source: ALg8bN6xwfe6ZT4w1pDzJCIs/XTtQN5pleLjuM8lpJiZmTZl+zUMLxmWcXZ8KkY708mlgA3WLMEokQ== X-Received: by 2002:a63:f844:: with SMTP id v4mr17927126pgj.82.1545810844104; Tue, 25 Dec 2018 23:54:04 -0800 (PST) Received: from pihsun-z840.tpe.corp.google.com ([2401:fa00:1:10:7889:7a43:f899:134c]) by smtp.googlemail.com with ESMTPSA id 84sm107392395pfa.115.2018.12.25.23.54.01 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Tue, 25 Dec 2018 23:54:03 -0800 (PST) From: Pi-Hsun Shih To: Subject: [RFC,2/5] remoteproc/mediatek: add SCP support for mt8183 Date: Wed, 26 Dec 2018 15:53:10 +0800 Message-Id: <20181226075330.82462-3-pihsun@chromium.org> X-Mailer: git-send-email 2.20.1.415.g653613c723-goog In-Reply-To: <20181226075330.82462-1-pihsun@chromium.org> References: <20181226075330.82462-1-pihsun@chromium.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20181225_235406_372688_20A74688 X-CRM114-Status: GOOD ( 20.85 ) X-BeenThere: linux-mediatek@lists.infradead.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Ohad Ben-Cohen , Nicolas Boichat , Erin Lo , "open list:REMOTE PROCESSOR REMOTEPROC SUBSYSTEM" , open list , Bjorn Andersson , "moderated list:ARM/Mediatek SoC support" , Pi-Hsun Shih , Matthias Brugger , Eddie Huang , "moderated list:ARM/Mediatek SoC support" Sender: "Linux-mediatek" Errors-To: linux-mediatek-bounces+patchwork-linux-mediatek=patchwork.kernel.org@lists.infradead.org X-Virus-Scanned: ClamAV using ClamSMTP From: Erin Lo Provide a basic driver to control Cortex M4 co-processor Signed-off-by: Erin Lo --- drivers/remoteproc/Kconfig | 9 + drivers/remoteproc/Makefile | 1 + drivers/remoteproc/mtk_scp.c | 568 ++++++++++++++++++++++++++ include/linux/platform_data/mtk_scp.h | 136 ++++++ 4 files changed, 714 insertions(+) create mode 100644 drivers/remoteproc/mtk_scp.c create mode 100644 include/linux/platform_data/mtk_scp.h diff --git a/drivers/remoteproc/Kconfig b/drivers/remoteproc/Kconfig index f0abd26080447..ee0bda2376893 100644 --- a/drivers/remoteproc/Kconfig +++ b/drivers/remoteproc/Kconfig @@ -22,6 +22,15 @@ config IMX_REMOTEPROC It's safe to say N here. +config MTK_SCP + tristate "Mediatek SCP support" + depends on ARCH_MEDIATEK + help + Say y here to support Mediatek's SCP (Cortex M4 + on MT8183) via the remote processor framework. + + It's safe to say N here. + config OMAP_REMOTEPROC tristate "OMAP remoteproc support" depends on ARCH_OMAP4 || SOC_OMAP5 diff --git a/drivers/remoteproc/Makefile b/drivers/remoteproc/Makefile index ce5d061e92be5..98e3498dbbe0e 100644 --- a/drivers/remoteproc/Makefile +++ b/drivers/remoteproc/Makefile @@ -10,6 +10,7 @@ remoteproc-y += remoteproc_sysfs.o remoteproc-y += remoteproc_virtio.o remoteproc-y += remoteproc_elf_loader.o obj-$(CONFIG_IMX_REMOTEPROC) += imx_rproc.o +obj-$(CONFIG_MTK_SCP) += mtk_scp.o obj-$(CONFIG_OMAP_REMOTEPROC) += omap_remoteproc.o obj-$(CONFIG_WKUP_M3_RPROC) += wkup_m3_rproc.o obj-$(CONFIG_DA8XX_REMOTEPROC) += da8xx_remoteproc.o diff --git a/drivers/remoteproc/mtk_scp.c b/drivers/remoteproc/mtk_scp.c new file mode 100644 index 0000000000000..7a1a8fe53b54a --- /dev/null +++ b/drivers/remoteproc/mtk_scp.c @@ -0,0 +1,568 @@ +// SPDX-License-Identifier: GPL-2.0 +// +// Copyright (c) 2018 MediaTek Inc. + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "remoteproc_internal.h" + +#define MT8183_SW_RSTN 0x0 +#define MT8183_SW_RSTN_BIT BIT(0) +#define MT8183_SCP_TO_HOST 0x1C +#define MT8183_SCP_IPC_INT_BIT BIT(0) +#define MT8183_SCP_WDT_INT_BIT BIT(8) +#define MT8183_HOST_TO_SCP 0x28 +#define MT8183_HOST_IPC_INT_BIT BIT(0) +#define MT8183_SCP_SRAM_PDN 0x402C + +#define INIT_TIMEOUT_MS 2000 +#define IPI_TIMEOUT_MS 2000 +#define SCP_FW_VER_LEN 32 + +#define MAX_CODE_SIZE 0x500000 + +struct scp_run { + u32 signaled; + s8 fw_ver[SCP_FW_VER_LEN]; + u32 dec_capability; + u32 enc_capability; + wait_queue_head_t wq; +}; + +struct scp_ipi_desc { + ipi_handler_t handler; + const char *name; + void *priv; +}; + +struct mtk_scp { + struct device *dev; + struct rproc *rproc; + struct clk *clk; + void __iomem *reg_base; + void __iomem *sram_base; + size_t sram_size; + + struct share_obj *recv_buf; + struct share_obj *send_buf; + struct scp_run run; + struct mutex scp_mutex; /* for protecting mtk_scp data structure */ + struct scp_ipi_desc ipi_desc[IPI_MAX]; + bool ipi_id_ack[IPI_MAX]; + wait_queue_head_t ack_wq; + + void __iomem *cpu_addr; + phys_addr_t phys_addr; + size_t dram_size; +}; + +/** + * struct share_obj - SRAM buffer shared with + * AP and SCP + * + * @id: IPI id + * @len: share buffer length + * @share_buf: share buffer data + */ +struct share_obj { + s32 id; + u32 len; + u8 share_buf[288]; +}; + +int scp_ipi_register(struct platform_device *pdev, + enum ipi_id id, + ipi_handler_t handler, + const char *name, + void *priv) +{ + struct mtk_scp *scp = platform_get_drvdata(pdev); + struct scp_ipi_desc *ipi_desc; + + if (!scp) { + dev_err(&pdev->dev, "scp device is not ready\n"); + return -EPROBE_DEFER; + } + + if (WARN(id < 0 || id >= IPI_MAX || handler == NULL, + "register scp ipi id %d with invalid arguments\n", id)) + return -EINVAL; + + ipi_desc = scp->ipi_desc; + ipi_desc[id].name = name; + ipi_desc[id].handler = handler; + ipi_desc[id].priv = priv; + + return 0; +} +EXPORT_SYMBOL_GPL(scp_ipi_register); + +int scp_ipi_send(struct platform_device *pdev, + enum ipi_id id, void *buf, + unsigned int len, + unsigned int wait) +{ + struct mtk_scp *scp = platform_get_drvdata(pdev); + struct share_obj *send_obj = scp->send_buf; + unsigned long timeout; + int ret; + + if (WARN(id <= IPI_SCP_INIT || id >= IPI_MAX || + len > sizeof(send_obj->share_buf) || !buf, + "failed to send ipi message\n")) + return -EINVAL; + + ret = clk_prepare_enable(scp->clk); + if (ret) { + dev_err(scp->dev, "failed to enable clock\n"); + return ret; + } + + mutex_lock(&scp->scp_mutex); + + /* Wait until SCP receives the last command */ + timeout = jiffies + msecs_to_jiffies(IPI_TIMEOUT_MS); + do { + if (time_after(jiffies, timeout)) { + dev_err(scp->dev, "scp_ipi_send: IPI timeout!\n"); + ret = -EIO; + mutex_unlock(&scp->scp_mutex); + goto clock_disable; + } + } while (readl(scp->reg_base + MT8183_HOST_TO_SCP)); + + memcpy(send_obj->share_buf, buf, len); + send_obj->len = len; + send_obj->id = id; + + scp->ipi_id_ack[id] = false; + /* send the command to SCP */ + writel(MT8183_HOST_IPC_INT_BIT, scp->reg_base + MT8183_HOST_TO_SCP); + + mutex_unlock(&scp->scp_mutex); + + if (wait) { + /* wait for SCP's ACK */ + timeout = msecs_to_jiffies(wait); + ret = wait_event_timeout(scp->ack_wq, + scp->ipi_id_ack[id], + timeout); + scp->ipi_id_ack[id] = false; + if (WARN(!ret, + "scp ipi %d ack time out !", id)) + ret = -EIO; + else + ret = 0; + } + +clock_disable: + clk_disable_unprepare(scp->clk); + + return ret; +} +EXPORT_SYMBOL_GPL(scp_ipi_send); + +struct platform_device *scp_get_plat_device(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct device_node *scp_node; + struct platform_device *scp_pdev; + + scp_node = of_parse_phandle(dev->of_node, "mediatek,scp", 0); + if (!scp_node) { + dev_err(dev, "can't get scp node\n"); + return NULL; + } + + scp_pdev = of_find_device_by_node(scp_node); + if (WARN_ON(!scp_pdev)) { + dev_err(dev, "scp pdev failed\n"); + of_node_put(scp_node); + return NULL; + } + + return scp_pdev; +} +EXPORT_SYMBOL_GPL(scp_get_plat_device); + +static void scp_wdt_handler(struct mtk_scp *scp) +{ + rproc_report_crash(scp->rproc, RPROC_WATCHDOG); +} + +static void scp_init_ipi_handler(void *data, unsigned int len, void *priv) +{ + struct mtk_scp *scp = (struct mtk_scp *)priv; + struct scp_run *run = (struct scp_run *)data; + + scp->run.signaled = run->signaled; + strncpy(scp->run.fw_ver, run->fw_ver, SCP_FW_VER_LEN); + scp->run.dec_capability = run->dec_capability; + scp->run.enc_capability = run->enc_capability; + wake_up_interruptible(&scp->run.wq); +} + +static void scp_ipi_handler(struct mtk_scp *scp) +{ + struct share_obj *rcv_obj = scp->recv_buf; + struct scp_ipi_desc *ipi_desc = scp->ipi_desc; + u8 tmp_data[288]; + + if (rcv_obj->id < IPI_MAX && ipi_desc[rcv_obj->id].handler) { + memcpy_fromio(tmp_data, &rcv_obj->share_buf, rcv_obj->len); + ipi_desc[rcv_obj->id].handler(&tmp_data[0], + rcv_obj->len, + ipi_desc[rcv_obj->id].priv); + scp->ipi_id_ack[rcv_obj->id] = true; + wake_up(&scp->ack_wq); + } else { + dev_err(scp->dev, "No such ipi id = %d\n", rcv_obj->id); + } +} + +static int scp_ipi_init(struct mtk_scp *scp) +{ + size_t send_offset = 0x800 - sizeof(struct share_obj); + size_t recv_offset = send_offset - sizeof(struct share_obj); + + /* Disable SCP to host interrupt */ + writel(MT8183_SCP_IPC_INT_BIT, scp->reg_base + MT8183_SCP_TO_HOST); + + /* shared buffer initialization */ + scp->recv_buf = (__force struct share_obj *)(scp->sram_base + + recv_offset); + scp->send_buf = (__force struct share_obj *)(scp->sram_base + + send_offset); + memset_io(scp->recv_buf, 0, sizeof(scp->recv_buf)); + memset_io(scp->send_buf, 0, sizeof(scp->send_buf)); + + return 0; +} + +static irqreturn_t scp_irq_handler(int irq, void *priv) +{ + struct mtk_scp *scp = priv; + u32 scp_to_host; + + scp_to_host = readl(scp->reg_base + MT8183_SCP_TO_HOST); + if (scp_to_host & MT8183_SCP_IPC_INT_BIT) { + scp_ipi_handler(scp); + } else { + dev_err(scp->dev, "scp watchdog timeout! 0x%x", scp_to_host); + scp_wdt_handler(scp); + } + + /* SCP won't send another interrupt until we set SCP_TO_HOST to 0. */ + writel(MT8183_SCP_IPC_INT_BIT | MT8183_SCP_WDT_INT_BIT, + scp->reg_base + MT8183_SCP_TO_HOST); + + return IRQ_HANDLED; +} + +static int mtk_scp_load(struct rproc *rproc, const struct firmware *fw) +{ + const struct mtk_scp *scp = rproc->priv; + struct device *dev = scp->dev; + int ret; + + ret = clk_prepare_enable(scp->clk); + if (ret) { + dev_err(dev, "failed to enable clocks\n"); + return ret; + } + + writel(0x0, scp->reg_base + MT8183_SCP_SRAM_PDN); + + memcpy(scp->sram_base, fw->data, fw->size); + return ret; +} + +static int mtk_scp_start(struct rproc *rproc) +{ + struct mtk_scp *scp = (struct mtk_scp *)rproc->priv; + struct device *dev = scp->dev; + struct scp_run *run; + u32 val; + int ret; + + ret = clk_prepare_enable(scp->clk); + if (ret) { + dev_err(dev, "failed to enable clocks\n"); + return ret; + } + + val = readl(scp->reg_base + MT8183_SW_RSTN); + val |= MT8183_SW_RSTN_BIT; + writel(val, scp->reg_base + MT8183_SW_RSTN); + + run = &scp->run; + + ret = wait_event_interruptible_timeout( + run->wq, + run->signaled, + msecs_to_jiffies(INIT_TIMEOUT_MS)); + + if (ret == 0) { + dev_err(dev, "wait scp initialization timeout!\n"); + return -ETIME; + } + if (ret == -ERESTARTSYS) { + dev_err(dev, "wait scp interrupted by a signal!\n"); + return -ERESTARTSYS; + } + dev_info(dev, "scp is ready. Fw version %s\n", run->fw_ver); + + return 0; +} + +static void *mtk_scp_da_to_va(struct rproc *rproc, u64 da, int len) +{ + struct mtk_scp *scp = (struct mtk_scp *)rproc->priv; + int offset; + + if (da < scp->sram_size) { + offset = da; + if (offset >= 0 && ((offset + len) < scp->sram_size)) { + return (__force void *)(scp->sram_base + offset); + } + } else if (da >= scp->sram_size && da < (scp->sram_size + MAX_CODE_SIZE)) { + offset = da - scp->sram_size; + if (offset >= 0 && (offset + len) < MAX_CODE_SIZE) { + return scp->cpu_addr + offset; + } + } else { + offset = da - scp->phys_addr; + if (offset >= 0 && (offset + len) < (scp->dram_size - MAX_CODE_SIZE)) { + return scp->cpu_addr + offset; + } + } + + return NULL; +} + +static int mtk_scp_stop(struct rproc *rproc) +{ + struct mtk_scp *scp = (struct mtk_scp *)rproc->priv; + u32 val; + + val = readl(scp->reg_base + MT8183_SW_RSTN); + val &= ~MT8183_SW_RSTN_BIT; + writel(val, scp->reg_base + MT8183_SW_RSTN); + + clk_disable_unprepare(scp->clk); + + return 0; +} + +static const struct rproc_ops mtk_scp_ops = { + .start = mtk_scp_start, + .stop = mtk_scp_stop, + .load = mtk_scp_load, + .da_to_va = mtk_scp_da_to_va, +}; + +unsigned int scp_get_vdec_hw_capa(struct platform_device *pdev) +{ + struct mtk_scp *scp = platform_get_drvdata(pdev); + + return scp->run.dec_capability; +} +EXPORT_SYMBOL_GPL(scp_get_vdec_hw_capa); + +unsigned int scp_get_venc_hw_capa(struct platform_device *pdev) +{ + struct mtk_scp *scp = platform_get_drvdata(pdev); + + return scp->run.enc_capability; +} +EXPORT_SYMBOL_GPL(scp_get_venc_hw_capa); + +void *scp_mapping_dm_addr(struct platform_device *pdev, u32 mem_addr) +{ + struct mtk_scp *scp = platform_get_drvdata(pdev); + void *ptr = NULL; + + ptr = mtk_scp_da_to_va(scp->rproc, mem_addr, 0); + + if (ptr) + return ptr; + else + return ERR_PTR(-EINVAL); +} +EXPORT_SYMBOL_GPL(scp_mapping_dm_addr); + +static int scp_map_memory_region(struct mtk_scp *scp) +{ + struct device_node *node; + struct resource r; + int ret; + + node = of_parse_phandle(scp->dev->of_node, "memory-region", 0); + if (!node) { + dev_err(scp->dev, "no memory-region specified\n"); + return -EINVAL; + } + + ret = of_address_to_resource(node, 0, &r); + if (ret) + return ret; + + scp->phys_addr = r.start; + scp->dram_size = resource_size(&r); + scp->cpu_addr = devm_ioremap_wc(scp->dev, scp->phys_addr, scp->dram_size); + + if (!scp->cpu_addr) { + dev_err(scp->dev, "unable to map memory region: %pa+%zx\n", + &r.start, scp->dram_size); + return -EBUSY; + } + + return 0; +} + +static int mtk_scp_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct device_node *np = dev->of_node; + struct mtk_scp *scp; + struct rproc *rproc; + struct resource *res; + char *fw_name = "scp.img"; + int ret; + + rproc = rproc_alloc(dev, + np->name, + &mtk_scp_ops, + fw_name, + sizeof(*scp)); + if (!rproc) { + dev_err(dev, "unable to allocate remoteproc\n"); + return -ENOMEM; + } + + scp = (struct mtk_scp *)rproc->priv; + scp->rproc = rproc; + scp->dev = dev; + platform_set_drvdata(pdev, scp); + + res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "sram"); + scp->sram_base = devm_ioremap_resource(dev, res); + scp->sram_size = resource_size(res); + if (IS_ERR((__force void *)scp->sram_base)) { + dev_err(dev, "Failed to parse and map sram memory\n"); + ret = PTR_ERR((__force void *)scp->sram_base); + goto free_rproc; + } + + res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "cfg"); + scp->reg_base = devm_ioremap_resource(dev, res); + if (IS_ERR((__force void *)scp->reg_base)) { + dev_err(dev, "Failed to parse and map cfg memory\n"); + ret = PTR_ERR((__force void *)scp->reg_base); + goto free_rproc; + } + + ret = scp_map_memory_region(scp); + if (ret) + goto free_rproc; + + scp->clk = devm_clk_get(dev, "main"); + if (IS_ERR(scp->clk)) { + dev_err(dev, "Failed to get clock\n"); + ret = PTR_ERR(scp->clk); + goto free_rproc; + } + + ret = clk_prepare_enable(scp->clk); + if (ret) { + dev_err(dev, "failed to enable clocks\n"); + goto free_rproc; + } + + ret = scp_ipi_init(scp); + clk_disable_unprepare(scp->clk); + if (ret) { + dev_err(dev, "Failed to init ipi\n"); + goto free_rproc; + } + + /* register scp initialization IPI */ + ret = scp_ipi_register(pdev, + IPI_SCP_INIT, + scp_init_ipi_handler, + "scp_init", + scp); + if (ret) { + dev_err(dev, "Failed to register IPI_SCP_INIT\n"); + goto free_rproc; + } + + ret = devm_request_irq(dev, + platform_get_irq(pdev, 0), + scp_irq_handler, + 0, + pdev->name, + scp); + + if (ret) { + dev_err(dev, "failed to request irq\n"); + goto free_rproc; + } + + mutex_init(&scp->scp_mutex); + + init_waitqueue_head(&scp->run.wq); + init_waitqueue_head(&scp->ack_wq); + + ret = rproc_add(rproc); + if (ret) + goto destroy_mutex; + + return ret; + +destroy_mutex: + mutex_destroy(&scp->scp_mutex); +free_rproc: + rproc_free(rproc); + + return ret; +} + +static int mtk_scp_remove(struct platform_device *pdev) +{ + struct mtk_scp *scp = platform_get_drvdata(pdev); + + rproc_del(scp->rproc); + rproc_free(scp->rproc); + + return 0; +} + +static const struct of_device_id mtk_scp_of_match[] = { + { .compatible = "mediatek,mt8183-scp"}, + {}, +}; +MODULE_DEVICE_TABLE(of, mtk_scp_of_match); + +static struct platform_driver mtk_scp_driver = { + .probe = mtk_scp_probe, + .remove = mtk_scp_remove, + .driver = { + .name = "mtk-scp", + .of_match_table = of_match_ptr(mtk_scp_of_match), + }, +}; + +module_platform_driver(mtk_scp_driver); + +MODULE_LICENSE("GPL v2"); +MODULE_DESCRIPTION("MediaTek scp control driver"); diff --git a/include/linux/platform_data/mtk_scp.h b/include/linux/platform_data/mtk_scp.h new file mode 100644 index 0000000000000..118838c91564f --- /dev/null +++ b/include/linux/platform_data/mtk_scp.h @@ -0,0 +1,136 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright (c) 2018 MediaTek Inc. + */ + +#ifndef _MTK_SCP_H +#define _MTK_SCP_H + +#include + +typedef void (*ipi_handler_t) (void *data, + unsigned int len, + void *priv); + +/** + * enum ipi_id - the id of inter-processor interrupt + * + * @IPI_SCP_INIT: The interrupt from scp is to notfiy kernel + * SCP initialization completed. + * IPI_SCP_INIT is sent from SCP when firmware is + * loaded. AP doesn't need to send IPI_SCP_INIT + * command to SCP. + * For other IPI below, AP should send the request + * to SCP to trigger the interrupt. + * @IPI_MAX: The maximum IPI number + */ + +enum ipi_id { + IPI_SCP_INIT = 0, + IPI_MDP, + IPI_MAX, +}; + +/** + * enum rst_id - reset id to register reset function for SCP watchdog timeout + * + * @SCP_RST_ENC: encoder reset id + * @SCP_RST_DEC: decoder reset id + * @SCP_RST_MDP: MDP (Media Data Path) reset id + * @SCP_RST_MAX: maximum reset id + */ +enum rst_id { + SCP_RST_ENC, + SCP_RST_DEC, + SCP_RST_MDP, + SCP_RST_MAX, +}; + +/** + * scp_ipi_register - register an ipi function + * + * @pdev: SCP platform device + * @id: IPI ID + * @handler: IPI handler + * @name: IPI name + * @priv: private data for IPI handler + * + * Register an ipi function to receive ipi interrupt from SCP. + * + * Return: Return 0 if ipi registers successfully, otherwise it is failed. + */ +int scp_ipi_register(struct platform_device *pdev, + enum ipi_id id, + ipi_handler_t handler, + const char *name, + void *priv); + +/** + * scp_ipi_send - send data from AP to scp. + * + * @pdev: SCP platform device + * @id: IPI ID + * @buf: the data buffer + * @len: the data buffer length + * @wait: 1: need ack + * + * This function is thread-safe. When this function returns, + * SCP has received the data and starts the processing. + * When the processing completes, IPI handler registered + * by scp_ipi_register will be called in interrupt context. + * + * Return: Return 0 if sending data successfully, otherwise it is failed. + **/ +int scp_ipi_send(struct platform_device *pdev, + enum ipi_id id, + void *buf, + unsigned int len, + unsigned int wait); + +/** + * scp_get_plat_device - get SCP's platform device + * + * @pdev: the platform device of the module requesting SCP platform + * device for using SCP API. + * + * Return: Return NULL if it is failed. + * otherwise it is SCP's platform device + **/ +struct platform_device *scp_get_plat_device(struct platform_device *pdev); + +/** + * scp_get_vdec_hw_capa - get video decoder hardware capability + * + * @pdev: SCP platform device + * + * Return: video decoder hardware capability + **/ +unsigned int scp_get_vdec_hw_capa(struct platform_device *pdev); + +/** + * scp_get_venc_hw_capa - get video encoder hardware capability + * + * @pdev: SCP platform device + * + * Return: video encoder hardware capability + **/ +unsigned int scp_get_venc_hw_capa(struct platform_device *pdev); + +/** + * scp_mapping_dm_addr - Mapping SRAM/DRAM to kernel virtual address + * + * @pdev: SCP platform device + * @mem_addr: SCP views memory address + * + * Mapping the SCP's SRAM address / + * DMEM (Data Extended Memory) memory address / + * Working buffer memory address to + * kernel virtual address. + * + * Return: Return ERR_PTR(-EINVAL) if mapping failed, + * otherwise the mapped kernel virtual address + **/ +void *scp_mapping_dm_addr(struct platform_device *pdev, + u32 mem_addr); + +#endif /* _MTK_SCP_H */ From patchwork Wed Dec 26 07:53:11 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Pi-Hsun Shih X-Patchwork-Id: 10742881 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id D4A641399 for ; Wed, 26 Dec 2018 07:55:26 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id C31B9287C6 for ; Wed, 26 Dec 2018 07:55:26 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id B63AF288C4; Wed, 26 Dec 2018 07:55:26 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-5.2 required=2.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,MAILING_LIST_MULTI,RCVD_IN_DNSWL_MED autolearn=unavailable version=3.3.1 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.wl.linuxfoundation.org (Postfix) with ESMTPS id 5A826287C6 for ; Wed, 26 Dec 2018 07:55:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=6M/T6erx3Kqih02QFe0xtIIszicIhviyrVxsCluTisA=; b=WMzdEZCuTQ4SF4 LhlTVWmvbQmB1eDtCvYSJ8sLHK1EmR5xIRu1y9aA7Oi+l46lcGWBYbLT2/cJPfDr+Ud18Lwvz7S93 2ZF2wJLuQkAZJTy5EA9VX4o1rUH8Je1lOy4+1+xGSTjwqnhLUoKvFmhZ2InRNBy9tpOBSLdRMXftn w3CHyNEUtp1uvt3qEUDoGzXxrxRjS11bNDvmCHKoSJgoz7KYTWVJKobgrf90RO7TdwlhGAXJ10DQI lp/YeJ2TlBY4tEyUkpuR3s70zk2P7zuEqMO/5PqRwxKS4DWW+is6q9/aqYH6j3PjfLlXImoSzWBKq R58hIF4+/RubAAGPKnPw==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.90_1 #2 (Red Hat Linux)) id 1gc42C-0000CE-9j; Wed, 26 Dec 2018 07:55:20 +0000 Received: from mail-pf1-x444.google.com ([2607:f8b0:4864:20::444]) by bombadil.infradead.org with esmtps (Exim 4.90_1 #2 (Red Hat Linux)) id 1gc41C-0006LF-OZ for linux-mediatek@lists.infradead.org; Wed, 26 Dec 2018 07:54:28 +0000 Received: by mail-pf1-x444.google.com with SMTP id c123so7585187pfb.0 for ; Tue, 25 Dec 2018 23:54:08 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=xXrvrFItBnRDxfG7z70Hu3FSZdgB97kZ5QNipXXX2BU=; b=aN+RpUig6MAXm9bqE+RIGDCVy4BNT/31Lx2/JoZ1nqd6TicW10OCNcRP8vkYGQyeKE kOjhKH5YGggLHgrRs/ny8baFHBuQmZEVj7EMfdMOs67G3uyEoAOOe2Xt3HOw5k3E0m1F YXYVr8cjJGH3fdgsRbFpfxq9VQjP0hlF6S+oI= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=xXrvrFItBnRDxfG7z70Hu3FSZdgB97kZ5QNipXXX2BU=; b=kZAZx6SuPZgO2PsqQ+ItaO4gmy4u89kkjmthm0xsjb0T/AiPNMuiOFTgxlfD6OkssD kVIbbnMtq8CKZCTZsNyj2KCh43SxFnHnalcaMFW6CVehi9EKFqnKztxrMWFaVUc0wXMA DW8TUewrFa0YeAXRqPM1M7J7zv+cEGX4EgQ4iUcQ5SOJISKZMH7f3WZek2q0K80uQFji 2cgSzMdXRcNDF4pfRkiLDFAbxgv1zNFk1CMhoOSG9WVvY24267uFsfIgQhOebSOxMvc3 qDswGaFGkyLCFWKwMYIzVVXMO/xnme4L13vCPIJ9B3Y9R0YK3v7X19A6xlnV1/PMAzDn a5jg== X-Gm-Message-State: AJcUukfBer/2b3meASWRMXI1FRPqjlN+ooYpBvIzHUgheoY4cwhVpcU2 j/CAMahGm2u9q4ih1LmwjYnJ1w== X-Google-Smtp-Source: ALg8bN5rMi9W8XlxnwP+m4dol26KacFQKQ6UEekDaZzYrzBBKvEIEDUAFkhKfTSusDTNsG6C4vVAGw== X-Received: by 2002:a63:4a0a:: with SMTP id x10mr18054501pga.237.1545810847787; Tue, 25 Dec 2018 23:54:07 -0800 (PST) Received: from pihsun-z840.tpe.corp.google.com ([2401:fa00:1:10:7889:7a43:f899:134c]) by smtp.googlemail.com with ESMTPSA id 84sm107392395pfa.115.2018.12.25.23.54.05 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Tue, 25 Dec 2018 23:54:07 -0800 (PST) From: Pi-Hsun Shih To: Subject: [RFC,3/5] remoteproc: move IPI interface into separate file. Date: Wed, 26 Dec 2018 15:53:11 +0800 Message-Id: <20181226075330.82462-4-pihsun@chromium.org> X-Mailer: git-send-email 2.20.1.415.g653613c723-goog In-Reply-To: <20181226075330.82462-1-pihsun@chromium.org> References: <20181226075330.82462-1-pihsun@chromium.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20181225_235419_475266_2112652A X-CRM114-Status: GOOD ( 20.10 ) X-BeenThere: linux-mediatek@lists.infradead.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Ohad Ben-Cohen , Nicolas Boichat , "open list:REMOTE PROCESSOR REMOTEPROC SUBSYSTEM" , open list , Bjorn Andersson , "moderated list:ARM/Mediatek SoC support" , Pi-Hsun Shih , Matthias Brugger , "moderated list:ARM/Mediatek SoC support" Sender: "Linux-mediatek" Errors-To: linux-mediatek-bounces+patchwork-linux-mediatek=patchwork.kernel.org@lists.infradead.org X-Virus-Scanned: ClamAV using ClamSMTP Move the IPI interface into a separate file mtk_scp_ipi.c, so the things that use the interface only can depend on the module only. Signed-off-by: Pi-Hsun Shih --- drivers/remoteproc/Makefile | 2 +- drivers/remoteproc/mtk_common.h | 73 +++++++++++++++ drivers/remoteproc/mtk_scp.c | 153 +------------------------------ drivers/remoteproc/mtk_scp_ipi.c | 109 ++++++++++++++++++++++ 4 files changed, 184 insertions(+), 153 deletions(-) create mode 100644 drivers/remoteproc/mtk_common.h create mode 100644 drivers/remoteproc/mtk_scp_ipi.c diff --git a/drivers/remoteproc/Makefile b/drivers/remoteproc/Makefile index 98e3498dbbe0e..16b3e5e7a81c8 100644 --- a/drivers/remoteproc/Makefile +++ b/drivers/remoteproc/Makefile @@ -10,7 +10,7 @@ remoteproc-y += remoteproc_sysfs.o remoteproc-y += remoteproc_virtio.o remoteproc-y += remoteproc_elf_loader.o obj-$(CONFIG_IMX_REMOTEPROC) += imx_rproc.o -obj-$(CONFIG_MTK_SCP) += mtk_scp.o +obj-$(CONFIG_MTK_SCP) += mtk_scp.o mtk_scp_ipi.o obj-$(CONFIG_OMAP_REMOTEPROC) += omap_remoteproc.o obj-$(CONFIG_WKUP_M3_RPROC) += wkup_m3_rproc.o obj-$(CONFIG_DA8XX_REMOTEPROC) += da8xx_remoteproc.o diff --git a/drivers/remoteproc/mtk_common.h b/drivers/remoteproc/mtk_common.h new file mode 100644 index 0000000000000..ae55fca2ce2d7 --- /dev/null +++ b/drivers/remoteproc/mtk_common.h @@ -0,0 +1,73 @@ +// SPDX-License-Identifier: GPL-2.0 +// +// Copyright (c) 2018 MediaTek Inc. + +#ifndef __RPROC_MTK_COMMON_H +#define __RPROC_MTK_COMMON_H + +#include +#include +#include +#include + +#define MT8183_SW_RSTN 0x0 +#define MT8183_SW_RSTN_BIT BIT(0) +#define MT8183_SCP_TO_HOST 0x1C +#define MT8183_SCP_IPC_INT_BIT BIT(0) +#define MT8183_SCP_WDT_INT_BIT BIT(8) +#define MT8183_HOST_TO_SCP 0x28 +#define MT8183_HOST_IPC_INT_BIT BIT(0) +#define MT8183_SCP_SRAM_PDN 0x402C + +#define SCP_FW_VER_LEN 32 + +struct scp_run { + u32 signaled; + s8 fw_ver[SCP_FW_VER_LEN]; + u32 dec_capability; + u32 enc_capability; + wait_queue_head_t wq; +}; + +struct scp_ipi_desc { + ipi_handler_t handler; + const char *name; + void *priv; +}; + +struct mtk_scp { + struct device *dev; + struct rproc *rproc; + struct clk *clk; + void __iomem *reg_base; + void __iomem *sram_base; + size_t sram_size; + + struct share_obj *recv_buf; + struct share_obj *send_buf; + struct scp_run run; + struct mutex scp_mutex; /* for protecting mtk_scp data structure */ + struct scp_ipi_desc ipi_desc[IPI_MAX]; + bool ipi_id_ack[IPI_MAX]; + wait_queue_head_t ack_wq; + + void __iomem *cpu_addr; + phys_addr_t phys_addr; + size_t dram_size; +}; + +/** + * struct share_obj - SRAM buffer shared with + * AP and SCP + * + * @id: IPI id + * @len: share buffer length + * @share_buf: share buffer data + */ +struct share_obj { + s32 id; + u32 len; + u8 share_buf[288]; +}; + +#endif diff --git a/drivers/remoteproc/mtk_scp.c b/drivers/remoteproc/mtk_scp.c index 7a1a8fe53b54a..aaebe96bcfd66 100644 --- a/drivers/remoteproc/mtk_scp.c +++ b/drivers/remoteproc/mtk_scp.c @@ -14,163 +14,12 @@ #include #include "remoteproc_internal.h" - -#define MT8183_SW_RSTN 0x0 -#define MT8183_SW_RSTN_BIT BIT(0) -#define MT8183_SCP_TO_HOST 0x1C -#define MT8183_SCP_IPC_INT_BIT BIT(0) -#define MT8183_SCP_WDT_INT_BIT BIT(8) -#define MT8183_HOST_TO_SCP 0x28 -#define MT8183_HOST_IPC_INT_BIT BIT(0) -#define MT8183_SCP_SRAM_PDN 0x402C +#include "mtk_common.h" #define INIT_TIMEOUT_MS 2000 -#define IPI_TIMEOUT_MS 2000 -#define SCP_FW_VER_LEN 32 #define MAX_CODE_SIZE 0x500000 -struct scp_run { - u32 signaled; - s8 fw_ver[SCP_FW_VER_LEN]; - u32 dec_capability; - u32 enc_capability; - wait_queue_head_t wq; -}; - -struct scp_ipi_desc { - ipi_handler_t handler; - const char *name; - void *priv; -}; - -struct mtk_scp { - struct device *dev; - struct rproc *rproc; - struct clk *clk; - void __iomem *reg_base; - void __iomem *sram_base; - size_t sram_size; - - struct share_obj *recv_buf; - struct share_obj *send_buf; - struct scp_run run; - struct mutex scp_mutex; /* for protecting mtk_scp data structure */ - struct scp_ipi_desc ipi_desc[IPI_MAX]; - bool ipi_id_ack[IPI_MAX]; - wait_queue_head_t ack_wq; - - void __iomem *cpu_addr; - phys_addr_t phys_addr; - size_t dram_size; -}; - -/** - * struct share_obj - SRAM buffer shared with - * AP and SCP - * - * @id: IPI id - * @len: share buffer length - * @share_buf: share buffer data - */ -struct share_obj { - s32 id; - u32 len; - u8 share_buf[288]; -}; - -int scp_ipi_register(struct platform_device *pdev, - enum ipi_id id, - ipi_handler_t handler, - const char *name, - void *priv) -{ - struct mtk_scp *scp = platform_get_drvdata(pdev); - struct scp_ipi_desc *ipi_desc; - - if (!scp) { - dev_err(&pdev->dev, "scp device is not ready\n"); - return -EPROBE_DEFER; - } - - if (WARN(id < 0 || id >= IPI_MAX || handler == NULL, - "register scp ipi id %d with invalid arguments\n", id)) - return -EINVAL; - - ipi_desc = scp->ipi_desc; - ipi_desc[id].name = name; - ipi_desc[id].handler = handler; - ipi_desc[id].priv = priv; - - return 0; -} -EXPORT_SYMBOL_GPL(scp_ipi_register); - -int scp_ipi_send(struct platform_device *pdev, - enum ipi_id id, void *buf, - unsigned int len, - unsigned int wait) -{ - struct mtk_scp *scp = platform_get_drvdata(pdev); - struct share_obj *send_obj = scp->send_buf; - unsigned long timeout; - int ret; - - if (WARN(id <= IPI_SCP_INIT || id >= IPI_MAX || - len > sizeof(send_obj->share_buf) || !buf, - "failed to send ipi message\n")) - return -EINVAL; - - ret = clk_prepare_enable(scp->clk); - if (ret) { - dev_err(scp->dev, "failed to enable clock\n"); - return ret; - } - - mutex_lock(&scp->scp_mutex); - - /* Wait until SCP receives the last command */ - timeout = jiffies + msecs_to_jiffies(IPI_TIMEOUT_MS); - do { - if (time_after(jiffies, timeout)) { - dev_err(scp->dev, "scp_ipi_send: IPI timeout!\n"); - ret = -EIO; - mutex_unlock(&scp->scp_mutex); - goto clock_disable; - } - } while (readl(scp->reg_base + MT8183_HOST_TO_SCP)); - - memcpy(send_obj->share_buf, buf, len); - send_obj->len = len; - send_obj->id = id; - - scp->ipi_id_ack[id] = false; - /* send the command to SCP */ - writel(MT8183_HOST_IPC_INT_BIT, scp->reg_base + MT8183_HOST_TO_SCP); - - mutex_unlock(&scp->scp_mutex); - - if (wait) { - /* wait for SCP's ACK */ - timeout = msecs_to_jiffies(wait); - ret = wait_event_timeout(scp->ack_wq, - scp->ipi_id_ack[id], - timeout); - scp->ipi_id_ack[id] = false; - if (WARN(!ret, - "scp ipi %d ack time out !", id)) - ret = -EIO; - else - ret = 0; - } - -clock_disable: - clk_disable_unprepare(scp->clk); - - return ret; -} -EXPORT_SYMBOL_GPL(scp_ipi_send); - struct platform_device *scp_get_plat_device(struct platform_device *pdev) { struct device *dev = &pdev->dev; diff --git a/drivers/remoteproc/mtk_scp_ipi.c b/drivers/remoteproc/mtk_scp_ipi.c new file mode 100644 index 0000000000000..6923066869874 --- /dev/null +++ b/drivers/remoteproc/mtk_scp_ipi.c @@ -0,0 +1,109 @@ +// SPDX-License-Identifier: GPL-2.0 +// +// Copyright (c) 2018 MediaTek Inc. + +#include +#include +#include +#include +#include +#include + +#include "mtk_common.h" + +#define IPI_TIMEOUT_MS 2000 + +int scp_ipi_register(struct platform_device *pdev, + enum ipi_id id, + ipi_handler_t handler, + const char *name, + void *priv) +{ + struct mtk_scp *scp = platform_get_drvdata(pdev); + struct scp_ipi_desc *ipi_desc; + + if (!scp) { + dev_err(&pdev->dev, "scp device is not ready\n"); + return -EPROBE_DEFER; + } + + if (WARN(id < 0 || id >= IPI_MAX || handler == NULL, + "register scp ipi id %d with invalid arguments\n", id)) + return -EINVAL; + + ipi_desc = scp->ipi_desc; + ipi_desc[id].name = name; + ipi_desc[id].handler = handler; + ipi_desc[id].priv = priv; + + return 0; +} +EXPORT_SYMBOL_GPL(scp_ipi_register); + +int scp_ipi_send(struct platform_device *pdev, + enum ipi_id id, void *buf, + unsigned int len, + unsigned int wait) +{ + struct mtk_scp *scp = platform_get_drvdata(pdev); + struct share_obj *send_obj = scp->send_buf; + unsigned long timeout; + int ret; + + if (WARN(id <= IPI_SCP_INIT || id >= IPI_MAX || + len > sizeof(send_obj->share_buf) || !buf, + "failed to send ipi message\n")) + return -EINVAL; + + ret = clk_prepare_enable(scp->clk); + if (ret) { + dev_err(scp->dev, "failed to enable clock\n"); + return ret; + } + + mutex_lock(&scp->scp_mutex); + + /* Wait until SCP receives the last command */ + timeout = jiffies + msecs_to_jiffies(IPI_TIMEOUT_MS); + do { + if (time_after(jiffies, timeout)) { + dev_err(scp->dev, "scp_ipi_send: IPI timeout!\n"); + ret = -EIO; + mutex_unlock(&scp->scp_mutex); + goto clock_disable; + } + } while (readl(scp->reg_base + MT8183_HOST_TO_SCP)); + + memcpy(send_obj->share_buf, buf, len); + send_obj->len = len; + send_obj->id = id; + + scp->ipi_id_ack[id] = false; + /* send the command to SCP */ + writel(MT8183_HOST_IPC_INT_BIT, scp->reg_base + MT8183_HOST_TO_SCP); + + mutex_unlock(&scp->scp_mutex); + + if (wait) { + /* wait for SCP's ACK */ + timeout = msecs_to_jiffies(wait); + ret = wait_event_timeout(scp->ack_wq, + scp->ipi_id_ack[id], + timeout); + scp->ipi_id_ack[id] = false; + if (WARN(!ret, + "scp ipi %d ack time out !", id)) + ret = -EIO; + else + ret = 0; + } + +clock_disable: + clk_disable_unprepare(scp->clk); + + return ret; +} +EXPORT_SYMBOL_GPL(scp_ipi_send); + +MODULE_LICENSE("GPL v2"); +MODULE_DESCRIPTION("MediaTek scp IPI interface"); From patchwork Wed Dec 26 07:53:12 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Pi-Hsun Shih X-Patchwork-Id: 10742883 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id B8CAB1399 for ; Wed, 26 Dec 2018 07:55:35 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id A880F287C6 for ; Wed, 26 Dec 2018 07:55:35 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 9C3F1288C4; Wed, 26 Dec 2018 07:55:35 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-5.2 required=2.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,MAILING_LIST_MULTI,RCVD_IN_DNSWL_MED autolearn=unavailable version=3.3.1 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.wl.linuxfoundation.org (Postfix) with ESMTPS id 288DA287C6 for ; Wed, 26 Dec 2018 07:55:31 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=T2iE4idF5J1h+hqScpbUxK8waGZ4ZE49nhsyj5o2hRw=; b=D7LyGuGk8+1wdr A2ymAi+Tm5dVmnYWrJvigiyhMCK85DHBtKrrc66l24xGk5jFfhUkDSyhrMtjn0kWVPMwTAGwKhhw0 /xFB+41V/JvGBOTihPOzfa0ZLjFdQEKT0G5tVwEqfEkoipbrGR2nWy/ey7hzDyoTNfLp6FI+hfx5J wG641Y+SumyqYVGM7Km3JsDzd12xtUL/7GCbKZBJMGk7vO/lreENeSIMKCfLiyIIY9515ZB+KU/iG PpP/gfhPExmxC6nC3X8ibVnETqXpfgl51vBz3kUDW0wKLvUrkOnNRTD2fcFzf69Drxxb6RDRlaExj I8NX1zD8b64eX/08exCw==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.90_1 #2 (Red Hat Linux)) id 1gc42K-0000lK-1Y; Wed, 26 Dec 2018 07:55:28 +0000 Received: from mail-pl1-x642.google.com ([2607:f8b0:4864:20::642]) by bombadil.infradead.org with esmtps (Exim 4.90_1 #2 (Red Hat Linux)) id 1gc41N-0006ZX-PQ for linux-mediatek@lists.infradead.org; Wed, 26 Dec 2018 07:54:41 +0000 Received: by mail-pl1-x642.google.com with SMTP id 101so7271411pld.6 for ; Tue, 25 Dec 2018 23:54:17 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=VFE5Q/expx9u5OAcUoGYir738UVsOttn1xCRe3b7ESk=; b=YBSkpL6ELxysiEDR1WlP0Jt/OWkV8QHrPo7e1QRsjZcA/yXiqhBE5uU0ePmN6uMMH/ 7yaZsKV9VWLlx8S1ADViAYPe6/H1hHPvdtz7FU7KbTjeFw3dN4lZaAR7F316cMOqaYqR eTGBw8j2i7V4/G+xCGXIMIlODu2P0XBYYjq1A= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=VFE5Q/expx9u5OAcUoGYir738UVsOttn1xCRe3b7ESk=; b=I/gQKhk0+SbW1PCmzpS4IxbmTaK0IcG/iW4OgOpHIFz2J6cCd3A9LOqifr5O7QAK41 BpNnov3NrrNsKwcmdx+Yv1kZhckiPbIa0/+5rdb64kvbRjDAVAsYLH6MWaFc1Me7OkEf 0/X+p43etC5fGXSTMZrIhSp6ulIXSLe+ZkkzBIB62HoeeavQSu5teOoyZczELdlPf9pk BoQ0ybGF0QMaP6lVicccWCa+NPZAPGsUxyrfv4RSWku8PWZnyO40A2THmfyHwejs3GEp AJReapDzFj4BSQwm4DWG0t22kFu/4KdIYUOiVW1HDq4llUbEnDEnqAqz1HmjeY357Ks/ EXaQ== X-Gm-Message-State: AJcUukdVDB8tg4SbAU9UC7iK5VrPAa7q9kDld1rQ3nCpf/fPM2TJTsfa I4qp5nAJMIYOYuT2tjR9cj4xzw== X-Google-Smtp-Source: ALg8bN54MM/dDBhCsTLRoHdoOmRtFl0m6Y30ZyOKKPjc3nFyFdj70pxkjvEAKApaXOt7DhSsOjvojg== X-Received: by 2002:a17:902:9a8b:: with SMTP id w11mr18448017plp.121.1545810856986; Tue, 25 Dec 2018 23:54:16 -0800 (PST) Received: from pihsun-z840.tpe.corp.google.com ([2401:fa00:1:10:7889:7a43:f899:134c]) by smtp.googlemail.com with ESMTPSA id 84sm107392395pfa.115.2018.12.25.23.54.14 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Tue, 25 Dec 2018 23:54:16 -0800 (PST) From: Pi-Hsun Shih To: Subject: [RFC,4/5] rpmsg: add rpmsg support for mt8183 SCP. Date: Wed, 26 Dec 2018 15:53:12 +0800 Message-Id: <20181226075330.82462-5-pihsun@chromium.org> X-Mailer: git-send-email 2.20.1.415.g653613c723-goog In-Reply-To: <20181226075330.82462-1-pihsun@chromium.org> References: <20181226075330.82462-1-pihsun@chromium.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20181225_235430_082121_848628BA X-CRM114-Status: GOOD ( 29.29 ) X-BeenThere: linux-mediatek@lists.infradead.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Ohad Ben-Cohen , Nicolas Boichat , Erin Lo , "open list:REMOTE PROCESSOR REMOTEPROC SUBSYSTEM" , open list , Bjorn Andersson , "moderated list:ARM/Mediatek SoC support" , Pi-Hsun Shih , Matthias Brugger , Eddie Huang , "moderated list:ARM/Mediatek SoC support" Sender: "Linux-mediatek" Errors-To: linux-mediatek-bounces+patchwork-linux-mediatek=patchwork.kernel.org@lists.infradead.org X-Virus-Scanned: ClamAV using ClamSMTP Add a simple rpmsg support for mt8183 SCP, that use IPI / IPC directly. Signed-off-by: Pi-Hsun Shih --- There are lots of TODO comments on things that are not done yet / I have doubt on whether it's the best way to do it. drivers/remoteproc/mtk_common.h | 3 + drivers/remoteproc/mtk_scp.c | 30 ++- drivers/remoteproc/mtk_scp_ipi.c | 2 +- drivers/rpmsg/Kconfig | 5 + drivers/rpmsg/Makefile | 1 + drivers/rpmsg/mtk_rpmsg.c | 341 ++++++++++++++++++++++++++ include/linux/platform_data/mtk_scp.h | 7 + include/linux/rpmsg/mtk_rpmsg.h | 34 +++ 8 files changed, 419 insertions(+), 4 deletions(-) create mode 100644 drivers/rpmsg/mtk_rpmsg.c create mode 100644 include/linux/rpmsg/mtk_rpmsg.h diff --git a/drivers/remoteproc/mtk_common.h b/drivers/remoteproc/mtk_common.h index ae55fca2ce2d7..cdd4919a402a8 100644 --- a/drivers/remoteproc/mtk_common.h +++ b/drivers/remoteproc/mtk_common.h @@ -54,6 +54,9 @@ struct mtk_scp { void __iomem *cpu_addr; phys_addr_t phys_addr; size_t dram_size; + + struct platform_device *pdev; + struct rproc_subdev *rpmsg_subdev; }; /** diff --git a/drivers/remoteproc/mtk_scp.c b/drivers/remoteproc/mtk_scp.c index aaebe96bcfd66..0ed7904809dce 100644 --- a/drivers/remoteproc/mtk_scp.c +++ b/drivers/remoteproc/mtk_scp.c @@ -12,6 +12,7 @@ #include #include #include +#include #include "remoteproc_internal.h" #include "mtk_common.h" @@ -278,6 +279,24 @@ static int scp_map_memory_region(struct mtk_scp *scp) return 0; } +static void scp_add_rpmsg_subdev(struct mtk_scp *scp) +{ + scp->rpmsg_subdev = + mtk_rpmsg_create_rproc_subdev(scp->pdev, scp->rproc); + if (scp->rpmsg_subdev) { + rproc_add_subdev(scp->rproc, scp->rpmsg_subdev); + } +} + +static void scp_remove_rpmsg_subdev(struct mtk_scp *scp) +{ + if (scp->rpmsg_subdev) { + rproc_remove_subdev(scp->rproc, scp->rpmsg_subdev); + mtk_rpmsg_destroy_rproc_subdev(scp->rpmsg_subdev); + scp->rpmsg_subdev = NULL; + } +} + static int mtk_scp_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; @@ -301,6 +320,7 @@ static int mtk_scp_probe(struct platform_device *pdev) scp = (struct mtk_scp *)rproc->priv; scp->rproc = rproc; scp->dev = dev; + scp->pdev = pdev; platform_set_drvdata(pdev, scp); res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "sram"); @@ -372,13 +392,16 @@ static int mtk_scp_probe(struct platform_device *pdev) init_waitqueue_head(&scp->run.wq); init_waitqueue_head(&scp->ack_wq); + scp_add_rpmsg_subdev(scp); + ret = rproc_add(rproc); if (ret) - goto destroy_mutex; + goto remove_subdev; - return ret; + return 0; -destroy_mutex: +remove_subdev: + scp_remove_rpmsg_subdev(scp); mutex_destroy(&scp->scp_mutex); free_rproc: rproc_free(rproc); @@ -390,6 +413,7 @@ static int mtk_scp_remove(struct platform_device *pdev) { struct mtk_scp *scp = platform_get_drvdata(pdev); + scp_remove_rpmsg_subdev(scp); rproc_del(scp->rproc); rproc_free(scp->rproc); diff --git a/drivers/remoteproc/mtk_scp_ipi.c b/drivers/remoteproc/mtk_scp_ipi.c index 6923066869874..1b72c5cc72d36 100644 --- a/drivers/remoteproc/mtk_scp_ipi.c +++ b/drivers/remoteproc/mtk_scp_ipi.c @@ -50,7 +50,7 @@ int scp_ipi_send(struct platform_device *pdev, unsigned long timeout; int ret; - if (WARN(id <= IPI_SCP_INIT || id >= IPI_MAX || + if (WARN(id <= IPI_NS_SERVICE || id >= IPI_MAX || len > sizeof(send_obj->share_buf) || !buf, "failed to send ipi message\n")) return -EINVAL; diff --git a/drivers/rpmsg/Kconfig b/drivers/rpmsg/Kconfig index d0322b41eca54..b8364a397bb60 100644 --- a/drivers/rpmsg/Kconfig +++ b/drivers/rpmsg/Kconfig @@ -55,4 +55,9 @@ config RPMSG_VIRTIO select RPMSG select VIRTIO +config RPMSG_MTK_SCP + tristate "MediaTek SCP" + depends on MTK_SCP + select RPMSG + endmenu diff --git a/drivers/rpmsg/Makefile b/drivers/rpmsg/Makefile index 9aa859502d275..a0c1dcefa36ee 100644 --- a/drivers/rpmsg/Makefile +++ b/drivers/rpmsg/Makefile @@ -6,3 +6,4 @@ obj-$(CONFIG_RPMSG_QCOM_GLINK_NATIVE) += qcom_glink_native.o obj-$(CONFIG_RPMSG_QCOM_GLINK_SMEM) += qcom_glink_smem.o obj-$(CONFIG_RPMSG_QCOM_SMD) += qcom_smd.o obj-$(CONFIG_RPMSG_VIRTIO) += virtio_rpmsg_bus.o +obj-$(CONFIG_RPMSG_MTK_SCP) += mtk_rpmsg.o diff --git a/drivers/rpmsg/mtk_rpmsg.c b/drivers/rpmsg/mtk_rpmsg.c new file mode 100644 index 0000000000000..66b39eaae51f2 --- /dev/null +++ b/drivers/rpmsg/mtk_rpmsg.c @@ -0,0 +1,341 @@ +// SPDX-License-Identifier: GPL-2.0 +// +// Copyright 2018 Google LLC. + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "rpmsg_internal.h" + +// TODO: This is built on top of scp_ipi_register / scp_ipi_send in mtk_scp.h. +// It's probably better to move the implementation of register / send to here +// instead of in remoteproc/mtk_scp_ipi.c +// TODO: Do we need some sort of vring for performance? We may be able to get +// rid of this file if so, but that would require SCP firmware support too. + +struct mtk_rpmsg_device { + struct rpmsg_device rpdev; + + struct platform_device *scp_pdev; +}; + +struct mtk_rpmsg_endpoint { + struct rpmsg_endpoint ept; + u32 ipi_id; + struct platform_device *scp_pdev; +}; + +// TODO: Naming is hard... +struct mtk_rpmsg_rproc_subdev { + struct rproc *scp_rproc; + struct platform_device *scp_pdev; + struct rpmsg_endpoint *ns_ept; + struct rproc_subdev subdev; +}; + +#define to_mtk_subdev(d) container_of(d, struct mtk_rpmsg_rproc_subdev, subdev); + +struct mtk_register_device_work { + struct work_struct register_work; + struct platform_device *scp_pdev; + char name[RPMSG_NAME_SIZE]; + u32 addr; +}; + +/** + * TODO: This is copied from virtio_rpmsg_bus. + * struct rpmsg_ns_msg - dynamic name service announcement message + * @name: name of remote service that is published + * @addr: address of remote service that is published + * + * This message is sent across to publish a new service, or announce + * about its removal. When we receive these messages, an appropriate + * rpmsg channel (i.e device) is created/destroyed. In turn, the ->probe() + * or ->remove() handler of the appropriate rpmsg driver will be invoked + * (if/as-soon-as one is registered). + */ +struct rpmsg_ns_msg { + char name[RPMSG_NAME_SIZE]; + u32 addr; +} __packed; + +#define to_scp_device(r) container_of(r, struct mtk_rpmsg_device, rpdev) +#define to_scp_endpoint(r) container_of(r, struct mtk_rpmsg_endpoint, ept) + +static const struct rpmsg_endpoint_ops mtk_rpmsg_endpoint_ops; + +static void __ept_release(struct kref *kref) +{ + struct rpmsg_endpoint *ept = container_of(kref, struct rpmsg_endpoint, + refcount); + kfree(to_scp_endpoint(ept)); +} + +static void mtk_rpmsg_ipi_handler(void *data, unsigned int len, void *priv) +{ + struct mtk_rpmsg_endpoint *mept = priv; + struct rpmsg_endpoint *ept = &mept->ept; + + // TODO: What if the cb() returns error? + (*ept->cb)(ept->rpdev, data, len, ept->priv, mept->ipi_id); +} + +static struct rpmsg_endpoint * +__rpmsg_create_ept(struct platform_device *scp_pdev, struct rpmsg_device *rpdev, + rpmsg_rx_cb_t cb, void *priv, + u32 id, const char *name) +{ + struct mtk_rpmsg_endpoint *mept; + struct rpmsg_endpoint *ept; + + int ret; + + mept = kzalloc(sizeof(*mept), GFP_KERNEL); + if (!mept) + return NULL; + mept->ipi_id = id; + mept->scp_pdev = scp_pdev; + + ept = &mept->ept; + kref_init(&ept->refcount); + + ept->rpdev = rpdev; + ept->cb = cb; + ept->priv = priv; + ept->ops = &mtk_rpmsg_endpoint_ops; + + ret = scp_ipi_register(scp_pdev, id, mtk_rpmsg_ipi_handler, name, mept); + if (ret) { + dev_err(&scp_pdev->dev, "ipi register failed, id = %d", id); + kref_put(&ept->refcount, __ept_release); + return NULL; + } + + return ept; +} + +static struct rpmsg_endpoint * +mtk_rpmsg_create_ept(struct rpmsg_device *rpdev, rpmsg_rx_cb_t cb, void *priv, + struct rpmsg_channel_info chinfo) +{ + struct platform_device *scp_pdev = to_scp_device(rpdev)->scp_pdev; + // TODO: Is using src as IPI id "correct"? + return __rpmsg_create_ept(scp_pdev, rpdev, cb, priv, chinfo.src, + chinfo.name); +} + +static const struct rpmsg_device_ops mtk_rpmsg_device_ops = { + .create_ept = mtk_rpmsg_create_ept, +}; + +static void mtk_rpmsg_destroy_ept(struct rpmsg_endpoint *ept) +{ + kref_put(&ept->refcount, __ept_release); +} + +static int __mtk_rpmsg_send(struct mtk_rpmsg_endpoint *mept, void *data, + int len, bool wait) +{ + // TODO: The "wait" is not same as what scp_ipi_send's "wait" means, so + // this is not correct. + // (first wait for there's space of tx buffer, second wait for the ack + // from scp.) + return scp_ipi_send(mept->scp_pdev, mept->ipi_id, data, len, + wait ? 200 : 0); +} + +static int mtk_rpmsg_send(struct rpmsg_endpoint *ept, void *data, int len) +{ + struct mtk_rpmsg_endpoint *mept = to_scp_endpoint(ept); + + return __mtk_rpmsg_send(mept, data, len, true); +} + +static int mtk_rpmsg_trysend(struct rpmsg_endpoint *ept, void *data, int len) +{ + struct mtk_rpmsg_endpoint *mept = to_scp_endpoint(ept); + + return __mtk_rpmsg_send(mept, data, len, false); +} + +static const struct rpmsg_endpoint_ops mtk_rpmsg_endpoint_ops = { + .destroy_ept = mtk_rpmsg_destroy_ept, + .send = mtk_rpmsg_send, + .trysend = mtk_rpmsg_trysend, +}; + +static void mtk_rpmsg_release_device(struct device *dev) +{ + struct rpmsg_device *rpdev = to_rpmsg_device(dev); + struct mtk_rpmsg_device *mdev = to_scp_device(rpdev); + + kfree(mdev); +} + +static void mtk_register_device_work_function(struct work_struct *register_work) +{ + struct mtk_rpmsg_device *mdev; + struct rpmsg_device *rpdev; + + struct mtk_register_device_work *work = container_of( + register_work, struct mtk_register_device_work, register_work); + struct platform_device *scp_pdev = work->scp_pdev; + + int ret; + + mdev = kzalloc(sizeof(*mdev), GFP_KERNEL); + if (!mdev) { + goto free_work; + } + + mdev->scp_pdev = scp_pdev; + + rpdev = &mdev->rpdev; + rpdev->ops = &mtk_rpmsg_device_ops; + rpdev->src = work->addr; + rpdev->dst = RPMSG_ADDR_ANY; + strncpy(rpdev->id.name, work->name, RPMSG_NAME_SIZE); + + rpdev->dev.parent = &scp_pdev->dev; + rpdev->dev.release = mtk_rpmsg_release_device; + + ret = rpmsg_register_device(rpdev); + + if (ret) { + dev_err(&scp_pdev->dev, "rpmsg register device failed\n"); + goto free_work; + } + return; + +free_work: + // TODO: Is it reasonable to free the work itself in the handler? + kfree(register_work); +} + +static int mtk_rpmsg_create_device(struct platform_device *scp_pdev, + char *name, u32 addr) +{ + struct mtk_register_device_work *work; + + // This is called in interrupt context from name service callback. + work = kzalloc(sizeof(*work), GFP_ATOMIC); + if (!work) + return -ENOMEM; + + INIT_WORK(&work->register_work, mtk_register_device_work_function); + work->scp_pdev = scp_pdev; + strncpy(work->name, name, RPMSG_NAME_SIZE); + work->addr = addr; + // rpmsg_register_device can't be called in interrupt context, so need + // to schedule a work for it. + // TODO: Or should we change mtk_scp to call the callback in + // non-interrupt context? + schedule_work(&work->register_work); + return 0; +} + +static int mtk_rpmsg_ns_cb(struct rpmsg_device *rpdev, void *data, int len, + void *priv, u32 src) +{ + struct rpmsg_ns_msg *msg = data; + struct platform_device *scp_pdev = priv; + struct device *dev = &scp_pdev->dev; + + int ret; + + if (len != sizeof(*msg)) { + dev_err(dev, "malformed ns msg (%d)\n", len); + return -EINVAL; + } + + /* + * the name service ept does _not_ belong to a real rpmsg channel, + * and is handled by the rpmsg bus itself. + * for sanity reasons, make sure a valid rpdev has _not_ sneaked + * in somehow. + */ + if (rpdev) { + dev_err(dev, "anomaly: ns ept has an rpdev handle\n"); + return -EINVAL; + } + + /* don't trust the remote processor for null terminating the name */ + msg->name[RPMSG_NAME_SIZE - 1] = '\0'; + + dev_info(dev, "creating channel %s addr 0x%x\n", msg->name, msg->addr); + + ret = mtk_rpmsg_create_device(scp_pdev, msg->name, msg->addr); + if (ret) { + dev_err(dev, "create rpmsg device failed\n"); + return ret; + } + + return 0; +} + +int mtk_rpmsg_prepare(struct rproc_subdev *subdev) +{ + struct mtk_rpmsg_rproc_subdev *mtk_subdev; + struct platform_device *scp_pdev; + + mtk_subdev = to_mtk_subdev(subdev); + scp_pdev = mtk_subdev->scp_pdev; + + /* a dedicated endpoint handles the name service msgs */ + mtk_subdev->ns_ept = + __rpmsg_create_ept(scp_pdev, NULL, mtk_rpmsg_ns_cb, scp_pdev, + IPI_NS_SERVICE, "name-service"); + if (!mtk_subdev->ns_ept) { + dev_err(&scp_pdev->dev, + "failed to create name service endpoint\n"); + return -ENOMEM; + } + + return 0; +} + +void mtk_rpmsg_unprepare(struct rproc_subdev *subdev) +{ + struct mtk_rpmsg_rproc_subdev *mtk_subdev = to_mtk_subdev(subdev); + + kref_put(&mtk_subdev->ns_ept->refcount, __ept_release); + // TODO: unregister all rpmsg devices created by name service here. +} + +struct rproc_subdev * +mtk_rpmsg_create_rproc_subdev(struct platform_device *scp_pdev, + struct rproc *scp_rproc) +{ + struct mtk_rpmsg_rproc_subdev *mtk_subdev; + struct device *dev = &scp_pdev->dev; + + mtk_subdev = kzalloc(sizeof(*mtk_subdev), GFP_KERNEL); + if (!mtk_subdev) { + dev_err(dev, "allocate rproc subdevice failed.\n"); + return NULL; + } + mtk_subdev->scp_pdev = scp_pdev; + mtk_subdev->scp_rproc = scp_rproc; + mtk_subdev->subdev.prepare = mtk_rpmsg_prepare; + mtk_subdev->subdev.unprepare = mtk_rpmsg_unprepare; + + return &mtk_subdev->subdev; +} +EXPORT_SYMBOL_GPL(mtk_rpmsg_create_rproc_subdev); + +void mtk_rpmsg_destroy_rproc_subdev(struct rproc_subdev *subdev) +{ + struct mtk_rpmsg_rproc_subdev *mtk_subdev = to_mtk_subdev(subdev); + + kfree(mtk_subdev); +} +EXPORT_SYMBOL_GPL(mtk_rpmsg_destroy_rproc_subdev); + +MODULE_LICENSE("GPL v2"); +MODULE_DESCRIPTION("MediaTek scp rpmsg driver"); diff --git a/include/linux/platform_data/mtk_scp.h b/include/linux/platform_data/mtk_scp.h index 118838c91564f..4b3cf4f63fbe9 100644 --- a/include/linux/platform_data/mtk_scp.h +++ b/include/linux/platform_data/mtk_scp.h @@ -27,7 +27,14 @@ typedef void (*ipi_handler_t) (void *data, enum ipi_id { IPI_SCP_INIT = 0, + // TODO: Should this just be part of the response of IPI_SCP_INIT + // instead? e.g. the initial IPI_SCP_INIT from SCP sends a list of + // channels. + IPI_NS_SERVICE, IPI_MDP, + // TODO: Since we'll not be having all IPI numbers here after the name + // service & rpmsg, this IPI_MAX need to be manually specified and sync + // with the firmware. IPI_MAX, }; diff --git a/include/linux/rpmsg/mtk_rpmsg.h b/include/linux/rpmsg/mtk_rpmsg.h new file mode 100644 index 0000000000000..c55dbd658dde1 --- /dev/null +++ b/include/linux/rpmsg/mtk_rpmsg.h @@ -0,0 +1,34 @@ +// SPDX-License-Identifier: GPL-2.0 +// +// Copyright 2018 Google LLC. + +#ifndef __LINUX_RPMSG_MTK_RPMSG_H +#define __LINUX_RPMSG_MTK_RPMSG_H + +#include +#include + +#if IS_ENABLED(CONFIG_RPMSG_MTK_SCP) + +struct rproc_subdev * +mtk_rpmsg_create_rproc_subdev(struct platform_device *scp_pdev, + struct rproc *scp_rproc); + +void mtk_rpmsg_destroy_rproc_subdev(struct rproc_subdev *subdev); + +#else + +static inline struct rproc_subdev * +mtk_rpmsg_create_rproc_subdev(struct platform_device *scp_pdev, + struct rproc *scp_rproc) +{ + return NULL; +} + +static inline void mtk_rpmsg_destroy_rproc_subdev(struct rproc_subdev *subdev) +{ +} + +#endif + +#endif