From patchwork Mon Mar 3 02:53:25 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Peng Fan X-Patchwork-Id: 13998090 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 1DD3DC19F32 for ; Mon, 3 Mar 2025 03:05:58 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender:List-Subscribe:List-Help :List-Post:List-Archive:List-Unsubscribe:List-Id:MIME-Version:Cc:To: In-Reply-To:References:Message-Id:Content-Transfer-Encoding:Content-Type: Subject:Date:From:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=H0URnfs1xyb+W4SHbq+XsmGBAVc4y4jZhI2YCpnW1Ps=; b=IF4g98ozxqpAMJP3lBHdrdDzGU erdbedIu7AjzX3R/KUm9MsprSFdHdh/9gyV/RI4WF/2VEqz+CYB9aPQhy8fzgQCGKaTdbOvZdp0e9 VE2DihiuawB7NYwBvYvYaGxZU1Yp1ZLk0i9vPibzY3nRUjYUJyDvOggpRMksrNciJePMhRKmwf1mR Do6eKTlaW3ZzZWPJXTFulREYuMIvW2AHF7t9uZyoU7cm8Yn4hEYcPYVQMt4QYpy+vAc4j108LwsN7 oakO1ETqAg2G1KLwumQjbRBVOIiKQ+nIo4elc49KtNOjoykuJQ9Fkxo9SYrkhxYKWp4qoZ5iibSVV TVF1/xTA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98 #2 (Red Hat Linux)) id 1tow7n-0000000H2Bf-11VQ; Mon, 03 Mar 2025 03:05:47 +0000 Received: from mail-db8eur05on2061e.outbound.protection.outlook.com ([2a01:111:f403:2614::61e] helo=EUR05-DB8-obe.outbound.protection.outlook.com) by bombadil.infradead.org with esmtps (Exim 4.98 #2 (Red Hat Linux)) id 1tovxO-0000000H191-29dJ for linux-arm-kernel@lists.infradead.org; Mon, 03 Mar 2025 02:55:03 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=k0Lqq5LnjKvlsqWJZfCa/Nsn7Lqb0WUbttjEXlTOUl4oosOxXE2YoZsTM51V+gSMocaJz1lSQJ7HrQLkmIQa+H9KCZlcil3y70qTJXqYdGY1ZKjWLXYx5Q3q7xXEHH/ZeBGkrNYOHEhNT4mde4H99ADcrcymYlWZZD3bdUynn0IBw+NJA3uQOuBR6u45EIGwghlJ8Wmz+cmaFKc2TcWNtYwCvaoVMCk8kg44NyClvQrKhcYBsK8f+26pildT0baPJyAf20c4uNnv6LOtrOJPemSA21HnHqXl3pnU1JE8upQgAdEnmrThyWC+vlFpFS78yNXb88d1DL8r/EcXCChaVQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector10001; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=H0URnfs1xyb+W4SHbq+XsmGBAVc4y4jZhI2YCpnW1Ps=; b=t3izbnL779biHOua+4vw26XEvhjH9hg6Ga8YQBn1PbOXMVv0+Yb5JWxUX2LvhNLI7dI/WuVHqz0PKJOl4+tvrB9EOTfwSM6ns4TyWtJBVLWsGqccai4hxISD5meNrO9J4h5D0Hmm/I545rQ9zBeS4DSvz7uXrMTpzGUSmCNdqjch1lCnAN1tNi48hkJK+K0+qIQ5WA7MjoYhxYEiak7NUnYL1Vvd8UfAGJDsLTPiLw4xmi/rrDa3y5BouJtsDO7SUhuBzV7MSyqcbBtiyELJKsz0cFVQZ4hMJk29vVyP8tHSZ+AeSxlX8TNq/EehfvINgPUYRoPK9Mfqjg/prnVo5g== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=oss.nxp.com; dmarc=pass action=none header.from=oss.nxp.com; dkim=pass header.d=oss.nxp.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=NXP1.onmicrosoft.com; s=selector1-NXP1-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=H0URnfs1xyb+W4SHbq+XsmGBAVc4y4jZhI2YCpnW1Ps=; b=nf1USgFS6RRnPQFtVsTQlycZNH75EJ5r+aJVdluLQ7XNpoZRsDsf42lQ1zZFSs7G2FIupsSJ0fBLsGiKc+VcOTB7gERqpz10ZiwRr4dWUmOXOizGZvlKOUiUtw3N4SQp/Ewpgu3DmHh/Bt/hj0AcV4TB6868KuSPlSj2pcLdBmP658oF8OprHC59jwRpKhYjbWMxUtozj9IGIZ+IWRsm7m+WwMmMJxwxyx6SjHuCmvpPrWxwuLz+EHxK68gff+WfkSLcFPTgz/17iwDOa/XDTk83pFayniEddSYNF/wV7E5Bp0pEpIjeG3f2bLEwAZLUnHr3tu1iwtdqO22+pFx4iA== Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=oss.nxp.com; Received: from PAXPR04MB8459.eurprd04.prod.outlook.com (2603:10a6:102:1da::15) by AM9PR04MB8308.eurprd04.prod.outlook.com (2603:10a6:20b:3e3::10) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.8489.27; Mon, 3 Mar 2025 02:54:43 +0000 Received: from PAXPR04MB8459.eurprd04.prod.outlook.com ([fe80::165a:30a2:5835:9630]) by PAXPR04MB8459.eurprd04.prod.outlook.com ([fe80::165a:30a2:5835:9630%4]) with mapi id 15.20.8489.025; Mon, 3 Mar 2025 02:54:43 +0000 From: "Peng Fan (OSS)" Date: Mon, 03 Mar 2025 10:53:25 +0800 Subject: [PATCH v3 4/7] firmware: arm_scmi: imx: Add i.MX95 CPU Protocol Message-Id: <20250303-imx-lmm-cpu-v3-4-7695f6f61cfc@nxp.com> References: <20250303-imx-lmm-cpu-v3-0-7695f6f61cfc@nxp.com> In-Reply-To: <20250303-imx-lmm-cpu-v3-0-7695f6f61cfc@nxp.com> To: Sudeep Holla , Cristian Marussi , Shawn Guo , Sascha Hauer , Pengutronix Kernel Team , Fabio Estevam , Rob Herring , Krzysztof Kozlowski , Conor Dooley Cc: Dan Carpenter , linux-kernel@vger.kernel.org, arm-scmi@vger.kernel.org, linux-arm-kernel@lists.infradead.org, imx@lists.linux.dev, devicetree@vger.kernel.org, Peng Fan X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1740970413; l=10156; i=peng.fan@nxp.com; s=20230812; h=from:subject:message-id; bh=TG6cyB/8wHRcrxt99BRqhHciWmEXUxMEAzTx8rHy51Q=; b=d8wVvJs/0StNyFKNZaWQfD6fjdDf54X4tlI6oKDOv7HKZvWvV6Dc4uc7H97M0splaHDrDJq9W v37XyQt0pEODFjCNPeRLtL85U3hhDvhkY8bvsqdcqEq67+H+JoryJUD X-Developer-Key: i=peng.fan@nxp.com; a=ed25519; pk=I4sJg7atIT1g63H7bb5lDRGR2gJW14RKDD0wFL8TT1g= X-ClientProxiedBy: SI2P153CA0014.APCP153.PROD.OUTLOOK.COM (2603:1096:4:140::6) To PAXPR04MB8459.eurprd04.prod.outlook.com (2603:10a6:102:1da::15) MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: PAXPR04MB8459:EE_|AM9PR04MB8308:EE_ X-MS-Office365-Filtering-Correlation-Id: c7183e8a-0155-4f70-36ae-08dd59febfae X-MS-Exchange-SharedMailbox-RoutingAgent-Processed: True X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0;ARA:13230040|1800799024|366016|52116014|7416014|376014|38350700014; X-Microsoft-Antispam-Message-Info: =?utf-8?q?MlxIoohGt51NYp4BxGjmj0GHYhMxSty?= =?utf-8?q?TurpxfscG6ELoWpnrm/dFYTNyjF6og5Qm64wAN/oWw9wscLPK4jva8Fgms/+Fjis0?= =?utf-8?q?y5Vb7ikDBqTu+VK1Am9pcbLeWLx0lvhbdEEPaiDFdZK55UFmv+RDQDtfQumTrwyS9?= =?utf-8?q?ifxtJEogR+oDPJXd3zXHCvlXxPuwqXOPZnPp7SCDx+WMqcdEcaiqo8GAj/ak4sWuL?= =?utf-8?q?GDE9B/fzwWuWwiKl0neoADqR/zWi8NJxEMiBueNle+bn4713jtiZvODvyMojC0lxv?= =?utf-8?q?ofnDTY2jsZJEiKFzFlvbYZCK/8JlZQ5MqVspFxbxn9NTXsXebyPPeg7GNnL2gV+mG?= =?utf-8?q?/AoMLB3WtHT1EUDBndxNs4Q0yYxOhQfrhf4wFrNFzLs71rlb5jzSLdN+d/qpNKzrZ?= =?utf-8?q?yZuBsYB++6NlDWdxa0bfqbvj0IfCQUslthI8SIKsdTWhitOTwQP2A4XKV93SFEER4?= =?utf-8?q?Cve0/YBtemIbyJ4y0XAGaeoGxgo+dcLWLQCuyuZwAuR43N6cye8r0Nf/BQfHkCRAa?= =?utf-8?q?0dS/bFpBE6IXCXFXAUIe9zjY9BsLyfmVft4ybdrQ0LWGjjrAtULLTjHkRRT8TBYcS?= =?utf-8?q?/8A8vS6h5BtAzskRVdHdK+Dr19WCD4DKRmjWBLAv5UOQzhjn6tzL4NTQYAIxONj53?= =?utf-8?q?vNedA7JgfifngblOMr6+GpD0EQ/iXAlFTBzNjeXBPIJJx/G9ZTR0LrODK9/mYYv78?= =?utf-8?q?qLZc6m0wGHGAFWntAWhGnH6PWAtQKgPtcGxeIZqLsFEuojSI7ThK0mlu4nvVB6tzy?= =?utf-8?q?SnKTdObA2J9RmaRwULoGEuEGhtIg/4XFOEjstzpsn+gUgdhjXrSlM/rhlqqO/mLSz?= =?utf-8?q?uk5YkLM3RlUfyxoWrNo0F9T4SRXU4gdzns1s+gU41Kw53+qj2IqxVrbk7SOhE0VzU?= =?utf-8?q?CADvNr98WE5Ct8IGpJTTvGRQx40mrbvcGgozwfOhwPVLy1A6JvssVWdP5WoWSdtGe?= =?utf-8?q?I923NPL5r8/usyeLlFbwAc/l0c36rkqSB5+kV/l9Ys/+JcmQKkWhsLR2061WE4G4X?= =?utf-8?q?toiMMXSDaFkQScV+2AykOZQqi2jk53sudr/bnGhBZMDtNAnFtvi9vPdJ2Fsuw30Bb?= =?utf-8?q?m/cyIyuuifKZ5oOAUQc6mjbmLqbHYwMcNoz/zoYpgiOaUO9iKq5E74dN7iEabLt68?= =?utf-8?q?VZyAH0/nknGxQDvef5CfmvgIx5cBG7yjWv3xHBfxoYaAbVnHRbwGJFhGuXDixso97?= =?utf-8?q?iJnZP79K3WFcQLtabWXhedKy+N4EGHtJ23vhGLHrQbsiyPmjIkRGk9N2qVbclNJV1?= =?utf-8?q?Vw2iBu+Gp8LwdJQDioYkAcvX9KrXg9L9HRePc0MwNwPeP1FXAgz1yeFG8nKBzvJO6?= =?utf-8?q?bXRVrsoka/b+mzSF+P6Ytb50aVfyjjma6kAGwlxQmnfLkZZD2D2ZvepytVndTu4qn?= =?utf-8?q?YcqX8yyUUkd?= X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:PAXPR04MB8459.eurprd04.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230040)(1800799024)(366016)(52116014)(7416014)(376014)(38350700014);DIR:OUT;SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?q?Io+G1ymnZv95eLixXhzsFaCtXgCJ?= =?utf-8?q?rNaQ4Yi9BFFHh7beOntsXRATdZLyo2mBx9fkaC9TQwT5H+chg3WEEiwx5eDfBJ/sm?= =?utf-8?q?41mpNySNytWksj4tDsU3pvdFg4lCt+CJKuSD/BdooHRZBt7iblQmA2dzu55AQNHux?= =?utf-8?q?WTpCSKOa7TGALitL6FbQy8U++cbHcOTB25IQ2K+0pnlHg6yiu1TBVLSww0vYkoF59?= =?utf-8?q?JfzOksTjDw8fyfGa9P9vEp+id70nTrkSy0Go8kAFY0GCaD4v4U0Ykm3AS86Zy3pIL?= =?utf-8?q?BIGr0v7F5QJPPUA8Rw2UzyH7oXx4cMd4foDn1tHhIBvMMOPOgg81FlFs40U2IOiPh?= =?utf-8?q?/zUxRvVDtTmUGtar5TgAOLvLx216uxjkzfMzNxITaUnhsDjn3VXmBxONIGr2qWnzK?= =?utf-8?q?mMJ8eZRROGeMc0qL15+l1U889LvfhsxNDU7CUyxUbxq9OIU+Q+QX92WMW2e5oaNid?= =?utf-8?q?1nDEOV71Y9/6yfUyk2EDplYn/27gt8rJnzyszO+AAt2LZagbGxdsjOyRVgM3xakbR?= =?utf-8?q?JsE4pOKw4zteqISwmzVUDJV1fmx9ZriG2V8U5UrAZsFwNQwuL+evlksosAiFhj6zF?= =?utf-8?q?j9xauxev1Ga189cYrQFyy+qGnYNUZ5mu6l5g+XcN6MbcIPBFJHbYthfWlNOI7KYJJ?= =?utf-8?q?fm0s+fpUSV94GsLNCIxbd4OiGYplorS/VrmF3pR+7IJFK2Cqfj/Vj9KrDiRktWV31?= =?utf-8?q?mFYCr6tmp9G1YP1u7HKxvFxMnk0WwwSJbSl4krKpJwlGeg0yQrQcZCiDExacZRF1c?= =?utf-8?q?+NGNCJT+pEV8oHL8pIrcTrpF3Yz6rxOx9bqnkFoIcHYlZDCMQS7+pdf/av5ixAca2?= =?utf-8?q?meZgm6mA3t9w3ZwMrh8gLXdroF4jgxvihYbD9jzAr+DIQQAqx5xXi6VPz2oacGkGg?= =?utf-8?q?UUCg1WvrI+SsJkDVL6dyzoRWVcr5ljxz7aETF1lOjmQrXfjx4IhoaRPvd+sC0pqzx?= =?utf-8?q?9cCfdVu+Yo55HyusyIx7qKLGPQjEBkXVDg+2BX/ERupRBq9rrPqJrmmmzoo8kL8PA?= =?utf-8?q?9ACwVWtj9PIlj5Q2hxHyPA8FAeeuiysDbehxZMX9b6aJGMMbAIxQbyT66uj3SM1s6?= =?utf-8?q?LRSxxYOFd04a6KVjuBhAg12F5lDc1nBi4TY/J8xt/7u9AYjTM1Tp9DyiQ0ihwD1gF?= =?utf-8?q?72cEbg4vEbUMw/PnW1aiDcrZAcRd0hwGs4jhoMnJsGBN3Lu2RJUVA69FWGptDKCmJ?= =?utf-8?q?EqOh06QAYB9+16i6whhHwIF2YbPu6z7h3aSGu55FhxbMNdkc6O87VJXn4fZSZDMah?= =?utf-8?q?eNejbq4GfkaOPtcbEN8nnb1v89n7h3uPvkcuTvWHNS4HCtj/JagNpz90S3QaZoX5B?= =?utf-8?q?u8umxkaQnYeav9FSul1SPTDdCMCuPogON76Rr7Z3IrcSEfN7WTioNvcegbjf6RNIr?= =?utf-8?q?CjgZWk8CRB6Z5W+UKECyhAxypFhHKYJid79wMmvRWFD1OFIVuTI3hgaGpTgq5lOYO?= =?utf-8?q?nAjQvVLjtms49EuyTCQUUIcgJgcksJUjbuMH9wSeOiVCGKVuIX9un+pVjmQqSvKS+?= =?utf-8?q?KxI0a112qoYY?= X-OriginatorOrg: oss.nxp.com X-MS-Exchange-CrossTenant-Network-Message-Id: c7183e8a-0155-4f70-36ae-08dd59febfae X-MS-Exchange-CrossTenant-AuthSource: PAXPR04MB8459.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 03 Mar 2025 02:54:43.0730 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 686ea1d3-bc2b-4c6f-a92c-d99c5c301635 X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: Df9BAbdGdSUxk5PY6hn5RAu5B0zXCPd9TAVrKCy5Omtdnk7/cdjYrqWuQBiH0tY9deYsJkUes/ssyX2YRgrhmA== X-MS-Exchange-Transport-CrossTenantHeadersStamped: AM9PR04MB8308 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20250302_185502_582430_95914105 X-CRM114-Status: GOOD ( 15.64 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org From: Peng Fan This protocol allows an agent to start, stop a CPU or set reset vector. It is used to manage auxiliary CPUs in an LM (e.g. additional cores in an AP cluster). Signed-off-by: Peng Fan --- drivers/firmware/arm_scmi/vendors/imx/Kconfig | 11 + drivers/firmware/arm_scmi/vendors/imx/Makefile | 1 + drivers/firmware/arm_scmi/vendors/imx/imx-sm-cpu.c | 276 +++++++++++++++++++++ include/linux/scmi_imx_protocol.h | 10 + 4 files changed, 298 insertions(+) diff --git a/drivers/firmware/arm_scmi/vendors/imx/Kconfig b/drivers/firmware/arm_scmi/vendors/imx/Kconfig index 1a936fc87d2350e2a21bccd45dfbeebfa3b90286..b5f13d0e40155e485f4d1696e9550645d888ef44 100644 --- a/drivers/firmware/arm_scmi/vendors/imx/Kconfig +++ b/drivers/firmware/arm_scmi/vendors/imx/Kconfig @@ -12,6 +12,17 @@ config IMX_SCMI_BBM_EXT To compile this driver as a module, choose M here: the module will be called imx-sm-bbm. +config IMX_SCMI_CPU_EXT + tristate "i.MX SCMI CPU EXTENSION" + depends on ARM_SCMI_PROTOCOL || (COMPILE_TEST && OF) + default y if ARCH_MXC + help + This enables i.MX System CPU Protocol to manage cpu + start, stop and etc. + + To compile this driver as a module, choose M here: the + module will be called imx-sm-cpu. + config IMX_SCMI_LMM_EXT tristate "i.MX SCMI LMM EXTENSION" depends on ARM_SCMI_PROTOCOL || (COMPILE_TEST && OF) diff --git a/drivers/firmware/arm_scmi/vendors/imx/Makefile b/drivers/firmware/arm_scmi/vendors/imx/Makefile index f39a99ccaf9af757475e8b112d224669444d7ddc..e3a5ea46345c89da1afae25e55698044672b7c28 100644 --- a/drivers/firmware/arm_scmi/vendors/imx/Makefile +++ b/drivers/firmware/arm_scmi/vendors/imx/Makefile @@ -1,4 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-only obj-$(CONFIG_IMX_SCMI_BBM_EXT) += imx-sm-bbm.o +obj-$(CONFIG_IMX_SCMI_CPU_EXT) += imx-sm-cpu.o obj-$(CONFIG_IMX_SCMI_LMM_EXT) += imx-sm-lmm.o obj-$(CONFIG_IMX_SCMI_MISC_EXT) += imx-sm-misc.o diff --git a/drivers/firmware/arm_scmi/vendors/imx/imx-sm-cpu.c b/drivers/firmware/arm_scmi/vendors/imx/imx-sm-cpu.c new file mode 100644 index 0000000000000000000000000000000000000000..7fa9a89d825396de00ae666f525e8d6a2d2aed18 --- /dev/null +++ b/drivers/firmware/arm_scmi/vendors/imx/imx-sm-cpu.c @@ -0,0 +1,276 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * System control and Management Interface (SCMI) NXP CPU Protocol + * + * Copyright 2025 NXP + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "../../protocols.h" +#include "../../notify.h" + +#define SCMI_PROTOCOL_SUPPORTED_VERSION 0x10000 + +enum scmi_imx_cpu_protocol_cmd { + SCMI_IMX_CPU_ATTRIBUTES = 0x3, + SCMI_IMX_CPU_START = 0x4, + SCMI_IMX_CPU_STOP = 0x5, + SCMI_IMX_CPU_RESET_VECTOR_SET = 0x6, + SCMI_IMX_CPU_INFO_GET = 0xC, +}; + +struct scmi_imx_cpu_info { + u32 nr_cpu; +}; + +#define SCMI_IMX_CPU_NR_CPU_MASK GENMASK(15, 0) +struct scmi_msg_imx_cpu_protocol_attributes { + __le32 attributes; +}; + +struct scmi_msg_imx_cpu_attributes_out { + __le32 attributes; +#define CPU_MAX_NAME 16 + u8 name[CPU_MAX_NAME]; +}; + +struct scmi_imx_cpu_reset_vector_set_in { + __le32 cpuid; +#define CPU_VEC_FLAGS_RESUME BIT(31) +#define CPU_VEC_FLAGS_START BIT(30) +#define CPU_VEC_FLAGS_BOOT BIT(29) + __le32 flags; + __le32 resetvectorlow; + __le32 resetvectorhigh; +}; + +struct scmi_imx_cpu_info_get_out { +#define CPU_RUN_MODE_START 0 +#define CPU_RUN_MODE_HOLD 1 +#define CPU_RUN_MODE_STOP 2 +#define CPU_RUN_MODE_SLEEP 3 + __le32 runmode; + __le32 sleepmode; + __le32 resetvectorlow; + __le32 resetvectorhigh; +}; + +static int scmi_imx_cpu_validate_cpuid(const struct scmi_protocol_handle *ph, + u32 cpuid) +{ + struct scmi_imx_cpu_info *info = ph->get_priv(ph); + + if (cpuid >= info->nr_cpu) + return -EINVAL; + + return 0; +} + +static int scmi_imx_cpu_start(const struct scmi_protocol_handle *ph, + u32 cpuid, bool start) +{ + struct scmi_xfer *t; + u8 msg_id; + int ret; + + ret = scmi_imx_cpu_validate_cpuid(ph, cpuid); + if (ret) + return ret; + + if (start) + msg_id = SCMI_IMX_CPU_START; + else + msg_id = SCMI_IMX_CPU_STOP; + + ret = ph->xops->xfer_get_init(ph, msg_id, sizeof(u32), 0, &t); + if (ret) + return ret; + + put_unaligned_le32(cpuid, t->tx.buf); + ret = ph->xops->do_xfer(ph, t); + + ph->xops->xfer_put(ph, t); + + return ret; +} + +static int scmi_imx_cpu_reset_vector_set(const struct scmi_protocol_handle *ph, + u32 cpuid, u64 vector, bool start, + bool boot, bool resume) +{ + struct scmi_imx_cpu_reset_vector_set_in *in; + struct scmi_xfer *t; + int ret; + + ret = scmi_imx_cpu_validate_cpuid(ph, cpuid); + if (ret) + return ret; + + ret = ph->xops->xfer_get_init(ph, SCMI_IMX_CPU_RESET_VECTOR_SET, sizeof(*in), + 0, &t); + if (ret) + return ret; + + in = t->tx.buf; + in->cpuid = cpu_to_le32(cpuid); + in->flags = cpu_to_le32(0); + if (start) + in->flags |= le32_encode_bits(1, CPU_VEC_FLAGS_START); + if (boot) + in->flags |= le32_encode_bits(1, CPU_VEC_FLAGS_BOOT); + if (resume) + in->flags |= le32_encode_bits(1, CPU_VEC_FLAGS_RESUME); + in->resetvectorlow = cpu_to_le32(lower_32_bits(vector)); + in->resetvectorhigh = cpu_to_le32(upper_32_bits(vector)); + ret = ph->xops->do_xfer(ph, t); + + ph->xops->xfer_put(ph, t); + + return ret; +} + +static int scmi_imx_cpu_started(const struct scmi_protocol_handle *ph, u32 cpuid, + bool *started) +{ + struct scmi_imx_cpu_info_get_out *out; + struct scmi_xfer *t; + u32 mode; + int ret; + + if (!started) + return -EINVAL; + + *started = false; + ret = scmi_imx_cpu_validate_cpuid(ph, cpuid); + if (ret) + return ret; + + ret = ph->xops->xfer_get_init(ph, SCMI_IMX_CPU_INFO_GET, sizeof(u32), + 0, &t); + if (ret) + return ret; + + put_unaligned_le32(cpuid, t->tx.buf); + ret = ph->xops->do_xfer(ph, t); + if (!ret) { + out = t->rx.buf; + mode = le32_to_cpu(out->runmode); + if ((mode == CPU_RUN_MODE_START) || (mode == CPU_RUN_MODE_SLEEP)) + *started = true; + } + + ph->xops->xfer_put(ph, t); + + return ret; +} + +static const struct scmi_imx_cpu_proto_ops scmi_imx_cpu_proto_ops = { + .cpu_reset_vector_set = scmi_imx_cpu_reset_vector_set, + .cpu_start = scmi_imx_cpu_start, + .cpu_started = scmi_imx_cpu_started, +}; + +static int scmi_imx_cpu_protocol_attributes_get(const struct scmi_protocol_handle *ph, + struct scmi_imx_cpu_info *info) +{ + struct scmi_msg_imx_cpu_protocol_attributes *attr; + struct scmi_xfer *t; + int ret; + + ret = ph->xops->xfer_get_init(ph, PROTOCOL_ATTRIBUTES, 0, + sizeof(*attr), &t); + if (ret) + return ret; + + attr = t->rx.buf; + + ret = ph->xops->do_xfer(ph, t); + if (!ret) { + info->nr_cpu = le32_get_bits(attr->attributes, SCMI_IMX_CPU_NR_CPU_MASK); + dev_info(ph->dev, "i.MX SM CPU: %d cpus\n", + info->nr_cpu); + } + + ph->xops->xfer_put(ph, t); + + return ret; +} + +static int scmi_imx_cpu_attributes_get(const struct scmi_protocol_handle *ph, + u32 cpuid) +{ + struct scmi_msg_imx_cpu_attributes_out *out; + char name[SCMI_SHORT_NAME_MAX_SIZE] = {'\0'}; + struct scmi_xfer *t; + int ret; + + ret = ph->xops->xfer_get_init(ph, SCMI_IMX_CPU_ATTRIBUTES, sizeof(u32), 0, &t); + if (ret) + return ret; + + put_unaligned_le32(cpuid, t->tx.buf); + ret = ph->xops->do_xfer(ph, t); + if (!ret) { + out = t->rx.buf; + strscpy(name, out->name, SCMI_SHORT_NAME_MAX_SIZE); + dev_info(ph->dev, "i.MX CPU: name: %s\n", name); + } else { + dev_err(ph->dev, "i.MX cpu: Failed to get info of cpu(%u)\n", cpuid); + } + + ph->xops->xfer_put(ph, t); + + return ret; +} + +static int scmi_imx_cpu_protocol_init(const struct scmi_protocol_handle *ph) +{ + struct scmi_imx_cpu_info *info; + u32 version; + int ret, i; + + ret = ph->xops->version_get(ph, &version); + if (ret) + return ret; + + dev_info(ph->dev, "NXP SM CPU Protocol Version %d.%d\n", + PROTOCOL_REV_MAJOR(version), PROTOCOL_REV_MINOR(version)); + + info = devm_kzalloc(ph->dev, sizeof(*info), GFP_KERNEL); + if (!info) + return -ENOMEM; + + ret = scmi_imx_cpu_protocol_attributes_get(ph, info); + if (ret) + return ret; + + for (i = 0; i < info->nr_cpu; i++) { + ret = scmi_imx_cpu_attributes_get(ph, i); + if (ret) + return ret; + } + + return ph->set_priv(ph, info, version); +} + +static const struct scmi_protocol scmi_imx_cpu = { + .id = SCMI_PROTOCOL_IMX_CPU, + .owner = THIS_MODULE, + .instance_init = &scmi_imx_cpu_protocol_init, + .ops = &scmi_imx_cpu_proto_ops, + .supported_version = SCMI_PROTOCOL_SUPPORTED_VERSION, + .vendor_id = SCMI_IMX_VENDOR, + .sub_vendor_id = SCMI_IMX_SUBVENDOR, +}; +module_scmi_protocol(scmi_imx_cpu); + +MODULE_ALIAS("scmi-protocol-" __stringify(SCMI_PROTOCOL_IMX_CPU) "-" SCMI_IMX_VENDOR); +MODULE_DESCRIPTION("i.MX SCMI CPU driver"); +MODULE_LICENSE("GPL"); diff --git a/include/linux/scmi_imx_protocol.h b/include/linux/scmi_imx_protocol.h index 2a96fc29cb6f4dd1e4c29e0aaaa614ae9783da4a..27bd372cbfb142b6acb0b1cf4b82f061529d0d45 100644 --- a/include/linux/scmi_imx_protocol.h +++ b/include/linux/scmi_imx_protocol.h @@ -16,6 +16,7 @@ #define SCMI_PROTOCOL_IMX_LMM 0x80 #define SCMI_PROTOCOL_IMX_BBM 0x81 +#define SCMI_PROTOCOL_IMX_CPU 0x82 #define SCMI_PROTOCOL_IMX_MISC 0x84 #define SCMI_IMX_VENDOR "NXP" @@ -89,4 +90,13 @@ struct scmi_imx_lmm_proto_ops { u32 flags); }; +struct scmi_imx_cpu_proto_ops { + int (*cpu_reset_vector_set)(const struct scmi_protocol_handle *ph, + u32 cpuid, u64 vector, bool start, + bool boot, bool resume); + int (*cpu_start)(const struct scmi_protocol_handle *ph, u32 cpuid, + bool start); + int (*cpu_started)(const struct scmi_protocol_handle *ph, u32 cpuid, + bool *started); +}; #endif