From patchwork Thu Jan 4 10:48:45 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Peng Fan \(OSS\)" X-Patchwork-Id: 760061 Received: from EUR02-VI1-obe.outbound.protection.outlook.com (mail-vi1eur02on2040.outbound.protection.outlook.com [40.107.241.40]) (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 ECA59210F0; Thu, 4 Jan 2024 10:44:54 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=oss.nxp.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.nxp.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=NXP1.onmicrosoft.com header.i=@NXP1.onmicrosoft.com header.b="JHeBpea3" ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=nINRsib9L2MPioXTYgQ3D01IPczqbM8Ow5XZFNOiJ1uIbf4E8kU4GvqGMIbd5aF1hbBObVvkyFjRE2YlteqvGThGpmoKNIPnsgGTGFaxQg7xJXUtgYBswCGQL/3v7uz8R3Cs7bn/HIP6Tw2c1KxJfkbxidwg9qY+xsm4KouZLq7rp73uj8js3gUTxVS8OJloQ0eQI8ANC8kWv8AxDTpPWxTgaVoMQy4HKe0kGO8g1jKVhL8D3ncOnBTr2sI2KVGxun/bemk9kmKpjuvX6ODi2tTKazVcN9VKkEEoNu1jd01lBzVAWKhOon6v1lNZsUxYs7GK/kvvikpoPKPwQ0K12g== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; 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=c8Q4gYjUQC14yC5W6QW/OwqgmYc1DkZqkRCHzTcTI5o=; b=AjuXufFRSuu7e6u6ptBmJT9FTpxBjAidKjWjATp+TZ0q7VQuCbseTYWNx8V31naEgnTXdM+OMixOa94L2Z2djX2hXoLh2yS3DLrewK34Xb4ATD7yD+tfkAZDpfAFd5oc0faspnspAIVDpPma7mAhkhPT30a5kRAZnOuXSzI97U2j6LX/tlyYZT/XtuQ7rB4ake6oh5Q/1Hk3PPVhKsNyrM7HiKWMOyCewE6Cq25jDh19MkiGZWn+VvtYYGtZbZXZl2N0KBPtQrgO2Gs8T9+PNxsX0z2R3yl1+/9bgvjnxLb2+bquuqy1e3wG9mf0AsVKCZHyxxSfQEmVH7O5hxlI+A== 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=selector2-NXP1-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=c8Q4gYjUQC14yC5W6QW/OwqgmYc1DkZqkRCHzTcTI5o=; b=JHeBpea39DfX5S3ePeg5lWEoqT5jR+Psi3cx9tuk+zRSpbEKderZKtYqHbntyLzZhhPfWdIzSOzXoKCK5AVE7dvzV3Wf1Purq8l+lyhG6pR0uuce5c/gx7byQskmElRr8qmGx8JdTQLLF3U2+aNGvYcx3XKQaqZeI9HndlVxzjg= Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=oss.nxp.com; Received: from DU0PR04MB9417.eurprd04.prod.outlook.com (2603:10a6:10:358::11) by PAXPR04MB8847.eurprd04.prod.outlook.com (2603:10a6:102:20e::16) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7135.25; Thu, 4 Jan 2024 10:44:51 +0000 Received: from DU0PR04MB9417.eurprd04.prod.outlook.com ([fe80::ff06:bbb2:c068:5fb3]) by DU0PR04MB9417.eurprd04.prod.outlook.com ([fe80::ff06:bbb2:c068:5fb3%7]) with mapi id 15.20.7135.023; Thu, 4 Jan 2024 10:44:51 +0000 From: "Peng Fan (OSS)" Date: Thu, 04 Jan 2024 18:48:45 +0800 Subject: [PATCH v2 1/6] firmware: arm_scmi: introduce helper get_max_msg_size Message-Id: <20240104-pinctrl-scmi-v2-1-a9bd86ab5a84@nxp.com> References: <20240104-pinctrl-scmi-v2-0-a9bd86ab5a84@nxp.com> In-Reply-To: <20240104-pinctrl-scmi-v2-0-a9bd86ab5a84@nxp.com> To: Sudeep Holla , Cristian Marussi , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Oleksii Moisieiev , Linus Walleij , Shawn Guo , Sascha Hauer , Pengutronix Kernel Team , Fabio Estevam , NXP Linux Team Cc: linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, linux-gpio@vger.kernel.org, AKASHI Takahiro , Peng Fan X-Mailer: b4 0.12.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1704365357; l=2660; i=peng.fan@nxp.com; s=20230812; h=from:subject:message-id; bh=woqhTHJgcBsnzMOI1imkT0MV1gtJZhQATiD3eryt0aA=; b=AfB8YdNCCChlIE9jt/x3WRkWZBYClWR/43M40BivfVd5eUxYH4kwJIKl+zhWFGgDFwSUbVrBO iqScQOzNKiaB6PB/8uLdfdI6kICzQiB7/S279wJTQNvEC3Y9GxTS0dB X-Developer-Key: i=peng.fan@nxp.com; a=ed25519; pk=I4sJg7atIT1g63H7bb5lDRGR2gJW14RKDD0wFL8TT1g= X-ClientProxiedBy: SG3P274CA0004.SGPP274.PROD.OUTLOOK.COM (2603:1096:4:be::16) To DU0PR04MB9417.eurprd04.prod.outlook.com (2603:10a6:10:358::11) Precedence: bulk X-Mailing-List: linux-gpio@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: DU0PR04MB9417:EE_|PAXPR04MB8847:EE_ X-MS-Office365-Filtering-Correlation-Id: fa7142cd-e896-41e9-7d89-08dc0d122e18 X-MS-Exchange-SharedMailbox-RoutingAgent-Processed: True X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: bSb17y8Mlj8yemrZWAdF0mc4EAfPFumNlELjS2fSAzYbPzyuZgsAW4b/F5Bpl4hAcJGEMSTMH1/S90ZQiwfUTG8h+KA8pU34Rz3BnqKVHO2+HhuI863xYAjShFqThiG5jEgSRXZtrrkj+cdob0bVk6+mtQOT12e+K5V4lylmiVtsU1KLycGE8/ABgVo1SpXfTyExtHZcqO57ApWcH57weTNNXl4RqqzRnOocBXMMfDqLjv2OcEoEeIxezauNZTblgczb6vN1OPhZ494DDeZ1gzvvYCpslravVJcWmjggJBQa+kFgO9q79AUoA4Tirmrp5flm5cI+R83hX3YZcr7gsISt8k+Wpb827hh16/Hr2WAgfFqh4VRXilbyEdSZBCjSbsKdbz0YYp4BHxqt15Rft5qrZkVJlIjKZmjE4VnmyiAmS4i0xSYZKwho/ayXf6Y8gIQIjwWcIsbSSSqpCkD/rIwyXJTMmsaXtAC0IsUTuE9kRUtZeh1CbECxrtSUTm1Y5LeXPeWUhDx/giKjqy4BNidTwfxpgkJQWY/lJZl4u1fDahkPKXe4tEoiY3p2Rv/EtRPnbd/70DSIxPN2l6/Ufl1Nk7pCkGWFNWal5LFQfR9K8Knem2oCqJNpQyZ70eitiisSEdStqFr/kZMdiAVNWA== X-Forefront-Antispam-Report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:DU0PR04MB9417.eurprd04.prod.outlook.com; PTR:; CAT:NONE; SFS:(13230031)(346002)(366004)(376002)(39860400002)(396003)(136003)(230922051799003)(64100799003)(1800799012)(451199024)(186009)(66476007)(66946007)(66556008)(6486002)(4326008)(8936002)(8676002)(26005)(54906003)(110136005)(316002)(83380400001)(6666004)(478600001)(52116002)(5660300002)(41300700001)(2906002)(7416002)(6506007)(6512007)(9686003)(38350700005)(921011)(36756003)(38100700002)(86362001); DIR:OUT; SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?q?c2aGIqMHQrZsQMOyfR2wzsfVPlkc?= =?utf-8?q?5Es/XigVaTEY4qG86H0Hwg5xFsiFfY8SKITsBTwGwfPUQ2xzL6yrq7KRUq9rypREd?= =?utf-8?q?eBXPyfzNQ9Z7RM1qQUnpdjyDHaALeOpVD52pE5H9M+SSUjCxxxGbgXnOk07/2rhfj?= =?utf-8?q?3oYAFNvZoUut0TfS8nRrPvuE6xe/3Ua6jOJzIw57fx1cElqMN6MzZd/cCrc/RgNP+?= =?utf-8?q?hQKzl9X/FQKZ9o9PTgnDZWIrzwbPMp2sPVKUtWQk8wMsHvEU51vdf2kwSjEQl8r8z?= =?utf-8?q?6Jce+Hd5IeZn6anHLM9UfMiwgwEXb/pxk8rKT3CB2WhcIyDiLrqAXhy9BezxpoAMj?= =?utf-8?q?VnrIHJ8Iu+g/gCtTQyTQZTJoIZKZrUlIu9tyGK18lWLHnfse5jUDmuV3HAyz8buf8?= =?utf-8?q?U1YGe0Rm7etq2rAgFnmk/51n9Ss5xSpwg0tF2P0qXmjWVPzmpHwhPwGFSXK7f6Wjw?= =?utf-8?q?VTGedEgzF1phL6KW+OaW1FDfIs67VmQNZUfLLSV8m7PPVCxdmVSK9kHOFT58AZTwg?= =?utf-8?q?Mw5iYoY4ArdgsxXG8BWQLrP+mr0Yiat9cRH+L06Oeu3qTAeFbpA5Kz7V1khi+Fq3a?= =?utf-8?q?1iXxE0tgFYbPDMxrgnjCMkKi8XZ5D70O/XBkj/1yY9DlhxmUbY0GjVjHyveHeJYaH?= =?utf-8?q?HO43lDCx4OIHz0OgyKRCIRmgR/AcWk5zpl+IGivXCu5ORBFa8vR+ZCUBT9XdiCcgE?= =?utf-8?q?DX1hJtgezw6gmG11fvbhKt/9L/dOOr8i7pAAEvVcGA79aLe/D6sAvROMD4+Omm+P7?= =?utf-8?q?0dZPHqeX/QtYkM/fhHhbc9nCRxtkIFTGX0kA5phTVzbG5r6kwl3tqH881Xna60mdx?= =?utf-8?q?8WFcxNH81Bdz/NI++iPy/s8Byw5E+bs8RAUchd9z+fa1C0M09v3CjKx6oZIpL5NHW?= =?utf-8?q?Dm+w1YZjUTc2hUioDVEWuzyvTldILhJmv1BTmu9IX2xvZsrGYMDeZXhZUqQc/dDQ6?= =?utf-8?q?Z+su884Zx59ZUzT9K+b3SdGHvwAcC2iKTs4HmyLoowYEMcCZa1FEFsgKE2WUG/leA?= =?utf-8?q?1/ZBw9CM2F6vHVjcYyD5O9Tv3Y0dMynW09Wla4hK8XGmBKIywx8InTvOwzHwOOR63?= =?utf-8?q?pGofJx7an4sc1jUHh+SKqO8m5y10xYXDriMEt3D8qDJRTnzViV6RLUC9JtXjDVsq6?= =?utf-8?q?Q7FNsSlrKKIQvgX0mbdra0mdiOCQJGiV9Cr6AxV5vF2+F0zliYV6sjEw1hXTb3ila?= =?utf-8?q?iUWB0JaYl+E8BKJTTLW9Zjo5yjd3PlW/j/I6sC4Nf532Mj7vvDMjk9qrFu3GWP3Lv?= =?utf-8?q?8W7bsT9EMe5mzB8kC4+eciyLvy7bu+S19lim3raiJb2NbnbUol0Vy7n4xIzK5LKlr?= =?utf-8?q?mJ+pWXwUWUJOCaTmdIGn22hEseAX9t3Cjdz/7SmDa2ZpAvtBZgMIFQKa5ZYGGz1Tn?= =?utf-8?q?pfLlW3uIgEnXQxVIgz+Zr5/Q6rE0X2jyl3oeK/9+FBNGdRI39YfxtogRtl4waCj0m?= =?utf-8?q?BIp3aSDJQ9bz+a2dtgdTusM1LP8vVDIS4kafQGWaWHQkerU9sKo6q5mKZsUiu0Pzu?= =?utf-8?q?/fR3q2elYVw7?= X-OriginatorOrg: oss.nxp.com X-MS-Exchange-CrossTenant-Network-Message-Id: fa7142cd-e896-41e9-7d89-08dc0d122e18 X-MS-Exchange-CrossTenant-AuthSource: DU0PR04MB9417.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 04 Jan 2024 10:44:51.4932 (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: 2QYSMJrDSzIN6uf/s6qV2JvssjoB56WCBZS6QPTpwHn2JB5Z8lPKeMlYBWUl5ccbfP5m5foPxbhyf6tkvzRNlQ== X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAXPR04MB8847 From: Peng Fan When Agent sending data to SCMI server, the Agent driver could check the size to avoid protocol buffer overflow. So introduce the helper get_max_msg_size. Reviewed-by: Cristian Marussi Signed-off-by: Peng Fan --- drivers/firmware/arm_scmi/driver.c | 15 +++++++++++++++ drivers/firmware/arm_scmi/protocols.h | 2 ++ 2 files changed, 17 insertions(+) diff --git a/drivers/firmware/arm_scmi/driver.c b/drivers/firmware/arm_scmi/driver.c index 3ea64b22cf0d..a12afc254afa 100644 --- a/drivers/firmware/arm_scmi/driver.c +++ b/drivers/firmware/arm_scmi/driver.c @@ -1481,6 +1481,20 @@ static int scmi_common_extended_name_get(const struct scmi_protocol_handle *ph, return ret; } +/** + * scmi_common_get_max_msg_size - Get maximum message size + * @ph: A protocol handle reference. + * + * Return: Maximum message size for the current protocol. + */ +static int scmi_common_get_max_msg_size(const struct scmi_protocol_handle *ph) +{ + const struct scmi_protocol_instance *pi = ph_to_pi(ph); + struct scmi_info *info = handle_to_scmi_info(pi->handle); + + return info->desc->max_msg_size; +} + /** * struct scmi_iterator - Iterator descriptor * @msg: A reference to the message TX buffer; filled by @prepare_message with @@ -1756,6 +1770,7 @@ static void scmi_common_fastchannel_db_ring(struct scmi_fc_db_info *db) static const struct scmi_proto_helpers_ops helpers_ops = { .extended_name_get = scmi_common_extended_name_get, + .get_max_msg_size = scmi_common_get_max_msg_size, .iter_response_init = scmi_iterator_init, .iter_response_run = scmi_iterator_run, .fastchannel_init = scmi_common_fastchannel_init, diff --git a/drivers/firmware/arm_scmi/protocols.h b/drivers/firmware/arm_scmi/protocols.h index e683c26f24eb..b5c65f26207b 100644 --- a/drivers/firmware/arm_scmi/protocols.h +++ b/drivers/firmware/arm_scmi/protocols.h @@ -254,6 +254,7 @@ struct scmi_fc_info { * @fastchannel_init: A common helper used to initialize FC descriptors by * gathering FC descriptions from the SCMI platform server. * @fastchannel_db_ring: A common helper to ring a FC doorbell. + * @get_max_msg_size: A common helper to get the maximum message size. */ struct scmi_proto_helpers_ops { int (*extended_name_get)(const struct scmi_protocol_handle *ph, @@ -270,6 +271,7 @@ struct scmi_proto_helpers_ops { void __iomem **p_addr, struct scmi_fc_db_info **p_db); void (*fastchannel_db_ring)(struct scmi_fc_db_info *db); + int (*get_max_msg_size)(const struct scmi_protocol_handle *ph); }; /** From patchwork Thu Jan 4 10:48:46 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Peng Fan \(OSS\)" X-Patchwork-Id: 760571 Received: from EUR02-VI1-obe.outbound.protection.outlook.com (mail-vi1eur02on2051.outbound.protection.outlook.com [40.107.241.51]) (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 1379A2110E; Thu, 4 Jan 2024 10:44:59 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=oss.nxp.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.nxp.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=NXP1.onmicrosoft.com header.i=@NXP1.onmicrosoft.com header.b="XnZ1/9AU" ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=QUZA5ViqP0swAaKRqlYwYLug5XQsrkl5VIKXa72D6RNgLmK5BLf4kP1z2u5ooob1xvaBmxf+1Hy2MpwEFfn1cvbDSWFDdG7p4BoHsKQkNY9h7xQWCt7t91ESf8A5fgYlZax5CtgGl8ul7s56tmtGFN64vToAKwJVce0RRjwbbwWTDMECpfXEEy+VkN72lUI9dzBMXSS0sw2YPhrLv1uI4fgcWxTXhZdrkneaQZ7lRaDEueqHyS8Bi+o/cexZ5GDcfRzXICEQ++uxuj9lbJIVb8eUo+mlW4elc8i8fw4Ox8FlrgFeai5eF/8JPdiPlk9zbSZZmdwbEbvApr9jLpq9Fw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; 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=+TeAOLAWJPpeQL55Zv+G3UCSTYmfxkGW6A62IaXCW9I=; b=YPQkELJgFDPiUhJzCpXRtrfT5YDHII2Gq7ESUipkZa7Qku9tKyF1xblMRVJ/xh894cc5IN22DHwLg9KnWVRKMcCOPnrppq6/hhn9r5TKvk5T+frPJDYj4ohfjCQZgp070F9xb7BE1G8mhEE1ndPW0TVpJEKE88OSqrl1p5QwJvm/UUbPjGPUGN7jX+ysAGkObIc8ViE8uskX84md+RmIeDet7eV/Qpp7F7j3AuBLA5z+Owuldt2tMjjfm20rS/NxTmv0uEWUZ0iCWOSW2Tec31XPGAQJjEehXM5gejB6w/X4AG5FcEbGL8SRKb1G8UqkUTojq5IWcjhgRb0RGkWpHw== 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=selector2-NXP1-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=+TeAOLAWJPpeQL55Zv+G3UCSTYmfxkGW6A62IaXCW9I=; b=XnZ1/9AUHz3kLf8M8QA33vtP+Zqa7Beu4TlA+JWOkPhIi6PvaiIJ3L9843FJ6RRfa2dEYDTLoSXVWBICt2x21s0nJSzNFuTDSUoBaY7SbFesYaXQ4Q6fMzYekrU3Vf8SbilXGyutz8asUFr0UFrH3OOomuN6gsrthJDsD6TlHnM= Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=oss.nxp.com; Received: from DU0PR04MB9417.eurprd04.prod.outlook.com (2603:10a6:10:358::11) by PAXPR04MB8847.eurprd04.prod.outlook.com (2603:10a6:102:20e::16) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7135.25; Thu, 4 Jan 2024 10:44:56 +0000 Received: from DU0PR04MB9417.eurprd04.prod.outlook.com ([fe80::ff06:bbb2:c068:5fb3]) by DU0PR04MB9417.eurprd04.prod.outlook.com ([fe80::ff06:bbb2:c068:5fb3%7]) with mapi id 15.20.7135.023; Thu, 4 Jan 2024 10:44:56 +0000 From: "Peng Fan (OSS)" Date: Thu, 04 Jan 2024 18:48:46 +0800 Subject: [PATCH v2 2/6] dt-bindings: firmware: arm,scmi: support pinctrl protocol Message-Id: <20240104-pinctrl-scmi-v2-2-a9bd86ab5a84@nxp.com> References: <20240104-pinctrl-scmi-v2-0-a9bd86ab5a84@nxp.com> In-Reply-To: <20240104-pinctrl-scmi-v2-0-a9bd86ab5a84@nxp.com> To: Sudeep Holla , Cristian Marussi , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Oleksii Moisieiev , Linus Walleij , Shawn Guo , Sascha Hauer , Pengutronix Kernel Team , Fabio Estevam , NXP Linux Team Cc: linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, linux-gpio@vger.kernel.org, AKASHI Takahiro , Peng Fan X-Mailer: b4 0.12.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1704365357; l=2276; i=peng.fan@nxp.com; s=20230812; h=from:subject:message-id; bh=BeunIXuoC9ojxhc94JLz5YEyvI/486KOwO+7ZGw6L4w=; b=vYbFJOSCLSbZthRGxRcwIkpgzxSoxy6EWRZkq9/tcqqnFR6M6BNw5iRP9KFC0mgYdrAFy3GzV uaF3fi7yGTABq5JDPsBD0a+w8AEsWoDVFhBfTpTt76AEZYl745315Uu X-Developer-Key: i=peng.fan@nxp.com; a=ed25519; pk=I4sJg7atIT1g63H7bb5lDRGR2gJW14RKDD0wFL8TT1g= X-ClientProxiedBy: SG3P274CA0004.SGPP274.PROD.OUTLOOK.COM (2603:1096:4:be::16) To DU0PR04MB9417.eurprd04.prod.outlook.com (2603:10a6:10:358::11) Precedence: bulk X-Mailing-List: linux-gpio@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: DU0PR04MB9417:EE_|PAXPR04MB8847:EE_ X-MS-Office365-Filtering-Correlation-Id: d4764564-1bf9-4778-49ac-08dc0d12312b X-MS-Exchange-SharedMailbox-RoutingAgent-Processed: True X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: Vddey871izLmp4AVHuPoCTkBBdsWmBDLQs5VpG+f2oAEhh+wP0DIoNtOTsd08uKfY7dpkR2vI0ztxjebcqUb2lIqxTqlfR//B8LxircmuiUpImxPJZh7WghQdR81cQvaYzdwW5cbs28RxsPRjT+gsa/+sr0xsKCXQJYe9v6C/FMeqCBYlaovw0SRY9Fen6tgoZOVrcXuzTev6RwELWBDX7IeQbYycY1ZT+vokJdEW+esoYvkXhxo0JTWJ8hDX3+hW9+drIqDMH6qE1U7vzy5loGI/JWlf55PjK/HepCQPKhA26SFZycs1ewoqT5doOgYOEy7R4XD19se7hBq4o9Od49SaztLI/ARXj+yiRr6V1kPn0fOPR/Urjy2elw2HvdN7qEXkfonZciH2A5BWU/ABaEUDcF6ROg4/Oex7+GDWHW7vJQgspNQfH4AEeurgXIjhZMCutaWBrRlMnVhREG/6hLH6uNbp4z/L5GQgF5KHzrURVQ+8g3h9UXwd5+u+eIH/k2dCuaayKgQFwbG9OAWlq6eewFliCkZ8L222CmQrEVmoqPV9DM7EZwtiOGkm4M/Thfjozkf/YtvBSZSFYwg0Mw6WRyZzOfYRETX8DqyEW608wMLih3E2+6qwY0DJLiCylWNAjsg8jQ37/9J+jTmGw== X-Forefront-Antispam-Report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:DU0PR04MB9417.eurprd04.prod.outlook.com; PTR:; CAT:NONE; SFS:(13230031)(346002)(366004)(376002)(39860400002)(396003)(136003)(230922051799003)(64100799003)(1800799012)(451199024)(186009)(66476007)(66946007)(66556008)(6486002)(4326008)(8936002)(8676002)(26005)(54906003)(110136005)(316002)(6666004)(478600001)(52116002)(5660300002)(41300700001)(2906002)(7416002)(6506007)(6512007)(9686003)(38350700005)(921011)(36756003)(38100700002)(86362001); DIR:OUT; SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?q?aOJpR7PT2i8bnruXiuIwh1anY4tp?= =?utf-8?q?TBjptcUW1+4TGgZ1SPjosGZwLg/ZwEim3T8EoKX4mWFhz0IA/dZbG4Jgttjlv+1Oe?= =?utf-8?q?JCrO+zEf1AsxFWgb9HUMZu4zX9ApnpBIQ/+J01AMz2wAXeENxeEXrcvB4Ym7XLjBN?= =?utf-8?q?GBrrB4RZc3NpTn51lJGdlVKkpi9jD3Nfx0fq3KnC+nVFKaYxjDxddaVPGiRLSlcAi?= =?utf-8?q?WqcfRcN0zgM0qtSWy5dnQ3F6X9bSDWKvC4cl/C4y/1EqGqXKxJ47qZ+Kvr2836/BG?= =?utf-8?q?7u2kJqqzS7fcHs77XCl/P5Y89Wdlt4vNyEwq8wLQiJtQbuTx1dXaPpOssRn2N4b9m?= =?utf-8?q?oBkEX6zQjm3PCaLa/DDp/gQYDftaW+eaCk0wRsIMNniL35NZLuOGIBKLMETFiBVHc?= =?utf-8?q?ADG4p1yOJO7kSPkAEhitMhPLIJsLYYokevxrHn92zmiUg3qCGGLQNBbFBmaNFnt5H?= =?utf-8?q?yTMUaQrc06ZL1Cc8gpY7JKnhLPnARfOBhgDJVs9f2DZdR9n/8V3R8gJFzh+ooMOuq?= =?utf-8?q?LuGPRqDyGYmNDYP8kzVUavTCxkeqI5Z612M4iYAXXganoWNHYWBDY3+zj09ZGBGd4?= =?utf-8?q?9vVi/1yraV0zmOzGFsz6hXbrw8ntqFQ/0AO3fYKU2zPbKCL7l2D4jqeOlV1ncIDY6?= =?utf-8?q?YmTcG9gS0xxyYUs6nKXPXjNjAXVXIRliE3/gEi79fj88whiWY4ez0GiDQre4iWwH0?= =?utf-8?q?d7VO5aYEM1Nwv4sUvuadGQtDsLJpo4KY6RbKp9RDVs9rQhmqAThgY4Pl3ceji1d/K?= =?utf-8?q?ODpy8xUudIysXHc4oTT4KTkj28M+gDDu9ZEPOxXIqNwgUU+tdI1iUrCnCD2T0Jn85?= =?utf-8?q?oyH7BACHuVjWn6QzuUHIzNk0osEZ4Uiqu/jxcuyjkRmo1aizQnLwnE5ERFuiCXgv/?= =?utf-8?q?nKMyAapg/zBaB82BnIYLe62by0f+BjaIhObRsEaJhe/2A5Pt9SiqUSMvqNjCsOO7M?= =?utf-8?q?3oSa3QM/7r+2LdwP1O/iZWCwUBXfp8lkNWRDYlmPVrdiLTyBg2a8R03lqU904/zO4?= =?utf-8?q?zPIVAYOIZBd5hDGDHC3v3omvIntw1qyvtEmkvkmm7X6VhiWnfni052vLRDSXvbKjF?= =?utf-8?q?DMGTGYf9oQwq8yZNyu7BfUugAzavMfMJkEQ5W4IXUcBTYqd2l4DsAwamnyR1ZqyYk?= =?utf-8?q?c5K/vA1dT06PQhNFI6gMIuxGtD6jJJTKqzoFy8YhZQyMhdltsnv3+yrAL589Drhn7?= =?utf-8?q?x/ZcWuFRkSa4poHQnuuCIk7rqUsvdfCRopn4u7PCSRmpIeeQBI9xh4suOrnHptHz3?= =?utf-8?q?/RVm+XqUDxeJBak0ZU8ywpy7h6pZGNZLrevYlTlKGOb+UhTbPyGKzEVGJQC0v792S?= =?utf-8?q?GGhuNnHb6PJeFqM86CVnGuvau77UK83mGULOvZH/gYB2dZcbmvYWChUR6uYoIGF6k?= =?utf-8?q?6Pmpk3XBzmq6JC0GzH/ab8dUAJU8PQx+e6987zW23y27y3Or0l+4bF/5lqCL75VWT?= =?utf-8?q?Ai3KMhLXGJTNKnTsxtmakshPaAwXRQlBZ12LrhDxA+cGry1NpSLLUUH/Z/4r22GjU?= =?utf-8?q?hfJAp+1CvoWL?= X-OriginatorOrg: oss.nxp.com X-MS-Exchange-CrossTenant-Network-Message-Id: d4764564-1bf9-4778-49ac-08dc0d12312b X-MS-Exchange-CrossTenant-AuthSource: DU0PR04MB9417.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 04 Jan 2024 10:44:56.6449 (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: lf8FE82Vvnn7tiDYbOazopD3hSaPeNCN3CaPQLSmIJAHy/zvCg8AqaSBs0JOZiu7vtxrH/E/Fg0VMmYbVtG1SQ== X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAXPR04MB8847 From: Peng Fan Add SCMI v3.2 pinctrl protocol bindings and example. Signed-off-by: Peng Fan Reviewed-by: Rob Herring Reviewed-by: Linus Walleij --- .../devicetree/bindings/firmware/arm,scmi.yaml | 50 ++++++++++++++++++++++ 1 file changed, 50 insertions(+) diff --git a/Documentation/devicetree/bindings/firmware/arm,scmi.yaml b/Documentation/devicetree/bindings/firmware/arm,scmi.yaml index 4591523b51a0..bba4a37de6b4 100644 --- a/Documentation/devicetree/bindings/firmware/arm,scmi.yaml +++ b/Documentation/devicetree/bindings/firmware/arm,scmi.yaml @@ -247,6 +247,37 @@ properties: reg: const: 0x18 + protocol@19: + type: object + allOf: + - $ref: '#/$defs/protocol-node' + - $ref: /schemas/pinctrl/pinctrl.yaml + + unevaluatedProperties: false + + properties: + reg: + const: 0x19 + + patternProperties: + '-pins$': + type: object + allOf: + - $ref: /schemas/pinctrl/pincfg-node.yaml# + - $ref: /schemas/pinctrl/pinmux-node.yaml# + unevaluatedProperties: false + + description: + A pin multiplexing sub-node describe how to configure a + set of pins is some desired function. + A single sub-node may define several pin configurations. + This sub-node is using default pinctrl bindings to configure + pin multiplexing and using SCMI protocol to apply specified + configuration using SCMI protocol. + + required: + - reg + additionalProperties: false $defs: @@ -401,6 +432,25 @@ examples: scmi_powercap: protocol@18 { reg = <0x18>; }; + + scmi_pinctrl: protocol@19 { + reg = <0x19>; + + i2c2-pins { + groups = "g_i2c2_a", "g_i2c2_b"; + function = "f_i2c2"; + }; + + mdio-pins { + groups = "g_avb_mdio"; + drive-strength = <24>; + }; + + keys_pins: keys-pins { + pins = "gpio_5_17", "gpio_5_20", "gpio_5_22", "gpio_2_1"; + bias-pull-up; + }; + }; }; }; From patchwork Thu Jan 4 10:48:47 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Peng Fan \(OSS\)" X-Patchwork-Id: 760060 Received: from EUR02-VI1-obe.outbound.protection.outlook.com (mail-vi1eur02on2047.outbound.protection.outlook.com [40.107.241.47]) (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 5885E20312; Thu, 4 Jan 2024 10:45:06 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=oss.nxp.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.nxp.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=NXP1.onmicrosoft.com header.i=@NXP1.onmicrosoft.com header.b="B65NjVW3" ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=f8tNNVkgyN5kllZAVTCoLimWSKWot+rTnnCsQyTAiLLEa4M+GAAyuI9DExCqqS2Sml3+q7bD3ej5I7QTW/uW0kYpWjbcy16fg96Vpld3qLaDT92OUa3JMEMDcgyV9apUN29BLIwVFWq1Q/YlkJlmnml/XuB3/Ko4UKKwuWLg0RoLUwZxFnqL/Ndv8tms8ZdpuleyPg10KlhMYN3TSoKaVeYXA+G6JI3VySJQi6RsRJkeS5AMjsCWJRzkonw4b4RuVMsKAMjMdq72in3YP9UZZaKeIT3PZ72Mc0W5tYPCAnzhevuP8I5hWkTB1ljwKL1R5y6Io7NN3N1LUvvqy+X3Hw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; 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=XN+OpbrcmTMT4H3pi5hwwbDfxt1SyViDK34Q/cTJNEg=; b=NI9qsy0dTQv61u3qPtXZ4jK9EaOFzBjUlzSfhlMWr92PnzJrIETztW18YZzPPd05U1sPK2222dAalyRqd9nL55a9M4rACIlDXwTy0pZPRujHi3oAfrz1W1vFh6X1QcS26+kxcdkNwIy9aBOI1z3nPtfUD87Bh8p9vXxthtppE4ai5m4sDVIRNoZYEE40Ir3vlztiCCSZrGcTM6Yb5HSUw/0TLWXzib7ZEcxgGmMMQmF64ilRi7RVDjBa0lPmJDS04fATboPtcbcK+OOjq+45MaAsc7fXzQ6+ZBs6KlbyCY51adTsVQ2X1mPu0e279ao3wUFJxMGJynSRF5Aca2cP7w== 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=selector2-NXP1-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=XN+OpbrcmTMT4H3pi5hwwbDfxt1SyViDK34Q/cTJNEg=; b=B65NjVW3M8CqYyVGkdQhS+lgsfZOKWtZB2j5J1e7KSxF9wY1TvLJsbNluFBi7S3AJP1ocaxeKJItiUPuf4IwgBkQU2QwL7SPUKqhAl41qgXNGbVWQRqgrcZ3JCjVf7alJ2xFbfY7qBZendrbbyEXdTLWZYkUP8Hp4IAJEcgjMNk= Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=oss.nxp.com; Received: from DU0PR04MB9417.eurprd04.prod.outlook.com (2603:10a6:10:358::11) by PAXPR04MB8847.eurprd04.prod.outlook.com (2603:10a6:102:20e::16) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7135.25; Thu, 4 Jan 2024 10:45:02 +0000 Received: from DU0PR04MB9417.eurprd04.prod.outlook.com ([fe80::ff06:bbb2:c068:5fb3]) by DU0PR04MB9417.eurprd04.prod.outlook.com ([fe80::ff06:bbb2:c068:5fb3%7]) with mapi id 15.20.7135.023; Thu, 4 Jan 2024 10:45:02 +0000 From: "Peng Fan (OSS)" Date: Thu, 04 Jan 2024 18:48:47 +0800 Subject: [PATCH v2 3/6] firmware: arm_scmi: Add SCMI v3.2 pincontrol protocol basic support Message-Id: <20240104-pinctrl-scmi-v2-3-a9bd86ab5a84@nxp.com> References: <20240104-pinctrl-scmi-v2-0-a9bd86ab5a84@nxp.com> In-Reply-To: <20240104-pinctrl-scmi-v2-0-a9bd86ab5a84@nxp.com> To: Sudeep Holla , Cristian Marussi , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Oleksii Moisieiev , Linus Walleij , Shawn Guo , Sascha Hauer , Pengutronix Kernel Team , Fabio Estevam , NXP Linux Team Cc: linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, linux-gpio@vger.kernel.org, AKASHI Takahiro , Peng Fan , Oleksii Moisieiev X-Mailer: b4 0.12.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1704365357; l=30286; i=peng.fan@nxp.com; s=20230812; h=from:subject:message-id; bh=KwPmf5cWc8W/xn3nA8DTSRpevUkumXSUbPjKCYtwWrQ=; b=Na/pwstiQ5z6NjDIBOK8omu2kBeTPOIVQEOOfZ0BXIwZ0FKKptgbyIfEfs3gDKOxJTInv943q vuMq4rDF/L7CsPiY3m0kOykK/PPToeI72fCT0wrnCiu4pvayr5D5CyZ X-Developer-Key: i=peng.fan@nxp.com; a=ed25519; pk=I4sJg7atIT1g63H7bb5lDRGR2gJW14RKDD0wFL8TT1g= X-ClientProxiedBy: SG3P274CA0004.SGPP274.PROD.OUTLOOK.COM (2603:1096:4:be::16) To DU0PR04MB9417.eurprd04.prod.outlook.com (2603:10a6:10:358::11) Precedence: bulk X-Mailing-List: linux-gpio@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: DU0PR04MB9417:EE_|PAXPR04MB8847:EE_ X-MS-Office365-Filtering-Correlation-Id: cb250456-8d82-4252-6234-08dc0d12346b X-MS-Exchange-SharedMailbox-RoutingAgent-Processed: True X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: wljW7zLNQnLWR5xGo/9286BPDhYdU16CCFiRfrBO6ypO1wMkljzptYc98Y1Q7rdOESZemj3vG4wL+qao83x9AssfMJQ4gAHJwhxVtIPn8Fj5pWNfar/glppG4ZRwCb69F6ADJA3C/h5PrDZ7C4QmOfYLrQVzjmBJklREuq0OcBS8rHVY71Fz6GmworaZ10nttDEKKFkdYfILnT1iMQISwzXSCfV48evNouRLW8ubqTMFPCbQ6MjE6NLfO7BnTzo6HYX753E0F/Ozb4r8PIdvXKwbWneS4mil39OcFDZ52MMfShJD8+2gE41pQ07qP5wTgpaMchK+qbp0itivg//AqjxYX8+RKKFbmdIO7sSz86iEF1QHCnFPDmKzZwAAsTamOE2N+W3TC0PhhG49rYj3141kqpX7uElpR/Q1KlIL/1ZwJKEKt231I8f6WAgvVgvtNK6rYO5kT3CJtPwbx1Ettsq60JdHqK1u2e9NuqklNEwuJGabAnVv0MtLtiK1uOJ/juFJRyu3d2CR312QWpfcgCjT+9d8uU6CGT7p/j6/UyGCPZylhL92cOI97rhrQSPQKbfPG6rgQlU9Jk2gzNmjA7rdNdK1twS8OxDHlhIiXpqfmyub2HVek60uwATe9VX6tEOpxBZvBSV4iJiGRvmcvQ== X-Forefront-Antispam-Report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:DU0PR04MB9417.eurprd04.prod.outlook.com; PTR:; CAT:NONE; SFS:(13230031)(346002)(366004)(376002)(39860400002)(396003)(136003)(230922051799003)(64100799003)(1800799012)(451199024)(186009)(66476007)(66946007)(66556008)(6486002)(4326008)(8936002)(8676002)(26005)(54906003)(110136005)(316002)(83380400001)(6666004)(478600001)(52116002)(5660300002)(41300700001)(30864003)(2906002)(7416002)(6506007)(6512007)(9686003)(38350700005)(921011)(36756003)(38100700002)(86362001); DIR:OUT; SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?q?hcTwMSMs6XWA1SxmC4OkFipogaJa?= =?utf-8?q?SPl6ehJsoqCLAyju3AN3rKPXcSa5AElvmxwzz1DKRcG7y4wtzG4vKpgXe6R1IkvgM?= =?utf-8?q?NjTph0yLFqa555w8MUN2fpAKgp90Ik6eyja1ggNZkv0m0uFD9VwDy05gNol6Pfs9W?= =?utf-8?q?419so80j1aMjGXznMWKEM6eaG8MbM2xvSnIHnFlWJA5OeWE4uRvMUnTReKIiry8tB?= =?utf-8?q?dX+ut8xbO9FF+rs+gSuTbpRvxTaqeRMkMxaSYCBl72X6klsiuBfK1ynTZ0Xb69V1e?= =?utf-8?q?HfPAShSE5ESUIoPMBW5wOJISH+JfYRB7n/n78+h+l3Qe/7S1SIxc//A0p0pftW/ny?= =?utf-8?q?o9qrAu9NRvoe3kE0v5KwgwuU7UfzwyDXsGNb39iWCXf9+Qhm2phJg/H1l8pyiYiA2?= =?utf-8?q?gQvN4NYFP6mTY0jmAikbQqFTPQJQDfE/0OEfbqdquj/5ApwYFt41HadA94qEyZ07J?= =?utf-8?q?hvCPPR7GIft3vd1jj/EGZ5icPc8PujAM9pv8uUxwABIW58WCZQEVxq+9tBcBFhBfn?= =?utf-8?q?QNOaf1zBb4TBbshfdOVf1KvQ7wopoqhGCGhOILR8g+G5JwvRrH/iZp7IS1eESOG0n?= =?utf-8?q?mZeJonkedU9I1G08o78L7wUrsFn0wEzeG6ulJHbQbYoWNwEb3rkSd03kkr6nmELEE?= =?utf-8?q?bqICbAQWVfpWygbfjGThAUCu2/DisLisvy35PIyEsnUgJhl8I93W8xnNdpZCS42OX?= =?utf-8?q?3TtCGMQq0Kuc8zkRjczqTc/Saa2E0y3SY5CZnfmMLkIfmlQRBCz+S3O1QF1Xtp3Xb?= =?utf-8?q?GPnzX4oWW8bWqiI/nbf/SPOlEwbha9wm6o0fRqyW6KeeejTJkyBsT7EO+gHG5hA1j?= =?utf-8?q?4Np6zwoze+V/SdgxSkOOlyeVt4GTvYkZOYdiKDEV3MkfF+sbkbNfAiTbDtU8ar0s+?= =?utf-8?q?/XWd/cfqOTq4CuM0KSEpNLnCvFgUHMG1YGZxanvxyc6VnKAxnndvuyYuTf6kZXBCz?= =?utf-8?q?iYuBYQn0S23AObu7VJ07AnRAnZEBFFwKlp6vdm1PoWQZc2dF1xKtxuuy54/xUd1DZ?= =?utf-8?q?jDXtJhby6/Sd6F+HaV9Oxo28BC483w7N1kgEgkaNdyQBv/XBY5/smPI643dyEEtj0?= =?utf-8?q?ocWmoZu2Gio3OPWmfdTWBzBKH/dhTAVoX8H2aqZ8qbavVsOCFTVQok8uO3vyLdNg5?= =?utf-8?q?ZFcSYq5FQgu2JZX38kzo9nJf7oZ3DcxWNAsYBNVKT0XSkBbKats3J2L+QmiSK58c+?= =?utf-8?q?ZXMwiWrNJ6EB+1JkImq/iyzN3yBW3nn1paKVxiod2H5MeZ6CJP/RGNaDJS9Otj7z9?= =?utf-8?q?PI10L/s3QtklwhpstqQPRCj4F948QIyXi5RzYLs5Rem0Ey0P1KBf5fXG1PV2OaWN5?= =?utf-8?q?dx7UEkL6tDyoYl/1bsHxELVJDNpQMOy/T0aE0zBCP2WbYEDMBltQs8ga8Q0Z1LTH/?= =?utf-8?q?IN9x2PejhtEuXV7fBYN25otixCfBUESX7hWdHTwx5tPB32vAQZaMkukCbRJrx2Ib7?= =?utf-8?q?0+WlH2R/4teCz5+xOD5rs/MXgsgAiS8Jasc9p0ANQkUY3tPQp02MMZuzTdVhic5eK?= =?utf-8?q?tvCnolbUef/a?= X-OriginatorOrg: oss.nxp.com X-MS-Exchange-CrossTenant-Network-Message-Id: cb250456-8d82-4252-6234-08dc0d12346b X-MS-Exchange-CrossTenant-AuthSource: DU0PR04MB9417.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 04 Jan 2024 10:45:02.1492 (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: gqBGZYgebGvYFfI7T3+j9cV3O0e/5L+08thAfj0VOKqJinokIcdPlykjJTY9o/OYHXpSLsjsvtF0v9LGZCtBaA== X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAXPR04MB8847 From: Oleksii Moisieiev Add basic implementation of the SCMI v3.2 pincontrol protocol. Signed-off-by: Oleksii Moisieiev Co-developed-by: Peng Fan Signed-off-by: Peng Fan --- MAINTAINERS | 6 + drivers/firmware/arm_scmi/Makefile | 1 + drivers/firmware/arm_scmi/driver.c | 2 + drivers/firmware/arm_scmi/pinctrl.c | 930 ++++++++++++++++++++++++++++++++++ drivers/firmware/arm_scmi/protocols.h | 1 + include/linux/scmi_protocol.h | 73 +++ 6 files changed, 1013 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index 0275a2c58f0f..487bff0d44c0 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -21322,6 +21322,12 @@ F: include/linux/sc[mp]i_protocol.h F: include/trace/events/scmi.h F: include/uapi/linux/virtio_scmi.h +SYSTEM CONTROL MANAGEMENT INTERFACE (SCMI) PINCTRL DRIVER +M: Oleksii Moisieiev +L: linux-arm-kernel@lists.infradead.org +S: Maintained +F: drivers/firmware/arm_scmi/pinctrl.c + SYSTEM RESET/SHUTDOWN DRIVERS M: Sebastian Reichel L: linux-pm@vger.kernel.org diff --git a/drivers/firmware/arm_scmi/Makefile b/drivers/firmware/arm_scmi/Makefile index a7bc4796519c..8e3874ff1544 100644 --- a/drivers/firmware/arm_scmi/Makefile +++ b/drivers/firmware/arm_scmi/Makefile @@ -11,6 +11,7 @@ scmi-transport-$(CONFIG_ARM_SCMI_HAVE_MSG) += msg.o scmi-transport-$(CONFIG_ARM_SCMI_TRANSPORT_VIRTIO) += virtio.o scmi-transport-$(CONFIG_ARM_SCMI_TRANSPORT_OPTEE) += optee.o scmi-protocols-y = base.o clock.o perf.o power.o reset.o sensors.o system.o voltage.o powercap.o +scmi-protocols-y += pinctrl.o scmi-module-objs := $(scmi-driver-y) $(scmi-protocols-y) $(scmi-transport-y) obj-$(CONFIG_ARM_SCMI_PROTOCOL) += scmi-core.o diff --git a/drivers/firmware/arm_scmi/driver.c b/drivers/firmware/arm_scmi/driver.c index a12afc254afa..4c3752749105 100644 --- a/drivers/firmware/arm_scmi/driver.c +++ b/drivers/firmware/arm_scmi/driver.c @@ -3050,6 +3050,7 @@ static int __init scmi_driver_init(void) scmi_voltage_register(); scmi_system_register(); scmi_powercap_register(); + scmi_pinctrl_register(); return platform_driver_register(&scmi_driver); } @@ -3067,6 +3068,7 @@ static void __exit scmi_driver_exit(void) scmi_voltage_unregister(); scmi_system_unregister(); scmi_powercap_unregister(); + scmi_pinctrl_unregister(); scmi_transports_exit(); diff --git a/drivers/firmware/arm_scmi/pinctrl.c b/drivers/firmware/arm_scmi/pinctrl.c new file mode 100644 index 000000000000..aa6e698e7b7c --- /dev/null +++ b/drivers/firmware/arm_scmi/pinctrl.c @@ -0,0 +1,930 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * System Control and Management Interface (SCMI) Pinctrl Protocol + * + * Copyright (C) 2023 EPAM + */ + +#include +#include +#include + +#include "common.h" +#include "protocols.h" + +/* Updated only after ALL the mandatory features for that version are merged */ +#define SCMI_PROTOCOL_SUPPORTED_VERSION 0x40000 + +#define REG_TYPE_BITS GENMASK(9, 8) +#define REG_CONFIG GENMASK(7, 0) + +#define GET_GROUPS_NR(x) le32_get_bits((x), GENMASK(31, 16)) +#define GET_PINS_NR(x) le32_get_bits((x), GENMASK(15, 0)) +#define GET_FUNCTIONS_NR(x) le32_get_bits((x), GENMASK(15, 0)) + +#define EXT_NAME_FLAG(x) le32_get_bits((x), BIT(31)) +#define NUM_ELEMS(x) le32_get_bits((x), GENMASK(15, 0)) + +#define REMAINING(x) le32_get_bits((x), GENMASK(31, 16)) +#define RETURNED(x) le32_get_bits((x), GENMASK(11, 0)) + +enum scmi_pinctrl_protocol_cmd { + PINCTRL_ATTRIBUTES = 0x3, + PINCTRL_LIST_ASSOCIATIONS = 0x4, + PINCTRL_CONFIG_GET = 0x5, + PINCTRL_CONFIG_SET = 0x6, + PINCTRL_FUNCTION_SELECT = 0x7, + PINCTRL_REQUEST = 0x8, + PINCTRL_RELEASE = 0x9, + PINCTRL_NAME_GET = 0xa, + PINCTRL_SET_PERMISSIONS = 0xb +}; + +struct scmi_msg_conf_set { + __le32 identifier; + __le32 attributes; + __le32 configs[]; +}; + +struct scmi_msg_conf_get { + __le32 identifier; + __le32 attributes; +}; + +struct scmi_resp_conf_get { + __le32 num_configs; + __le32 configs[]; +}; + +struct scmi_msg_pinctrl_protocol_attributes { + __le32 attributes_low; + __le32 attributes_high; +}; + +struct scmi_msg_pinctrl_attributes { + __le32 identifier; + __le32 flags; +}; + +struct scmi_resp_pinctrl_attributes { + __le32 attributes; + u8 name[SCMI_SHORT_NAME_MAX_SIZE]; +}; + +struct scmi_msg_pinctrl_list_assoc { + __le32 identifier; + __le32 flags; + __le32 index; +}; + +struct scmi_resp_pinctrl_list_assoc { + __le32 flags; + __le16 array[]; +}; + +struct scmi_msg_func_set { + __le32 identifier; + __le32 function_id; + __le32 flags; +}; + +struct scmi_msg_request { + __le32 identifier; + __le32 flags; +}; + +struct scmi_group_info { + char name[SCMI_MAX_STR_SIZE]; + bool present; + unsigned int *group_pins; + unsigned int nr_pins; +}; + +struct scmi_function_info { + char name[SCMI_MAX_STR_SIZE]; + bool present; + unsigned int *groups; + unsigned int nr_groups; +}; + +struct scmi_pin_info { + char name[SCMI_MAX_STR_SIZE]; + bool present; +}; + +struct scmi_pinctrl_info { + u32 version; + int nr_groups; + int nr_functions; + int nr_pins; + struct scmi_group_info *groups; + struct scmi_function_info *functions; + struct scmi_pin_info *pins; +}; + +static int scmi_pinctrl_attributes_get(const struct scmi_protocol_handle *ph, + struct scmi_pinctrl_info *pi) +{ + int ret; + struct scmi_xfer *t; + struct scmi_msg_pinctrl_protocol_attributes *attr; + + 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) { + pi->nr_functions = GET_FUNCTIONS_NR(attr->attributes_high); + pi->nr_groups = GET_GROUPS_NR(attr->attributes_low); + pi->nr_pins = GET_PINS_NR(attr->attributes_low); + } + + ph->xops->xfer_put(ph, t); + return ret; +} + +static int scmi_pinctrl_count_get(const struct scmi_protocol_handle *ph, + enum scmi_pinctrl_selector_type type) +{ + struct scmi_pinctrl_info *pi = ph->get_priv(ph); + + switch (type) { + case PIN_TYPE: + return pi->nr_pins; + case GROUP_TYPE: + return pi->nr_groups; + case FUNCTION_TYPE: + return pi->nr_functions; + default: + return -EINVAL; + } +} + +static int scmi_pinctrl_validate_id(const struct scmi_protocol_handle *ph, + u32 identifier, + enum scmi_pinctrl_selector_type type) +{ + int value; + + value = scmi_pinctrl_count_get(ph, type); + if (value < 0) + return value; + + if (identifier >= value) + return -EINVAL; + + return 0; +} + +static int scmi_pinctrl_attributes(const struct scmi_protocol_handle *ph, + enum scmi_pinctrl_selector_type type, + u32 selector, char *name, + unsigned int *n_elems) +{ + int ret; + struct scmi_xfer *t; + struct scmi_msg_pinctrl_attributes *tx; + struct scmi_resp_pinctrl_attributes *rx; + + if (!name) + return -EINVAL; + + ret = scmi_pinctrl_validate_id(ph, selector, type); + if (ret) + return ret; + + ret = ph->xops->xfer_get_init(ph, PINCTRL_ATTRIBUTES, sizeof(*tx), sizeof(*rx), &t); + if (ret) + return ret; + + tx = t->tx.buf; + rx = t->rx.buf; + tx->identifier = cpu_to_le32(selector); + tx->flags = cpu_to_le32(type); + + ret = ph->xops->do_xfer(ph, t); + if (!ret) { + if (n_elems) + *n_elems = NUM_ELEMS(rx->attributes); + + strscpy(name, rx->name, SCMI_SHORT_NAME_MAX_SIZE); + } + + ph->xops->xfer_put(ph, t); + + /* + * If supported overwrite short name with the extended one; + * on error just carry on and use already provided short name. + */ + if (!ret && EXT_NAME_FLAG(rx->attributes)) + ph->hops->extended_name_get(ph, PINCTRL_NAME_GET, selector, + (u32 *)&type, name, + SCMI_MAX_STR_SIZE); + return ret; +} + +struct scmi_pinctrl_ipriv { + u32 selector; + enum scmi_pinctrl_selector_type type; + unsigned int *array; +}; + +static void iter_pinctrl_assoc_prepare_message(void *message, + unsigned int desc_index, + const void *priv) +{ + struct scmi_msg_pinctrl_list_assoc *msg = message; + const struct scmi_pinctrl_ipriv *p = priv; + + msg->identifier = cpu_to_le32(p->selector); + msg->flags = cpu_to_le32(p->type); + /* Set the number of OPPs to be skipped/already read */ + msg->index = cpu_to_le32(desc_index); +} + +static int iter_pinctrl_assoc_update_state(struct scmi_iterator_state *st, + const void *response, void *priv) +{ + const struct scmi_resp_pinctrl_list_assoc *r = response; + + st->num_returned = RETURNED(r->flags); + st->num_remaining = REMAINING(r->flags); + + return 0; +} + +static int +iter_pinctrl_assoc_process_response(const struct scmi_protocol_handle *ph, + const void *response, + struct scmi_iterator_state *st, void *priv) +{ + const struct scmi_resp_pinctrl_list_assoc *r = response; + struct scmi_pinctrl_ipriv *p = priv; + + p->array[st->desc_index + st->loop_idx] = + le16_to_cpu(r->array[st->loop_idx]); + + return 0; +} + +static int scmi_pinctrl_list_associations(const struct scmi_protocol_handle *ph, + u32 selector, + enum scmi_pinctrl_selector_type type, + u16 size, unsigned int *array) +{ + int ret; + void *iter; + struct scmi_iterator_ops ops = { + .prepare_message = iter_pinctrl_assoc_prepare_message, + .update_state = iter_pinctrl_assoc_update_state, + .process_response = iter_pinctrl_assoc_process_response, + }; + struct scmi_pinctrl_ipriv ipriv = { + .selector = selector, + .type = type, + .array = array, + }; + + if (!array || !size || type == PIN_TYPE) + return -EINVAL; + + ret = scmi_pinctrl_validate_id(ph, selector, type); + if (ret) + return ret; + + iter = ph->hops->iter_response_init(ph, &ops, size, + PINCTRL_LIST_ASSOCIATIONS, + sizeof(struct scmi_msg_pinctrl_list_assoc), + &ipriv); + + if (IS_ERR(iter)) + return PTR_ERR(iter); + + return ph->hops->iter_response_run(iter); +} + +struct scmi_conf_get_ipriv { + u32 selector; + enum scmi_pinctrl_selector_type type; + u8 all; + u8 *config_types; + u32 *config_values; +}; + +static void iter_pinctrl_conf_get_prepare_message(void *message, + unsigned int desc_index, + const void *priv) +{ + struct scmi_msg_conf_get *msg = message; + const struct scmi_conf_get_ipriv *p = priv; + u32 attributes; + + attributes = FIELD_PREP(BIT(18), p->all) | + FIELD_PREP(GENMASK(17, 16), p->type); + + if (p->all) + attributes |= FIELD_PREP(GENMASK(15, 8), desc_index); + else + attributes |= FIELD_PREP(GENMASK(7, 0), p->config_types[0]); + + msg->attributes = cpu_to_le32(attributes); + msg->identifier = cpu_to_le32(p->selector); +} + +static int iter_pinctrl_conf_get_update_state(struct scmi_iterator_state *st, + const void *response, void *priv) +{ + const struct scmi_resp_conf_get *r = response; + struct scmi_conf_get_ipriv *p = priv; + + if (!p->all) { + st->num_returned = 1; + st->num_remaining = 0; + } else { + st->num_returned = le32_get_bits(r->num_configs, GENMASK(7, 0)); + st->num_remaining = le32_get_bits(r->num_configs, GENMASK(31, 24)); + } + + return 0; +} + +static int iter_pinctrl_conf_get_process_response(const struct scmi_protocol_handle *ph, + const void *response, + struct scmi_iterator_state *st, void *priv) +{ + const struct scmi_resp_conf_get *r = response; + struct scmi_conf_get_ipriv *p = priv; + + if (!p->all) { + if (p->config_types[0] != + le32_get_bits(r->configs[st->loop_idx * 2], GENMASK(7, 0))) + return -EINVAL; + } else { + p->config_types[st->desc_index + st->loop_idx] = + le32_get_bits(r->configs[st->loop_idx * 2], GENMASK(7, 0)); + } + + p->config_values[st->desc_index + st->loop_idx] = + le32_to_cpu(r->configs[st->loop_idx * 2 + 1]); + + return 0; +} + +static int scmi_pinctrl_config_get(const struct scmi_protocol_handle *ph, + u32 selector, + enum scmi_pinctrl_selector_type type, + u8 config_type, u32 *config_value) +{ + int ret; + void *iter; + struct scmi_iterator_ops ops = { + .prepare_message = iter_pinctrl_conf_get_prepare_message, + .update_state = iter_pinctrl_conf_get_update_state, + .process_response = iter_pinctrl_conf_get_process_response, + }; + struct scmi_conf_get_ipriv ipriv = { + .selector = selector, + .type = type, + .all = 0, + .config_types = &config_type, + .config_values = config_value, + }; + + if (!config_value || type == FUNCTION_TYPE) + return -EINVAL; + + ret = scmi_pinctrl_validate_id(ph, selector, type); + if (ret) + return ret; + + iter = ph->hops->iter_response_init(ph, &ops, 1, PINCTRL_CONFIG_GET, + sizeof(struct scmi_msg_conf_get), + &ipriv); + + if (IS_ERR(iter)) + return PTR_ERR(iter); + + return ph->hops->iter_response_run(iter); +} + +static int scmi_pinctrl_config_get_all(const struct scmi_protocol_handle *ph, + u32 selector, + enum scmi_pinctrl_selector_type type, + u16 size, u8 *config_types, + u32 *config_values) +{ + int ret; + void *iter; + struct scmi_iterator_ops ops = { + .prepare_message = iter_pinctrl_conf_get_prepare_message, + .update_state = iter_pinctrl_conf_get_update_state, + .process_response = iter_pinctrl_conf_get_process_response, + }; + struct scmi_conf_get_ipriv ipriv = { + .selector = selector, + .type = type, + .all = 1, + .config_types = config_types, + .config_values = config_values, + }; + + if (!config_values || !config_types || type == FUNCTION_TYPE) + return -EINVAL; + + ret = scmi_pinctrl_validate_id(ph, selector, type); + if (ret) + return ret; + + iter = ph->hops->iter_response_init(ph, &ops, size, PINCTRL_CONFIG_GET, + sizeof(struct scmi_msg_conf_get), + &ipriv); + + if (IS_ERR(iter)) + return PTR_ERR(iter); + + return ph->hops->iter_response_run(iter); +} + +static int scmi_pinctrl_config_set(const struct scmi_protocol_handle *ph, + u32 selector, enum scmi_pinctrl_selector_type type, + unsigned int nr_configs, u8 *config_type, + u32 *config_value) +{ + struct scmi_xfer *t; + struct scmi_msg_conf_set *tx; + u32 attributes; + int ret, i; + unsigned int configs_in_chunk, conf_num = 0; + unsigned int chunk; + int max_msg_size = ph->hops->get_max_msg_size(ph); + + if (!config_type || !config_value || type == FUNCTION_TYPE) + return -EINVAL; + + ret = scmi_pinctrl_validate_id(ph, selector, type); + if (ret) + return ret; + + configs_in_chunk = (max_msg_size - sizeof(*tx)) / (sizeof(__le32) * 2); + while (conf_num < nr_configs) { + chunk = (nr_configs - conf_num > configs_in_chunk) ? configs_in_chunk : + nr_configs - conf_num; + + ret = ph->xops->xfer_get_init(ph, PINCTRL_CONFIG_SET, + sizeof(*tx) + chunk * 2 * sizeof(__le32), + 0, &t); + if (ret) + return ret; + + tx = t->tx.buf; + tx->identifier = cpu_to_le32(selector); + attributes = FIELD_PREP(GENMASK(1, 0), type) | + FIELD_PREP(GENMASK(9, 2), chunk); + tx->attributes = cpu_to_le32(attributes); + + for (i = 0; i < chunk; i++) { + tx->configs[i * 2] = cpu_to_le32(config_type[conf_num + i]); + tx->configs[i * 2 + 1] = cpu_to_le32(config_value[conf_num + i]); + } + + ret = ph->xops->do_xfer(ph, t); + + ph->xops->xfer_put(ph, t); + + if (ret) + break; + + conf_num += chunk; + } + + return ret; +} + +static int scmi_pinctrl_function_select(const struct scmi_protocol_handle *ph, + u32 identifier, + enum scmi_pinctrl_selector_type type, + u32 function_id) +{ + int ret; + struct scmi_xfer *t; + struct scmi_msg_func_set *tx; + + if (type == FUNCTION_TYPE) + return -EINVAL; + + ret = scmi_pinctrl_validate_id(ph, identifier, type); + if (ret) + return ret; + + ret = ph->xops->xfer_get_init(ph, PINCTRL_FUNCTION_SELECT, sizeof(*tx), 0, &t); + if (ret) + return ret; + + tx = t->tx.buf; + tx->identifier = cpu_to_le32(identifier); + tx->function_id = cpu_to_le32(function_id); + tx->flags = cpu_to_le32(type); + + ret = ph->xops->do_xfer(ph, t); + ph->xops->xfer_put(ph, t); + + return ret; +} + +static int scmi_pinctrl_request(const struct scmi_protocol_handle *ph, + u32 identifier, + enum scmi_pinctrl_selector_type type) +{ + int ret; + struct scmi_xfer *t; + struct scmi_msg_request *tx; + + if (type == FUNCTION_TYPE) + return -EINVAL; + + ret = scmi_pinctrl_validate_id(ph, identifier, type); + if (ret) + return ret; + + ret = ph->xops->xfer_get_init(ph, PINCTRL_REQUEST, sizeof(*tx), 0, &t); + + tx = t->tx.buf; + tx->identifier = cpu_to_le32(identifier); + tx->flags = cpu_to_le32(type); + + ret = ph->xops->do_xfer(ph, t); + ph->xops->xfer_put(ph, t); + + return ret; +} + +static int scmi_pinctrl_pin_request(const struct scmi_protocol_handle *ph, + u32 pin) +{ + return scmi_pinctrl_request(ph, pin, PIN_TYPE); +} + +static int scmi_pinctrl_free(const struct scmi_protocol_handle *ph, + u32 identifier, + enum scmi_pinctrl_selector_type type) +{ + int ret; + struct scmi_xfer *t; + struct scmi_msg_request *tx; + + if (type == FUNCTION_TYPE) + return -EINVAL; + + ret = scmi_pinctrl_validate_id(ph, identifier, type); + if (ret) + return ret; + + ret = ph->xops->xfer_get_init(ph, PINCTRL_RELEASE, sizeof(*tx), 0, &t); + + tx = t->tx.buf; + tx->identifier = cpu_to_le32(identifier); + tx->flags = cpu_to_le32(type); + + ret = ph->xops->do_xfer(ph, t); + ph->xops->xfer_put(ph, t); + + return ret; +} + +static int scmi_pinctrl_pin_free(const struct scmi_protocol_handle *ph, u32 pin) +{ + return scmi_pinctrl_free(ph, pin, PIN_TYPE); +} + +static int scmi_pinctrl_get_group_info(const struct scmi_protocol_handle *ph, + u32 selector, + struct scmi_group_info *group) +{ + int ret; + + if (!group) + return -EINVAL; + + ret = scmi_pinctrl_attributes(ph, GROUP_TYPE, selector, + group->name, + &group->nr_pins); + if (ret) + return ret; + + if (!group->nr_pins) { + dev_err(ph->dev, "Group %d has 0 elements", selector); + return -ENODATA; + } + + group->group_pins = kmalloc_array(group->nr_pins, sizeof(*group->group_pins), GFP_KERNEL); + if (!group->group_pins) + return -ENOMEM; + + ret = scmi_pinctrl_list_associations(ph, selector, GROUP_TYPE, + group->nr_pins, group->group_pins); + if (ret) { + kfree(group->group_pins); + return ret; + } + + group->present = true; + return 0; +} + +static int scmi_pinctrl_get_group_name(const struct scmi_protocol_handle *ph, + u32 selector, const char **name) +{ + struct scmi_pinctrl_info *pi = ph->get_priv(ph); + + if (!name) + return -EINVAL; + + if (selector >= pi->nr_groups) + return -EINVAL; + + if (!pi->groups[selector].present) { + int ret; + + ret = scmi_pinctrl_get_group_info(ph, selector, + &pi->groups[selector]); + if (ret) + return ret; + } + + *name = pi->groups[selector].name; + + return 0; +} + +static int scmi_pinctrl_group_pins_get(const struct scmi_protocol_handle *ph, + u32 selector, const unsigned int **pins, + unsigned int *nr_pins) +{ + struct scmi_pinctrl_info *pi = ph->get_priv(ph); + + if (!pins || !nr_pins) + return -EINVAL; + + if (selector >= pi->nr_groups) + return -EINVAL; + + if (!pi->groups[selector].present) { + int ret; + + ret = scmi_pinctrl_get_group_info(ph, selector, + &pi->groups[selector]); + if (ret) + return ret; + } + + *pins = pi->groups[selector].group_pins; + *nr_pins = pi->groups[selector].nr_pins; + + return 0; +} + +static int scmi_pinctrl_get_function_info(const struct scmi_protocol_handle *ph, + u32 selector, + struct scmi_function_info *func) +{ + int ret; + + if (!func) + return -EINVAL; + + ret = scmi_pinctrl_attributes(ph, FUNCTION_TYPE, selector, + func->name, + &func->nr_groups); + if (ret) + return ret; + + if (!func->nr_groups) { + dev_err(ph->dev, "Function %d has 0 elements", selector); + return -ENODATA; + } + + func->groups = kmalloc_array(func->nr_groups, sizeof(*func->groups), GFP_KERNEL); + if (!func->groups) + return -ENOMEM; + + ret = scmi_pinctrl_list_associations(ph, selector, FUNCTION_TYPE, + func->nr_groups, func->groups); + if (ret) { + kfree(func->groups); + return ret; + } + + func->present = true; + return 0; +} + +static int scmi_pinctrl_get_function_name(const struct scmi_protocol_handle *ph, + u32 selector, const char **name) +{ + struct scmi_pinctrl_info *pi = ph->get_priv(ph); + + if (!name) + return -EINVAL; + + if (selector >= pi->nr_functions) + return -EINVAL; + + if (!pi->functions[selector].present) { + int ret; + + ret = scmi_pinctrl_get_function_info(ph, selector, + &pi->functions[selector]); + if (ret) + return ret; + } + + *name = pi->functions[selector].name; + return 0; +} + +static int scmi_pinctrl_function_groups_get(const struct scmi_protocol_handle *ph, + u32 selector, + unsigned int *nr_groups, + const unsigned int **groups) +{ + struct scmi_pinctrl_info *pi = ph->get_priv(ph); + + if (!groups || !nr_groups) + return -EINVAL; + + if (selector >= pi->nr_functions) + return -EINVAL; + + if (!pi->functions[selector].present) { + int ret; + + ret = scmi_pinctrl_get_function_info(ph, selector, + &pi->functions[selector]); + if (ret) + return ret; + } + + *groups = pi->functions[selector].groups; + *nr_groups = pi->functions[selector].nr_groups; + + return 0; +} + +static int scmi_pinctrl_mux_set(const struct scmi_protocol_handle *ph, + u32 selector, u32 group) +{ + return scmi_pinctrl_function_select(ph, group, GROUP_TYPE, + selector); +} + +static int scmi_pinctrl_get_pin_info(const struct scmi_protocol_handle *ph, + u32 selector, struct scmi_pin_info *pin) +{ + int ret; + + if (!pin) + return -EINVAL; + + ret = scmi_pinctrl_attributes(ph, PIN_TYPE, selector, + pin->name, NULL); + if (ret) + return ret; + + pin->present = true; + return 0; +} + +static int scmi_pinctrl_get_pin_name(const struct scmi_protocol_handle *ph, + u32 selector, const char **name) +{ + struct scmi_pinctrl_info *pi = ph->get_priv(ph); + + if (!name) + return -EINVAL; + + if (selector >= pi->nr_pins) + return -EINVAL; + + if (!pi->pins[selector].present) { + int ret; + + ret = scmi_pinctrl_get_pin_info(ph, selector, + &pi->pins[selector]); + if (ret) + return ret; + } + + *name = pi->pins[selector].name; + + return 0; +} + +static int scmi_pinctrl_name_get(const struct scmi_protocol_handle *ph, + u32 selector, + enum scmi_pinctrl_selector_type type, + const char **name) +{ + switch (type) { + case PIN_TYPE: + return scmi_pinctrl_get_pin_name(ph, selector, name); + case GROUP_TYPE: + return scmi_pinctrl_get_group_name(ph, selector, name); + case FUNCTION_TYPE: + return scmi_pinctrl_get_function_name(ph, selector, name); + default: + return -EINVAL; + } +} + +static const struct scmi_pinctrl_proto_ops pinctrl_proto_ops = { + .count_get = scmi_pinctrl_count_get, + .name_get = scmi_pinctrl_name_get, + .group_pins_get = scmi_pinctrl_group_pins_get, + .function_groups_get = scmi_pinctrl_function_groups_get, + .mux_set = scmi_pinctrl_mux_set, + .config_get = scmi_pinctrl_config_get, + .config_get_all = scmi_pinctrl_config_get_all, + .config_set = scmi_pinctrl_config_set, + .pin_request = scmi_pinctrl_pin_request, + .pin_free = scmi_pinctrl_pin_free, +}; + +static int scmi_pinctrl_protocol_init(const struct scmi_protocol_handle *ph) +{ + int ret; + u32 version; + struct scmi_pinctrl_info *pinfo; + + ret = ph->xops->version_get(ph, &version); + if (ret) + return ret; + + dev_dbg(ph->dev, "Pinctrl Version %d.%d\n", + PROTOCOL_REV_MAJOR(version), PROTOCOL_REV_MINOR(version)); + + pinfo = devm_kzalloc(ph->dev, sizeof(*pinfo), GFP_KERNEL); + if (!pinfo) + return -ENOMEM; + + ret = scmi_pinctrl_attributes_get(ph, pinfo); + if (ret) + return ret; + + pinfo->pins = devm_kcalloc(ph->dev, pinfo->nr_pins, + sizeof(*pinfo->pins), + GFP_KERNEL); + if (!pinfo->pins) + return -ENOMEM; + + pinfo->groups = devm_kcalloc(ph->dev, pinfo->nr_groups, + sizeof(*pinfo->groups), + GFP_KERNEL); + if (!pinfo->groups) + return -ENOMEM; + + pinfo->functions = devm_kcalloc(ph->dev, pinfo->nr_functions, + sizeof(*pinfo->functions), + GFP_KERNEL); + if (!pinfo->functions) + return -ENOMEM; + + pinfo->version = version; + + return ph->set_priv(ph, pinfo, version); +} + +static int scmi_pinctrl_protocol_deinit(const struct scmi_protocol_handle *ph) +{ + int i; + struct scmi_pinctrl_info *pi = ph->get_priv(ph); + + for (i = 0; i < pi->nr_groups; i++) { + if (pi->groups[i].present) { + kfree(pi->groups[i].group_pins); + pi->groups[i].present = false; + } + } + + for (i = 0; i < pi->nr_functions; i++) { + if (pi->functions[i].present) { + kfree(pi->functions[i].groups); + pi->functions[i].present = false; + } + } + + return 0; +} + +static const struct scmi_protocol scmi_pinctrl = { + .id = SCMI_PROTOCOL_PINCTRL, + .owner = THIS_MODULE, + .instance_init = &scmi_pinctrl_protocol_init, + .instance_deinit = &scmi_pinctrl_protocol_deinit, + .ops = &pinctrl_proto_ops, + .supported_version = SCMI_PROTOCOL_SUPPORTED_VERSION, +}; + +DEFINE_SCMI_PROTOCOL_REGISTER_UNREGISTER(pinctrl, scmi_pinctrl) diff --git a/drivers/firmware/arm_scmi/protocols.h b/drivers/firmware/arm_scmi/protocols.h index b5c65f26207b..996410962b91 100644 --- a/drivers/firmware/arm_scmi/protocols.h +++ b/drivers/firmware/arm_scmi/protocols.h @@ -348,6 +348,7 @@ void __exit scmi_##name##_unregister(void) \ DECLARE_SCMI_REGISTER_UNREGISTER(base); DECLARE_SCMI_REGISTER_UNREGISTER(clock); DECLARE_SCMI_REGISTER_UNREGISTER(perf); +DECLARE_SCMI_REGISTER_UNREGISTER(pinctrl); DECLARE_SCMI_REGISTER_UNREGISTER(power); DECLARE_SCMI_REGISTER_UNREGISTER(reset); DECLARE_SCMI_REGISTER_UNREGISTER(sensors); diff --git a/include/linux/scmi_protocol.h b/include/linux/scmi_protocol.h index f2f05fb42d28..d8e2bb828ee7 100644 --- a/include/linux/scmi_protocol.h +++ b/include/linux/scmi_protocol.h @@ -717,6 +717,78 @@ struct scmi_powercap_proto_ops { u32 *power_thresh_high); }; +enum scmi_pinctrl_selector_type { + PIN_TYPE = 0, + GROUP_TYPE, + FUNCTION_TYPE, +}; + +/** + * struct scmi_pinctrl_proto_ops - represents the various operations provided + * by SCMI Pinctrl Protocol + * + * @count_get: returns count of the registered elements in given type + * @name_get: returns name by index of given type + * @group_pins_get: returns the set of pins, assigned to the specified group + * @function_groups_get: returns the set of groups, assigned to the specified + * function + * @mux_set: set muxing function for groups of pins + * @config_get: returns configuration parameter for pin or group + * @config_set: sets the configuration parameter for pin or group + * @pin_request: aquire pin before selecting mux setting + * @pin_free: frees pin, acquired by request_pin call + */ +struct scmi_pinctrl_proto_ops { + int (*count_get)(const struct scmi_protocol_handle *ph, + enum scmi_pinctrl_selector_type type); + int (*name_get)(const struct scmi_protocol_handle *ph, u32 selector, + enum scmi_pinctrl_selector_type type, const char **name); + int (*group_pins_get)(const struct scmi_protocol_handle *ph, u32 selector, + const unsigned int **pins, unsigned int *nr_pins); + int (*function_groups_get)(const struct scmi_protocol_handle *ph, u32 selector, + unsigned int *nr_groups, const unsigned int **groups); + int (*mux_set)(const struct scmi_protocol_handle *ph, u32 selector, u32 group); + int (*config_get)(const struct scmi_protocol_handle *ph, u32 selector, + enum scmi_pinctrl_selector_type type, + u8 config_type, u32 *config_value); + int (*config_get_all)(const struct scmi_protocol_handle *ph, + u32 selector, + enum scmi_pinctrl_selector_type type, u16 size, + u8 *config_types, u32 *config_values); + int (*config_set)(const struct scmi_protocol_handle *ph, u32 selector, + enum scmi_pinctrl_selector_type type, + unsigned int nr_configs, + u8 *config_type, u32 *config_value); + int (*pin_request)(const struct scmi_protocol_handle *ph, u32 pin); + int (*pin_free)(const struct scmi_protocol_handle *ph, u32 pin); +}; + +enum scmi_pinctrl_conf_type { + SCMI_PIN_NONE = 0x0, + SCMI_PIN_BIAS_BUS_HOLD = 0x1, + SCMI_PIN_BIAS_DISABLE = 0x2, + SCMI_PIN_BIAS_HIGH_IMPEDANCE = 0x3, + SCMI_PIN_BIAS_PULL_UP = 0x4, + SCMI_PIN_BIAS_PULL_DEFAULT = 0x5, + SCMI_PIN_BIAS_PULL_DOWN = 0x6, + SCMI_PIN_DRIVE_OPEN_DRAIN = 0x7, + SCMI_PIN_DRIVE_OPEN_SOURCE = 0x8, + SCMI_PIN_DRIVE_PUSH_PULL = 0x9, + SCMI_PIN_DRIVE_STRENGTH = 0xA, + SCMI_PIN_INPUT_DEBOUNCE = 0xB, + SCMI_PIN_INPUT_MODE = 0xC, + SCMI_PIN_PULL_MODE = 0xD, + SCMI_PIN_INPUT_VALUE = 0xE, + SCMI_PIN_INPUT_SCHMITT = 0xF, + SCMI_PIN_LOW_POWER_MODE = 0x10, + SCMI_PIN_OUTPUT_MODE = 0x11, + SCMI_PIN_OUTPUT_VALUE = 0x12, + SCMI_PIN_POWER_SOURCE = 0x13, + SCMI_PIN_SLEW_RATE = 0x20, + SCMI_PIN_OEM_START = 0xC0, + SCMI_PIN_OEM_END = 0xFF, +}; + /** * struct scmi_notify_ops - represents notifications' operations provided by * SCMI core @@ -824,6 +896,7 @@ enum scmi_std_protocol { SCMI_PROTOCOL_RESET = 0x16, SCMI_PROTOCOL_VOLTAGE = 0x17, SCMI_PROTOCOL_POWERCAP = 0x18, + SCMI_PROTOCOL_PINCTRL = 0x19, }; enum scmi_system_events { From patchwork Thu Jan 4 10:48:48 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Peng Fan \(OSS\)" X-Patchwork-Id: 760570 Received: from EUR02-VI1-obe.outbound.protection.outlook.com (mail-vi1eur02on2047.outbound.protection.outlook.com [40.107.241.47]) (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 7F6E421376; Thu, 4 Jan 2024 10:45:09 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=oss.nxp.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.nxp.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=NXP1.onmicrosoft.com header.i=@NXP1.onmicrosoft.com header.b="KEcEJ8VY" ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=dpSte67HKY5PcKV7jBjd2j3hlBKXp/c57AoC9Oki84gtu1ybmyM0WKS+5rcFnGSOjIusC9H5l5WAG0uH3bIr+839LrEX0w0mzXQ86+vmzzuwBvqPmL4sc/fxUmvfmhudYW2vh7Feqt+1486imlWC9kX0UhUmwP2Xc/pZHs9YyzYvxMMf4djZn4Yv/zND9pIiegdnSabzBd5i9F9PjN3nsjEZaVGOigsWM/npNLsUMGXSC+sh9gNY6Om66JFqCfCChzsnGn1pJcGVHOzWCDfn8xgYKV5oO2/+52c3UM83Hz+DbQKx56Zzqn7wHRE0+Kt6iW8nltjHJCSQYUGftfftkw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; 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=9RB2NHo/fYiKMwFb0jNvCwZrzOOaa97W60fFoi29rg8=; b=IAOCsPV3fSKm3ZFPI9NiRx88wLrdFp1ajsIFf+DfHUzk4jnsXdHyRxt5GpMG1vSLCFDezPn8IepOJsfqAcp+bclHRuQoTTKa+8MMTBxJ9JuRH4BeFjVQELaHlL9iQPzeEWFp9WcIkvkXNe7Vozt9axTlUveFfd3RpMqmU+SEalKgIIIa2kq1VKIoWJkuwyc/Ii1Fg4DreZtdEWxXmbcpj6w3bAs2XS4ycFCrse4gVqyMJ4Tb6tlOArGvWhYLdQvwSmHxFMvA1FJkYI2N+pInxXCe+SukJr7rObA6M7msy30Fs5QkAQ7X2D4bth+yzP/nIQgeKJiB9Dgkl4eiYZaDXg== 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=selector2-NXP1-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=9RB2NHo/fYiKMwFb0jNvCwZrzOOaa97W60fFoi29rg8=; b=KEcEJ8VY0OKl7D8jMn/VjKYJnFQC59A37+kt8i2tCkdrTFiB3L7cPkhidEaCfsrghfoSrIEuQ6m9awZef4ybDOzmcSF9N6VqMyh1dA2INKXVXz7R8C7EgI2WbSEn9B6roNHhua9uT1vcgcGZJtfRZp0S2z8wb/nWCu47wPwz0no= Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=oss.nxp.com; Received: from DU0PR04MB9417.eurprd04.prod.outlook.com (2603:10a6:10:358::11) by PAXPR04MB8847.eurprd04.prod.outlook.com (2603:10a6:102:20e::16) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7135.25; Thu, 4 Jan 2024 10:45:07 +0000 Received: from DU0PR04MB9417.eurprd04.prod.outlook.com ([fe80::ff06:bbb2:c068:5fb3]) by DU0PR04MB9417.eurprd04.prod.outlook.com ([fe80::ff06:bbb2:c068:5fb3%7]) with mapi id 15.20.7135.023; Thu, 4 Jan 2024 10:45:07 +0000 From: "Peng Fan (OSS)" Date: Thu, 04 Jan 2024 18:48:48 +0800 Subject: [PATCH v2 4/6] pinctrl: Implementation of the generic scmi-pinctrl driver Message-Id: <20240104-pinctrl-scmi-v2-4-a9bd86ab5a84@nxp.com> References: <20240104-pinctrl-scmi-v2-0-a9bd86ab5a84@nxp.com> In-Reply-To: <20240104-pinctrl-scmi-v2-0-a9bd86ab5a84@nxp.com> To: Sudeep Holla , Cristian Marussi , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Oleksii Moisieiev , Linus Walleij , Shawn Guo , Sascha Hauer , Pengutronix Kernel Team , Fabio Estevam , NXP Linux Team Cc: linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, linux-gpio@vger.kernel.org, AKASHI Takahiro , Peng Fan X-Mailer: b4 0.12.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1704365357; l=17128; i=peng.fan@nxp.com; s=20230812; h=from:subject:message-id; bh=sieGniu0UyEJ3MN5HvOjYsYbKv/d/KecFgmaODuXpu8=; b=LQ6ET6szHpOH2rga2Kgo+H8jYOaRPvBWbd0QbHZpZ6/leboz10a3SZ1jQ0xrnczqKDNJV1p0k t1Y3UDL9GURB0Rg62Ilc5F9GXGLuU4YwrY1IS7e1ZMHyLBhcJgZ5XQU X-Developer-Key: i=peng.fan@nxp.com; a=ed25519; pk=I4sJg7atIT1g63H7bb5lDRGR2gJW14RKDD0wFL8TT1g= X-ClientProxiedBy: SG3P274CA0004.SGPP274.PROD.OUTLOOK.COM (2603:1096:4:be::16) To DU0PR04MB9417.eurprd04.prod.outlook.com (2603:10a6:10:358::11) Precedence: bulk X-Mailing-List: linux-gpio@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: DU0PR04MB9417:EE_|PAXPR04MB8847:EE_ X-MS-Office365-Filtering-Correlation-Id: 8aca705a-cda5-4ad4-b772-08dc0d123787 X-MS-Exchange-SharedMailbox-RoutingAgent-Processed: True X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: duU+4g8LeqW1zVm2GQsmgXtZMWq6aqpHMQKeT/Jj/hNz2DVdijWcHXgIbjPnUMqP/0gM8joV4IXfxkCPtAEwvNH//+G76CNDfIFxgWEtH/BtHcaZKoOr71NCPk9k+hE8Gl+KqNRmNbYd2bf5ZbuwL/J904h1lUI1FfpbTj6ckxn79c1hAdQ287+AVJlxR5T9QYmsUDA3evUJW2w47AlpbWjje4daJIZq6C95Q3tC/kq3koXKtytRb+hd2GZl9awk1OHkj90dF30HF/0loyA+q9smMjIEg5DlyWZ8CQO4EZR475E5GfhGBiEj4A3CruvGG1kseV+J9ogazX+HwpdGgzRYS/Izx//5mMoyckZw4LNeXQG+N3J+rDP3V37vxWiQPWDD8644XYUKou6batwNffQB6lMk09gj8rRcz9DjjohaXOtQAS6PD9/FW61DftDwabm5xyyan+Q4ut0kTPnVsf5NLj1frUnBYSYUAftik6M1Qzca072LE9r+PLBbcMq8ScGyzBOOFcSY4d8TP5UcPWhvPfX5Wjxx/lnk0K5oxxxEnob0IY3sikAMTqivo8q2jFhqTouJSHBELET4l+Fa8LLmrP7eY3dFIABfXNAoDKbcPQmj/oJoxcQM3ZzfkYREYIh45Bu1DF2/vj8BBqB151mgwpOB3lYVNEi/YzjsC0w= X-Forefront-Antispam-Report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:DU0PR04MB9417.eurprd04.prod.outlook.com; PTR:; CAT:NONE; SFS:(13230031)(346002)(366004)(376002)(39860400002)(396003)(136003)(230922051799003)(64100799003)(1800799012)(451199024)(186009)(66476007)(66946007)(66556008)(6486002)(4326008)(8936002)(8676002)(26005)(54906003)(110136005)(316002)(83380400001)(6666004)(478600001)(52116002)(5660300002)(41300700001)(30864003)(2906002)(7416002)(6506007)(6512007)(9686003)(38350700005)(921011)(36756003)(38100700002)(86362001)(41533002); DIR:OUT; SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?q?KBGrJ308h+WQB/LcTOiqyjwYp+mo?= =?utf-8?q?vZNXJAj1QsGaBqvY0h9tU7s+zqR1HDlO8pkXDdd+ELO+x75AJ0xEiu6Hed3C1hUfM?= =?utf-8?q?1BJBBw5xYXU0PwYHOFigkyKITYADTeksh3sKDhk3ZKGymL3IjGQ+DRjmFeSc7M1Ii?= =?utf-8?q?hgGeTv7CWu1GWkB+CsZJWiFQESnZ+uOwqKaZGasahtK2bGKYZVLMdsMK5CoakHsMt?= =?utf-8?q?jXfiMCDTPUZEf7NHQS9QtwjgaRirv48HW5MxduuejqZeu0GQsXBQqhhTyoc9ILeFt?= =?utf-8?q?csSL9PljOd9ZLBQ0PIMPI36QUjOdCk1/zsDM8YMG1b1RN4UDVZRfRlLvledYpjawG?= =?utf-8?q?CbfPrva7hkon5wd8IbryOAK38OCymJmz1zkwlQYtchkeJy9fnQaEHoNOV9kUXSaDP?= =?utf-8?q?uBSZioojrHgOk4gcfyy69LGATEveM8RfgEImSjj+aS4C2xL7frgyHjltxFcXOt771?= =?utf-8?q?nsF9syeU0889CCmHInjc79Uu4CPSLGQxI/PYF3ttPLXoakaDlvg/KDKblvp5BEhk0?= =?utf-8?q?zt3jURBR8Z8BlloVBbnNnnDAMjt0FQ0ucfn4AvKvxjv4J5Arcrja716geA2JkKRG5?= =?utf-8?q?ffYAsyFoTBma32lX2fuoT3IvOYgGn+nPLe5Hte2XlRc5zIbmahpaHymcHbOnQhImM?= =?utf-8?q?iV3zA4w8AdDC7XkxVvgkG0BXnucGslege99ld8n9h9wv65S6F6NLLu8goHYH/Mo98?= =?utf-8?q?/1XfB8Uw/4VfahYgN7PWidwJYzfIdoAKm+dwbO/AfN+E3n8jv4L2nOdwVMab6F4e8?= =?utf-8?q?chj5gNA/JGxQJx8NR9hoXCQpHPIS66rVzx3O1nGXdkv0iUoSWvmNL7D5+kNgXKBcq?= =?utf-8?q?eAmO49OBMIvzLfPTLm2RnjlukoXb+p/5emxfhrb3puxlYFxthjuHix4Ue+oJaSzvR?= =?utf-8?q?1fuThVmYJM0RjPjjmwWJYfQCX0Dslq1D0ww9vgJ5guYP98fwMOi5tGwtXTRePWT7z?= =?utf-8?q?8xeJzC/zh/h/Sb+syHq3VSFSejmSCzxFzfsiJNB2FxsXJW2bNOucmtunJc+T4lyDp?= =?utf-8?q?1envS7S9fsFspFGFyMDyhNKmRhgM72/VRr35/F55QYMT6wBreWJMQKUI50biD4VUX?= =?utf-8?q?BzxotcM+UGkUsMpyvwdlNIBLWPuMCqI61i0/yOv2x8O1E5VNCQX2gfTCn//EzaoSV?= =?utf-8?q?Y3seAi4eaYlOHjlP4bT2WunJkTGbkvFNJfDRSfKqSUyxCNXa+1PqhKRNBJcnxj3PE?= =?utf-8?q?jHCRz5weayAMMIQE1dK4P3Tjk+IlMxXDMtNVqzi/woB9wnqsZ7c66ugMB2ZCJbtyK?= =?utf-8?q?Hx1lNQ4hInfYfT9/QNBweBohZSBHZGrj+FqUhxjrrf7pQ0ns9hBCH+yHmXTm8vk6q?= =?utf-8?q?ylNh/wIhAWcRo+4wnSrx6zO0UaNUULSYQ6IFOZtvXL7Upr6EcqMi4ZzeWO20CVw8M?= =?utf-8?q?MCcTNYYwovbsfBZEFhHvxR1x3phBYL8LwOHdyfLbJl3lJti+gHX0o71vefmFi464S?= =?utf-8?q?tm04OXM2U7n+ySWRvcWWb8d/x2pKPwuXYuYvxh4oPkM+oFi3XgnDtWjztxTfsFHiv?= =?utf-8?q?YQI1Ykrg0dwB?= X-OriginatorOrg: oss.nxp.com X-MS-Exchange-CrossTenant-Network-Message-Id: 8aca705a-cda5-4ad4-b772-08dc0d123787 X-MS-Exchange-CrossTenant-AuthSource: DU0PR04MB9417.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 04 Jan 2024 10:45:07.3224 (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: Py0zFD1LbGcSINm6EsSVWopqPg62PerQoMXEyQ04e1+kv0pVQ3h8jVGB0osxK4sHzQn0lEIXupvTU4xVfpbIUg== X-MS-Exchange-Transport-CrossTenantHeadersStamped: PAXPR04MB8847 From: Peng Fan scmi-pinctrl driver implements pinctrl driver interface and using SCMI protocol to redirect messages from pinctrl subsystem SDK to SCMI platform firmware, which does the changes in HW. Co-developed-by: Oleksii Moisieiev Signed-off-by: Oleksii Moisieiev Signed-off-by: Peng Fan --- MAINTAINERS | 1 + drivers/pinctrl/Kconfig | 11 + drivers/pinctrl/Makefile | 1 + drivers/pinctrl/pinctrl-scmi.c | 524 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 537 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index 487bff0d44c0..3fe790e90834 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -21314,6 +21314,7 @@ F: drivers/clk/clk-sc[mp]i.c F: drivers/cpufreq/sc[mp]i-cpufreq.c F: drivers/firmware/arm_scmi/ F: drivers/firmware/arm_scpi.c +F: drivers/pinctrl/pinctrl-scmi.c F: drivers/pmdomain/arm/ F: drivers/powercap/arm_scmi_powercap.c F: drivers/regulator/scmi-regulator.c diff --git a/drivers/pinctrl/Kconfig b/drivers/pinctrl/Kconfig index 8163a5983166..27b26e428f60 100644 --- a/drivers/pinctrl/Kconfig +++ b/drivers/pinctrl/Kconfig @@ -432,6 +432,17 @@ config PINCTRL_ROCKCHIP help This support pinctrl and GPIO driver for Rockchip SoCs. +config PINCTRL_SCMI + tristate "Pinctrl driver using SCMI protocol interface" + depends on ARM_SCMI_PROTOCOL || COMPILE_TEST + select PINMUX + select GENERIC_PINCONF + help + This driver provides support for pinctrl which is controlled + by firmware that implements the SCMI interface. + It uses SCMI Message Protocol to interact with the + firmware providing all the pinctrl controls. + config PINCTRL_SINGLE tristate "One-register-per-pin type device tree based pinctrl driver" depends on OF diff --git a/drivers/pinctrl/Makefile b/drivers/pinctrl/Makefile index 1071f301cc70..ba755ed2d46c 100644 --- a/drivers/pinctrl/Makefile +++ b/drivers/pinctrl/Makefile @@ -44,6 +44,7 @@ obj-$(CONFIG_PINCTRL_PIC32) += pinctrl-pic32.o obj-$(CONFIG_PINCTRL_PISTACHIO) += pinctrl-pistachio.o obj-$(CONFIG_PINCTRL_RK805) += pinctrl-rk805.o obj-$(CONFIG_PINCTRL_ROCKCHIP) += pinctrl-rockchip.o +obj-$(CONFIG_PINCTRL_SCMI) += pinctrl-scmi.o obj-$(CONFIG_PINCTRL_SINGLE) += pinctrl-single.o obj-$(CONFIG_PINCTRL_ST) += pinctrl-st.o obj-$(CONFIG_PINCTRL_STMFX) += pinctrl-stmfx.o diff --git a/drivers/pinctrl/pinctrl-scmi.c b/drivers/pinctrl/pinctrl-scmi.c new file mode 100644 index 000000000000..146308d27f54 --- /dev/null +++ b/drivers/pinctrl/pinctrl-scmi.c @@ -0,0 +1,524 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * System Control and Power Interface (SCMI) Protocol based pinctrl driver + * + * Copyright (C) 2023 EPAM + * Copyright 2023 NXP + */ + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "pinctrl-utils.h" +#include "core.h" +#include "pinconf.h" + +#define DRV_NAME "scmi-pinctrl" + +static const struct scmi_pinctrl_proto_ops *pinctrl_ops; + +struct scmi_pinctrl_funcs { + unsigned int num_groups; + const char **groups; +}; + +struct scmi_pinctrl { + struct device *dev; + struct scmi_protocol_handle *ph; + struct pinctrl_dev *pctldev; + struct pinctrl_desc pctl_desc; + struct scmi_pinctrl_funcs *functions; + unsigned int nr_functions; + char **groups; + unsigned int nr_groups; + struct pinctrl_pin_desc *pins; + unsigned int nr_pins; + u8 *config_type; + u32 *config_value; +}; + +static int pinctrl_scmi_get_groups_count(struct pinctrl_dev *pctldev) +{ + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); + + return pinctrl_ops->count_get(pmx->ph, GROUP_TYPE); +} + +static const char *pinctrl_scmi_get_group_name(struct pinctrl_dev *pctldev, unsigned int selector) +{ + int ret; + const char *name; + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); + + ret = pinctrl_ops->name_get(pmx->ph, selector, GROUP_TYPE, &name); + if (ret) { + dev_err(pmx->dev, "get name failed with err %d", ret); + return NULL; + } + + return name; +} + +static int pinctrl_scmi_get_group_pins(struct pinctrl_dev *pctldev, + unsigned int selector, + const unsigned int **pins, + unsigned int *num_pins) +{ + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); + + return pinctrl_ops->group_pins_get(pmx->ph, selector, pins, num_pins); +} + +static const struct pinctrl_ops pinctrl_scmi_pinctrl_ops = { + .get_groups_count = pinctrl_scmi_get_groups_count, + .get_group_name = pinctrl_scmi_get_group_name, + .get_group_pins = pinctrl_scmi_get_group_pins, +#ifdef CONFIG_OF + .dt_node_to_map = pinconf_generic_dt_node_to_map_all, + .dt_free_map = pinconf_generic_dt_free_map, +#endif +}; + +static int pinctrl_scmi_get_functions_count(struct pinctrl_dev *pctldev) +{ + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); + + return pinctrl_ops->count_get(pmx->ph, FUNCTION_TYPE); +} + +static const char *pinctrl_scmi_get_function_name(struct pinctrl_dev *pctldev, + unsigned int selector) +{ + int ret; + const char *name; + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); + + ret = pinctrl_ops->name_get(pmx->ph, selector, FUNCTION_TYPE, &name); + if (ret) { + dev_err(pmx->dev, "get name failed with err %d", ret); + return NULL; + } + + return name; +} + +static int pinctrl_scmi_get_function_groups(struct pinctrl_dev *pctldev, + unsigned int selector, + const char * const **groups, + unsigned int * const num_groups) +{ + const unsigned int *group_ids; + int ret, i; + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); + + if (!groups || !num_groups) + return -EINVAL; + + if (selector < pmx->nr_functions && + pmx->functions[selector].num_groups) { + *groups = (const char * const *)pmx->functions[selector].groups; + *num_groups = pmx->functions[selector].num_groups; + return 0; + } + + ret = pinctrl_ops->function_groups_get(pmx->ph, selector, + &pmx->functions[selector].num_groups, + &group_ids); + if (ret) { + dev_err(pmx->dev, "Unable to get function groups, err %d", ret); + return ret; + } + + *num_groups = pmx->functions[selector].num_groups; + if (!*num_groups) + return -EINVAL; + + pmx->functions[selector].groups = + devm_kcalloc(pmx->dev, *num_groups, sizeof(*pmx->functions[selector].groups), + GFP_KERNEL); + if (!pmx->functions[selector].groups) + return -ENOMEM; + + for (i = 0; i < *num_groups; i++) { + pmx->functions[selector].groups[i] = + pinctrl_scmi_get_group_name(pmx->pctldev, + group_ids[i]); + if (!pmx->functions[selector].groups[i]) { + ret = -ENOMEM; + goto err_free; + } + } + + *groups = (const char * const *)pmx->functions[selector].groups; + + return 0; + +err_free: + devm_kfree(pmx->dev, pmx->functions[selector].groups); + + return ret; +} + +static int pinctrl_scmi_func_set_mux(struct pinctrl_dev *pctldev, unsigned int selector, + unsigned int group) +{ + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); + + return pinctrl_ops->mux_set(pmx->ph, selector, group); +} + +static int pinctrl_scmi_request(struct pinctrl_dev *pctldev, unsigned int offset) +{ + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); + + return pinctrl_ops->pin_request(pmx->ph, offset); +} + +static int pinctrl_scmi_free(struct pinctrl_dev *pctldev, unsigned int offset) +{ + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); + + return pinctrl_ops->pin_free(pmx->ph, offset); +} + +static const struct pinmux_ops pinctrl_scmi_pinmux_ops = { + .request = pinctrl_scmi_request, + .free = pinctrl_scmi_free, + .get_functions_count = pinctrl_scmi_get_functions_count, + .get_function_name = pinctrl_scmi_get_function_name, + .get_function_groups = pinctrl_scmi_get_function_groups, + .set_mux = pinctrl_scmi_func_set_mux, +}; + +static int pinctrl_scmi_map_pinconf_type(enum pin_config_param param, u8 *type) +{ + u8 arg = param; + + switch (arg) { + case PIN_CONFIG_BIAS_BUS_HOLD: + *type = SCMI_PIN_BIAS_BUS_HOLD; + break; + case PIN_CONFIG_BIAS_DISABLE: + *type = SCMI_PIN_BIAS_DISABLE; + break; + case PIN_CONFIG_BIAS_HIGH_IMPEDANCE: + *type = SCMI_PIN_BIAS_HIGH_IMPEDANCE; + break; + case PIN_CONFIG_BIAS_PULL_DOWN: + *type = SCMI_PIN_BIAS_PULL_DOWN; + break; + case PIN_CONFIG_BIAS_PULL_PIN_DEFAULT: + *type = SCMI_PIN_BIAS_PULL_DEFAULT; + break; + case PIN_CONFIG_BIAS_PULL_UP: + *type = SCMI_PIN_BIAS_PULL_UP; + break; + case PIN_CONFIG_DRIVE_OPEN_DRAIN: + *type = SCMI_PIN_DRIVE_OPEN_DRAIN; + break; + case PIN_CONFIG_DRIVE_OPEN_SOURCE: + *type = SCMI_PIN_DRIVE_OPEN_SOURCE; + break; + case PIN_CONFIG_DRIVE_PUSH_PULL: + *type = SCMI_PIN_DRIVE_PUSH_PULL; + break; + case PIN_CONFIG_DRIVE_STRENGTH: + *type = SCMI_PIN_DRIVE_STRENGTH; + break; + case PIN_CONFIG_DRIVE_STRENGTH_UA: + *type = SCMI_PIN_DRIVE_STRENGTH; + break; + case PIN_CONFIG_INPUT_DEBOUNCE: + *type = SCMI_PIN_INPUT_DEBOUNCE; + break; + case PIN_CONFIG_INPUT_ENABLE: + *type = SCMI_PIN_INPUT_MODE; + break; + case PIN_CONFIG_INPUT_SCHMITT: + *type = SCMI_PIN_INPUT_SCHMITT; + break; + case PIN_CONFIG_INPUT_SCHMITT_ENABLE: + *type = SCMI_PIN_INPUT_MODE; + break; + case PIN_CONFIG_MODE_LOW_POWER: + *type = SCMI_PIN_LOW_POWER_MODE; + break; + case PIN_CONFIG_OUTPUT: + *type = SCMI_PIN_OUTPUT_VALUE; + break; + case PIN_CONFIG_OUTPUT_ENABLE: + *type = SCMI_PIN_OUTPUT_MODE; + break; + case PIN_CONFIG_OUTPUT_IMPEDANCE_OHMS: + *type = SCMI_PIN_OUTPUT_VALUE; + break; + case PIN_CONFIG_POWER_SOURCE: + *type = SCMI_PIN_POWER_SOURCE; + break; + case PIN_CONFIG_SLEW_RATE: + *type = SCMI_PIN_SLEW_RATE; + break; + case SCMI_PIN_OEM_START ... SCMI_PIN_OEM_END: + *type = param; + break; + default: + return -EOPNOTSUPP; + } + + return 0; +} + +static int pinctrl_scmi_pinconf_get(struct pinctrl_dev *pctldev, unsigned int _pin, + unsigned long *config) +{ + int ret; + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); + enum pin_config_param config_type; + u32 config_value; + u8 type; + + if (!config) + return -EINVAL; + + config_type = pinconf_to_config_param(*config); + + ret = pinctrl_scmi_map_pinconf_type(config_type, &type); + if (ret) { + dev_err(pmx->dev, "Error map pinconf_type %d\n", ret); + return ret; + } + + ret = pinctrl_ops->config_get(pmx->ph, _pin, PIN_TYPE, type, &config_value); + if (ret) + return ret; + + *config = pinconf_to_config_packed(config_type, config_value); + + return 0; +} + +static int pinctrl_scmi_pinconf_set(struct pinctrl_dev *pctldev, + unsigned int _pin, + unsigned long *configs, + unsigned int num_configs) +{ + int i, ret; + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); + + if (!configs || !num_configs) + return -EINVAL; + + for (i = 0; i < num_configs; i++) { + ret = pinctrl_scmi_map_pinconf_type(pinconf_to_config_param(configs[i]), + &pmx->config_type[i]); + if (ret) { + dev_err(pmx->dev, "Error map pinconf_type %d\n", ret); + return ret; + } + pmx->config_value[i] = pinconf_to_config_argument(configs[i]); + } + + ret = pinctrl_ops->config_set(pmx->ph, _pin, PIN_TYPE, num_configs, + pmx->config_type, pmx->config_value); + if (ret) + dev_err(pmx->dev, "Error parsing config %d\n", ret); + + return ret; +} + +static int pinctrl_scmi_pinconf_group_set(struct pinctrl_dev *pctldev, + unsigned int group, + unsigned long *configs, + unsigned int num_configs) +{ + int i, ret; + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); + + if (!configs || !num_configs) + return -EINVAL; + + for (i = 0; i < num_configs; i++) { + ret = pinctrl_scmi_map_pinconf_type(pinconf_to_config_param(configs[i]), + &pmx->config_type[i]); + if (ret) { + dev_err(pmx->dev, "Error map pinconf_type %d\n", ret); + return ret; + } + pmx->config_value[i] = pinconf_to_config_argument(configs[i]); + } + + ret = pinctrl_ops->config_set(pmx->ph, group, GROUP_TYPE, num_configs, + pmx->config_type, pmx->config_value); + if (ret) + dev_err(pmx->dev, "Error parsing config %d", ret); + + return ret; +}; + +static int pinctrl_scmi_pinconf_group_get(struct pinctrl_dev *pctldev, + unsigned int group, + unsigned long *config) +{ + int ret; + struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); + enum pin_config_param config_type; + u32 config_value; + u8 type; + + if (!config) + return -EINVAL; + + config_type = pinconf_to_config_param(*config); + ret = pinctrl_scmi_map_pinconf_type(config_type, &type); + + ret = pinctrl_ops->config_get(pmx->ph, group, GROUP_TYPE, type, &config_value); + if (ret) + return ret; + + *config = pinconf_to_config_packed(config_type, config_value); + + return 0; +} + +static const struct pinconf_ops pinctrl_scmi_pinconf_ops = { + .is_generic = true, + .pin_config_get = pinctrl_scmi_pinconf_get, + .pin_config_set = pinctrl_scmi_pinconf_set, + .pin_config_group_set = pinctrl_scmi_pinconf_group_set, + .pin_config_group_get = pinctrl_scmi_pinconf_group_get, + .pin_config_config_dbg_show = pinconf_generic_dump_config, +}; + +static int pinctrl_scmi_get_pins(struct scmi_pinctrl *pmx, + unsigned int *nr_pins, + const struct pinctrl_pin_desc **pins) +{ + int ret, i; + + if (!pins || !nr_pins) + return -EINVAL; + + if (pmx->nr_pins) { + *pins = pmx->pins; + *nr_pins = pmx->nr_pins; + return 0; + } + + *nr_pins = pinctrl_ops->count_get(pmx->ph, PIN_TYPE); + + pmx->nr_pins = *nr_pins; + pmx->pins = devm_kmalloc_array(pmx->dev, *nr_pins, sizeof(*pmx->pins), GFP_KERNEL); + if (!pmx->pins) + return -ENOMEM; + + for (i = 0; i < *nr_pins; i++) { + pmx->pins[i].number = i; + ret = pinctrl_ops->name_get(pmx->ph, i, PIN_TYPE, &pmx->pins[i].name); + if (ret) { + dev_err(pmx->dev, "Can't get name for pin %d: rc %d", i, ret); + pmx->nr_pins = 0; + return ret; + } + } + + *pins = pmx->pins; + dev_dbg(pmx->dev, "got pins %d", *nr_pins); + + return 0; +} + +static const struct scmi_device_id scmi_id_table[] = { + { SCMI_PROTOCOL_PINCTRL, "pinctrl" }, + { } +}; +MODULE_DEVICE_TABLE(scmi, scmi_id_table); + +static int scmi_pinctrl_probe(struct scmi_device *sdev) +{ + int ret; + struct device *dev = &sdev->dev; + struct scmi_pinctrl *pmx; + const struct scmi_handle *handle; + struct scmi_protocol_handle *ph; + + if (!sdev || !sdev->handle) + return -EINVAL; + + handle = sdev->handle; + + pinctrl_ops = handle->devm_protocol_get(sdev, SCMI_PROTOCOL_PINCTRL, &ph); + if (IS_ERR(pinctrl_ops)) + return PTR_ERR(pinctrl_ops); + + pmx = devm_kzalloc(dev, sizeof(*pmx), GFP_KERNEL); + if (!pmx) + return -ENOMEM; + + pmx->config_type = devm_kzalloc(dev, SZ_4K, GFP_KERNEL); + if (!pmx->config_type) + return -ENOMEM; + + pmx->config_value = devm_kzalloc(dev, SZ_4K, GFP_KERNEL); + if (!pmx->config_value) + return -ENOMEM; + + pmx->ph = ph; + + pmx->dev = dev; + pmx->pctl_desc.name = DRV_NAME; + pmx->pctl_desc.owner = THIS_MODULE; + pmx->pctl_desc.pctlops = &pinctrl_scmi_pinctrl_ops; + pmx->pctl_desc.pmxops = &pinctrl_scmi_pinmux_ops; + pmx->pctl_desc.confops = &pinctrl_scmi_pinconf_ops; + + ret = pinctrl_scmi_get_pins(pmx, &pmx->pctl_desc.npins, + &pmx->pctl_desc.pins); + if (ret) + return ret; + + ret = devm_pinctrl_register_and_init(dev, &pmx->pctl_desc, pmx, &pmx->pctldev); + if (ret) + return dev_err_probe(dev, ret, "Failed to register pinctrl\n"); + + pmx->nr_functions = pinctrl_scmi_get_functions_count(pmx->pctldev); + pmx->nr_groups = pinctrl_scmi_get_groups_count(pmx->pctldev); + + if (pmx->nr_functions) { + pmx->functions = + devm_kcalloc(dev, pmx->nr_functions, sizeof(*pmx->functions), + GFP_KERNEL); + if (!pmx->functions) + return -ENOMEM; + } + + if (pmx->nr_groups) { + pmx->groups = + devm_kcalloc(dev, pmx->nr_groups, sizeof(*pmx->groups), GFP_KERNEL); + if (!pmx->groups) + return -ENOMEM; + } + + return pinctrl_enable(pmx->pctldev); +} + +static struct scmi_driver scmi_pinctrl_driver = { + .name = DRV_NAME, + .probe = scmi_pinctrl_probe, + .id_table = scmi_id_table, +}; +module_scmi_driver(scmi_pinctrl_driver); + +MODULE_AUTHOR("Oleksii Moisieiev "); +MODULE_AUTHOR("Peng Fan "); +MODULE_DESCRIPTION("ARM SCMI pin controller driver"); +MODULE_LICENSE("GPL"); From patchwork Thu Jan 4 10:48:49 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Peng Fan \(OSS\)" X-Patchwork-Id: 760059 Received: from EUR04-DB3-obe.outbound.protection.outlook.com (mail-db3eur04on2048.outbound.protection.outlook.com [40.107.6.48]) (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 CB53B22301; Thu, 4 Jan 2024 10:45:16 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=oss.nxp.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.nxp.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=NXP1.onmicrosoft.com header.i=@NXP1.onmicrosoft.com header.b="bfcLIt1s" ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=ewr9TDR1AG19CacelmvkVMPBC7BytFOACjQ0vz9iU7bhutZDsaH3mbCropBMOuYYt8QPOWNqcQzAZF6+FfdgMlHKmQPYS7JRePTjjrKpyiX42um78PwKAREu0luTTWIR4+t6tW+YHdKN/ss4vQ4NXwpL7DZjU7tJrDQz1F3wDRpHdiTzERut5iNj9h5/2qiXTXTa7P2dHdEloA+SfoCuBN7FoulnwkN/U6Szhbm6DPGkPq/2d9qmLqH9PDmILHOCA021m+I7d4JglplFjOBBwzZV10hy6K3pInugZlLNVCr3DlQkoVNa5NrUemoj3iBc9uZiGPQs+zRveM/3DMl15w== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; 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=+0B085vYvHv/GmYgoqvl90VanzgCgwz3QndzMlRohe8=; b=CpaxaO4CyxVfB40+urL2bq/jKDlgOT/4Trw6RZ7FhJMLjQ9twbz3k6ySq+bSRXQ6SeUrpOlpjSgcVVVHo51XCo8XOJ6//Ydvzg5YQbW4sh+5dLhwmBtDBPwU/tBFe7ae1C78AJweQ4NpNbDiOVwaZoEsyCoiSL5TcIYSAwB3+1zO6SjYg70ZZrB6XqTJeqBIBSk1hK57xvsDMp/lNvMH9rHN0PWuoKHPfmYt88InZcyj07f8D94nnusboz5pI+E2DwSFqIAY+4PEs7O/4fHhUHqfxhJRTclJLvZFF8FkCiTalpv8FJX+hLeWjnr41C4XYsGPKph3SfUX0ye54K+zYw== 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=selector2-NXP1-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=+0B085vYvHv/GmYgoqvl90VanzgCgwz3QndzMlRohe8=; b=bfcLIt1s067cQ+8CdN+lSo9E3lgZn/U/4QamNHRMpPcqK/bS5AErhezvH+nh8f/4F51G1wTWSjurY91l1o5AmCzIOqSs7N7JKwkUh8aGTRj/HWY0zUJA8ZQXdXliqVbke4mDm5ffSQJwzeSEdahUWvoIAV0rTNeSMxvVzMSI+00= Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=oss.nxp.com; Received: from DU0PR04MB9417.eurprd04.prod.outlook.com (2603:10a6:10:358::11) by DBBPR04MB7994.eurprd04.prod.outlook.com (2603:10a6:10:1ea::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7159.15; Thu, 4 Jan 2024 10:45:12 +0000 Received: from DU0PR04MB9417.eurprd04.prod.outlook.com ([fe80::ff06:bbb2:c068:5fb3]) by DU0PR04MB9417.eurprd04.prod.outlook.com ([fe80::ff06:bbb2:c068:5fb3%7]) with mapi id 15.20.7135.023; Thu, 4 Jan 2024 10:45:12 +0000 From: "Peng Fan (OSS)" Date: Thu, 04 Jan 2024 18:48:49 +0800 Subject: [PATCH NOT APPLY v2 5/6] firmware: scmi: support compatible string Message-Id: <20240104-pinctrl-scmi-v2-5-a9bd86ab5a84@nxp.com> References: <20240104-pinctrl-scmi-v2-0-a9bd86ab5a84@nxp.com> In-Reply-To: <20240104-pinctrl-scmi-v2-0-a9bd86ab5a84@nxp.com> To: Sudeep Holla , Cristian Marussi , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Oleksii Moisieiev , Linus Walleij , Shawn Guo , Sascha Hauer , Pengutronix Kernel Team , Fabio Estevam , NXP Linux Team Cc: linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, linux-gpio@vger.kernel.org, AKASHI Takahiro , Peng Fan X-Mailer: b4 0.12.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1704365357; l=8215; i=peng.fan@nxp.com; s=20230812; h=from:subject:message-id; bh=HKxjvWiYypkOgV8jylYBCQuqa9u8st95SOC7mkLfRYQ=; b=761EMAEM0hpudqz6eIK8jdJPapKyapBuQxaTyt1f3SKZ5FqaAzeQq8nHT2yh3KVToS0Dw++9O hw5LO+X2VceCiC9TFY1w79/s0Oxj5i+QCTx2S8q7OX06qhstQoXr+gR X-Developer-Key: i=peng.fan@nxp.com; a=ed25519; pk=I4sJg7atIT1g63H7bb5lDRGR2gJW14RKDD0wFL8TT1g= X-ClientProxiedBy: SG3P274CA0004.SGPP274.PROD.OUTLOOK.COM (2603:1096:4:be::16) To DU0PR04MB9417.eurprd04.prod.outlook.com (2603:10a6:10:358::11) Precedence: bulk X-Mailing-List: linux-gpio@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: DU0PR04MB9417:EE_|DBBPR04MB7994:EE_ X-MS-Office365-Filtering-Correlation-Id: 1bc65258-c0f3-41cd-481a-08dc0d123a9f X-MS-Exchange-SharedMailbox-RoutingAgent-Processed: True X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: 36wgjFjsrlUy10gfZIAmlvuP77SjlllFBDa1IhDbK/yBvpGApxZKN3osuHH74u4FbRgJN8Skerkus5q12IKFSzAuVlfcaiQCFVqPzXOBh+trhNbyBweMKXe1FpHoqwimqC9pCE+l2ZPx1dUWnBtKiaSLYWAFGz/AmWukair5z/ZNYj3Zz3bC3A8Ub0u8TJTTAv+Ef9NopyhVQPip7yW6k3gtfgf+T4xET9l+6VjogojH9u23xThTXLJ1DOUH/zpOdmTTT/ofS1na/CBOOKsedjNMW4VxzcrSxW6oYzDmioREz3DxmsOlpDsAszfcvFg85yFqeLRaLzqVx1pHfwGwE3isXw5CRZli5WLPEUGRlokKfAKCA4rxE/X144a9+Io1WRa08jTHqmoB3dmuJ7xdTWV3azkgRPhN3fAgTx1V9JtkdTnZzDJ8Yih4DKDQT0GifoYDexX3gjAzKl1EvMaei4AWSef3ieV4CUAwAmDKJlH8Kmk1WSS74kpQwqJLrTSXV5uiCDQw+RRNbRIcSBcxk1tJDvmqHZm55rv+lZMQN6vSsAnYR/2ip0UyFjmi7uxopfbSv2hNnpdwVettDS/K4WBmBXr89IbcsoQDCMa3VmA8ESFQb8EQqrirqvhOt578f1cyyx18nllhPCdsv8dwlQ== X-Forefront-Antispam-Report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:DU0PR04MB9417.eurprd04.prod.outlook.com; PTR:; CAT:NONE; SFS:(13230031)(136003)(346002)(376002)(396003)(39860400002)(366004)(230922051799003)(451199024)(64100799003)(186009)(1800799012)(26005)(38100700002)(83380400001)(41300700001)(8676002)(8936002)(110136005)(54906003)(5660300002)(2906002)(7416002)(316002)(4326008)(6666004)(66946007)(478600001)(9686003)(6512007)(6506007)(66556008)(52116002)(66476007)(921011)(6486002)(38350700005)(86362001)(36756003); DIR:OUT; SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?q?AMnbHFLTcz+rT3zJ/CQ1o7Wg7R4K?= =?utf-8?q?sHvWMgSBn0ZlrBLxp0/ciLrfZ7FIH19TR4/y0wPegl4bE2gy/jVPcBSWNOmUc8Lxw?= =?utf-8?q?46nYevt1DtONLP4Z1aMm9IWWBbvpFPqpFPZSG3I4UPII1hk8gjuuAUlaCw5fWunxg?= =?utf-8?q?PHbbKJ6BRRdzVQBTzzTW1EnJ7dtMpl7A1O1Y6z9cbrd91BWACCK6D94Ef4Ea7ksuL?= =?utf-8?q?ks8XcJxJLDQsydwBshnrQi3PBkQsGf2uef4QFCctX6dr7CFBHuA4YJVkaDSR3dBGP?= =?utf-8?q?vJ7S9KuNLh0JI3beBhCpjwJBuR9vQhCFulpp4HgOBKDPklzHIfs96N+GXLbuOM3pq?= =?utf-8?q?VhBxp/6y36wIF1moocIWsPsRE84TyBELwjjLn7NN7qINn4m4zhP4Hcb2yiBh6M+ml?= =?utf-8?q?UnETDhDWld9TwkDhCywaF9WWn6oug/h7RCkJy5e0iF3fGwa0vo894KRxkhuD5aIl9?= =?utf-8?q?ntWn0qTtK26m5K1nyjAfYGYlfM4sIg7ImconDkP5T5M60Tw7vZo56o+zpFDoxEycd?= =?utf-8?q?gA1yjOqqgcztnk0bsZjkwxtnKoHTO/Jy2sSGPfCauLxQRh3uiXRnLPEi5sKmq1wb3?= =?utf-8?q?Lodw6HRz7vGbAVXC1x6y+Lu/58pCPiG0hMXxIsRn1eWapmIrdglpy4k/E6lToSZEI?= =?utf-8?q?mxasQjKUxnNuRhvKBFj2X7jPt1my/Cuw3CLc3O4TrFjh5Lm8VdM7Ftq41JC20k9ki?= =?utf-8?q?F9bGbnNgHQfiybWINreCZA+uDKeaSLuXOhEtT1jOsomHw8cY1BXEECzXP7uKONKV7?= =?utf-8?q?xZ7xe66Cr0We35SBtQ0eAKPnLtwrl8RVtcCSt+chL/jC8XiyR0LtkTwXh9asJhVJL?= =?utf-8?q?LxTs4CbOJJueRe2fs3E43YpWPiWJMXh8cvtD8wlw8p8ZlR1fijzgajeLaHQyS49ER?= =?utf-8?q?TC5oIq9Xvk1A02CnCLZJ2RmgT0p6SJ5uuTqJkR63CuLIrdTgX7lh8vGm0JBkXUnXj?= =?utf-8?q?lvfAu97ALEpVIumH+WO9GIFG0pgWqr4eoA3rcUDZOupEks8/OuPkNoK9nWWw94tzw?= =?utf-8?q?rEwa3eh/aTGR5L5W+Rm2lLbiT//jAuGB7fXIAVXNGMyPIqwLYGPLkIgO5oW35pkzs?= =?utf-8?q?IueGVrYgsueR4E6AxCOA3VYdXYEdf9YTlnNisjynYjHq4E/z0HMSOp9618LOPSQoJ?= =?utf-8?q?u/Jsv4HbsuXMp16OKnk8MZoE/A74IaEpZ5aWz6eSBp8eE7BGPWFnzWaxI2kY8/e3N?= =?utf-8?q?jqSIDMPbyxSMAulQVYv5nEDJSk96iStmjckBf4fO78KafZKjb6wUTe4n3EGknMQ/b?= =?utf-8?q?SDqjI9p5gJ0jiffixW888V3sz3dWtAZMZk9zyXxFA8cgXmfVLjTysAb/wz08IxKJj?= =?utf-8?q?T+jofkKR3Cvf/k0xilP0WY5n/D4Rx18KbnP0CjWNMSbW6/lS8QChtgiKxNnVREsak?= =?utf-8?q?pn8nFRgVOJaWeYa5AutTcKtfwFYP4sdF0sQFjVuIbKDNwm0GTNS0/0UslDQlbHhb6?= =?utf-8?q?gqRqBYvpqBg3yndQtZU8Qo1vpew9clOlpUyGuX2df+QISI3zRtnVOZDzouatHdEOH?= =?utf-8?q?rdAhr6xwLiwN?= X-OriginatorOrg: oss.nxp.com X-MS-Exchange-CrossTenant-Network-Message-Id: 1bc65258-c0f3-41cd-481a-08dc0d123a9f X-MS-Exchange-CrossTenant-AuthSource: DU0PR04MB9417.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 04 Jan 2024 10:45:12.4865 (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: BmGWlXOUkv8f7Vl6qRIsz/c9B5ql3GEdU6so3kxi463x65hx7WELM8EZk2dOvmEoml3yI6SdLdllTPYQf6x//g== X-MS-Exchange-Transport-CrossTenantHeadersStamped: DBBPR04MB7994 From: Peng Fan i.MX95 use SCMI PINCTRL OEM config type, so it could not reuse pinctrl-scmi.c which use generic pinconf. Then need introduce saying pinctrl-imx-scmi.c to support i.MX95, however both pinctrl-scmi and pinctrl-imx-scmi driver will register a pinctrl device with the same of_node(protocl@19). This will introduce an issue, because the pinctrl subsystem will use of_node to find the exact pinctrl device. But with two pinctrl devices registered by two drivers, it is unknown which pinctrl device will be chosen. So introduce compatible string to support cases that Vendor SCMI driver which does almost same thing as generic SCMI driver, but has some specific Vendor settings to do. Signed-off-by: Peng Fan --- drivers/firmware/arm_scmi/bus.c | 39 ++++++++++++++++++++++++++++++-------- drivers/firmware/arm_scmi/common.h | 2 +- drivers/firmware/arm_scmi/driver.c | 15 ++++++++++----- include/linux/scmi_protocol.h | 2 ++ 4 files changed, 44 insertions(+), 14 deletions(-) diff --git a/drivers/firmware/arm_scmi/bus.c b/drivers/firmware/arm_scmi/bus.c index 1f9735dbebec..9043f6366fa8 100644 --- a/drivers/firmware/arm_scmi/bus.c +++ b/drivers/firmware/arm_scmi/bus.c @@ -214,13 +214,21 @@ scmi_dev_match_id(struct scmi_device *scmi_dev, struct scmi_driver *scmi_drv) if (!id) return NULL; - for (; id->protocol_id; id++) - if (id->protocol_id == scmi_dev->protocol_id) { - if (!id->name) + for (; id->protocol_id; id++) { + if (id->protocol_id != scmi_dev->protocol_id) + continue; + if (!id->name) + return id; + + if (!strcmp(id->name, scmi_dev->name)) { + if (!id->compatible && + device_property_read_string(&scmi_dev->dev, "compatible", NULL)) return id; - else if (!strcmp(id->name, scmi_dev->name)) + + if (id->compatible && device_is_compatible(&scmi_dev->dev, id->compatible)) return id; } + } return NULL; } @@ -345,11 +353,14 @@ static void __scmi_device_destroy(struct scmi_device *scmi_dev) static struct scmi_device * __scmi_device_create(struct device_node *np, struct device *parent, - int protocol, const char *name) + int protocol, const char *name, const char *compatible) { int id, retval; struct scmi_device *scmi_dev; + if (compatible && !of_device_is_compatible(np, compatible)) + return NULL; + /* * If the same protocol/name device already exist under the same parent * (i.e. SCMI instance) just return the existent device. @@ -425,6 +436,7 @@ __scmi_device_create(struct device_node *np, struct device *parent, * @name: The requested-name of the device to be created; this is optional * and if no @name is provided, all the devices currently known to * be requested on the SCMI bus for @protocol will be created. + * @compatible: The compatible string * * This method can be invoked to create a single well-defined device (like * a transport device or a device requested by an SCMI driver loaded after @@ -441,14 +453,14 @@ __scmi_device_create(struct device_node *np, struct device *parent, */ struct scmi_device *scmi_device_create(struct device_node *np, struct device *parent, int protocol, - const char *name) + const char *name, const char *compatible) { struct list_head *phead; struct scmi_requested_dev *rdev; struct scmi_device *scmi_dev = NULL; if (name) - return __scmi_device_create(np, parent, protocol, name); + return __scmi_device_create(np, parent, protocol, name, compatible); mutex_lock(&scmi_requested_devices_mtx); phead = idr_find(&scmi_requested_devices, protocol); @@ -462,9 +474,20 @@ struct scmi_device *scmi_device_create(struct device_node *np, list_for_each_entry(rdev, phead, node) { struct scmi_device *sdev; + if (compatible) { + if (!rdev->id_table->compatible) + continue; + if (strcmp(compatible, rdev->id_table->compatible)) + continue; + } else { + if (rdev->id_table->compatible) + continue; + } + sdev = __scmi_device_create(np, parent, rdev->id_table->protocol_id, - rdev->id_table->name); + rdev->id_table->name, + rdev->id_table->compatible); /* Report errors and carry on... */ if (sdev) scmi_dev = sdev; diff --git a/drivers/firmware/arm_scmi/common.h b/drivers/firmware/arm_scmi/common.h index 00b165d1f502..ac0d83ed5803 100644 --- a/drivers/firmware/arm_scmi/common.h +++ b/drivers/firmware/arm_scmi/common.h @@ -149,7 +149,7 @@ extern struct blocking_notifier_head scmi_requested_devices_nh; struct scmi_device *scmi_device_create(struct device_node *np, struct device *parent, int protocol, - const char *name); + const char *name, const char *compatible); void scmi_device_destroy(struct device *parent, int protocol, const char *name); int scmi_protocol_acquire(const struct scmi_handle *handle, u8 protocol_id); diff --git a/drivers/firmware/arm_scmi/driver.c b/drivers/firmware/arm_scmi/driver.c index 4c3752749105..b78fce62a0de 100644 --- a/drivers/firmware/arm_scmi/driver.c +++ b/drivers/firmware/arm_scmi/driver.c @@ -261,15 +261,17 @@ EXPORT_SYMBOL_GPL(scmi_protocol_unregister); * @name: The optional name of the device to be created: if not provided this * call will lead to the creation of all the devices currently requested * for the specified protocol. + * @compatible: optional, the compatible string */ static void scmi_create_protocol_devices(struct device_node *np, struct scmi_info *info, - int prot_id, const char *name) + int prot_id, const char *name, + const char *compatible) { struct scmi_device *sdev; mutex_lock(&info->devreq_mtx); - sdev = scmi_device_create(np, info->dev, prot_id, name); + sdev = scmi_device_create(np, info->dev, prot_id, name, compatible); if (name && !sdev) dev_err(info->dev, "failed to create device for protocol 0x%X (%s)\n", @@ -2354,7 +2356,7 @@ static int scmi_chan_setup(struct scmi_info *info, struct device_node *of_node, snprintf(name, 32, "__scmi_transport_device_%s_%02X", idx ? "rx" : "tx", prot_id); /* Create a uniquely named, dedicated transport device for this chan */ - tdev = scmi_device_create(of_node, info->dev, prot_id, name); + tdev = scmi_device_create(of_node, info->dev, prot_id, name, NULL); if (!tdev) { dev_err(info->dev, "failed to create transport device (%s)\n", name); @@ -2550,7 +2552,7 @@ static int scmi_device_request_notifier(struct notifier_block *nb, switch (action) { case SCMI_BUS_NOTIFY_DEVICE_REQUEST: scmi_create_protocol_devices(np, info, id_table->protocol_id, - id_table->name); + id_table->name, id_table->compatible); break; case SCMI_BUS_NOTIFY_DEVICE_UNREQUEST: scmi_destroy_protocol_devices(info, id_table->protocol_id, @@ -2802,10 +2804,13 @@ static int scmi_probe(struct platform_device *pdev) for_each_available_child_of_node(np, child) { u32 prot_id; + const char *s = NULL; if (of_property_read_u32(child, "reg", &prot_id)) continue; + of_property_read_string(child, "compatible", &s); + if (!FIELD_FIT(MSG_PROTOCOL_ID_MASK, prot_id)) dev_err(dev, "Out of range protocol %d\n", prot_id); @@ -2828,7 +2833,7 @@ static int scmi_probe(struct platform_device *pdev) } of_node_get(child); - scmi_create_protocol_devices(child, info, prot_id, NULL); + scmi_create_protocol_devices(child, info, prot_id, NULL, s); } return 0; diff --git a/include/linux/scmi_protocol.h b/include/linux/scmi_protocol.h index d8e2bb828ee7..ee7b77eb9466 100644 --- a/include/linux/scmi_protocol.h +++ b/include/linux/scmi_protocol.h @@ -912,6 +912,7 @@ struct scmi_device { u32 id; u8 protocol_id; const char *name; + const char *compatible; /* Optional */ struct device dev; struct scmi_handle *handle; }; @@ -921,6 +922,7 @@ struct scmi_device { struct scmi_device_id { u8 protocol_id; const char *name; + const char *compatible; /* Optional */ }; struct scmi_driver { From patchwork Thu Jan 4 10:48:50 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Peng Fan \(OSS\)" X-Patchwork-Id: 760569 Received: from EUR04-DB3-obe.outbound.protection.outlook.com (mail-db3eur04on2048.outbound.protection.outlook.com [40.107.6.48]) (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 3A0F920DDE; Thu, 4 Jan 2024 10:45:19 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=oss.nxp.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=oss.nxp.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=NXP1.onmicrosoft.com header.i=@NXP1.onmicrosoft.com header.b="IYEFe8ci" ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=kKPAu8J2wowPDiR9G4kHLkwJDHAHwWLDNemZGHlhjmsLPlK/ZRmdkzNHcMEUhQsbLoliLZUQGyDqgYFUyC4s+fpdaeULw7BRwVAJ6d7UKgA859C3Sk4gfcHW+PP6S9LuRcFRW6qqqfWTtKbmYpeiFHznUMYGRarH5OD1opd1ShtDchNnBeDzVQe4WF6sQnVc7DcDPJOC2jh1EDve/D3Iz0JzTfLrqP7jQKXfjIabuc5OqDSyIKJ9o86RUY1JUI6paALSRqi/Mf4mlazFUBu81kgDTTxenHRFL0dDaW6mWszzMiDiTtfLr/pYLtn/J5Ih1lY54qzkjLtrQs3FyeEk9Q== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; 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=TBrv5grZuXi9ZKLBAqWKbI2ffwa3ut4ZwXFNS5mOLI8=; b=Q7oZ+Li8RbzM8zMUa9kUinnsCQ/U5clKNcr2FNyx0WzzVyw5g4NN5x1J3brRorzCZrMigEtwQ/Ea6mHPW61jfaeWaZT072e6UetaI9z0MRJGoIcRGprXHfMsUrwv5HAGCZqjnvn5VKIBmAerEzmK4wEuPHYDyDziOkRefciyqEGL6ncY+O5E7iCkQwOpuvsHn04RHe2MG0YwgZ04qusVPFbGcQJIklflf10TB64AfB+p0LvdTPy6bamfbWVxXEi4b4hj71fVr2ZSqf2O/9YqM/z0xZ/rEzZHoc4yzoaYtJQczYLGDPyFmtA5AO4tTHNv+ciaDnPrNzcMFfTng/AQaQ== 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=selector2-NXP1-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=TBrv5grZuXi9ZKLBAqWKbI2ffwa3ut4ZwXFNS5mOLI8=; b=IYEFe8ci4MrgJRJsaxXRKQnThdQiIrwUldBv7AIPI1t/hLaLFkOjXtQ8DWzM6MkSMdATF0BW0gecsai26zkvQDwbvNFIftK8feEvN9m9LIVmV0pkUNtg7FNVFbElCx6RP40F8Qx2eFTqzVQHV6iThYQOOO+VvvzzhRq77GKkSuU= Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=oss.nxp.com; Received: from DU0PR04MB9417.eurprd04.prod.outlook.com (2603:10a6:10:358::11) by DBBPR04MB7994.eurprd04.prod.outlook.com (2603:10a6:10:1ea::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7159.15; Thu, 4 Jan 2024 10:45:17 +0000 Received: from DU0PR04MB9417.eurprd04.prod.outlook.com ([fe80::ff06:bbb2:c068:5fb3]) by DU0PR04MB9417.eurprd04.prod.outlook.com ([fe80::ff06:bbb2:c068:5fb3%7]) with mapi id 15.20.7135.023; Thu, 4 Jan 2024 10:45:17 +0000 From: "Peng Fan (OSS)" Date: Thu, 04 Jan 2024 18:48:50 +0800 Subject: [PATCH NOT APPLY v2 6/6] pinctrl: scmi: implement pinctrl_scmi_imx_dt_node_to_map Message-Id: <20240104-pinctrl-scmi-v2-6-a9bd86ab5a84@nxp.com> References: <20240104-pinctrl-scmi-v2-0-a9bd86ab5a84@nxp.com> In-Reply-To: <20240104-pinctrl-scmi-v2-0-a9bd86ab5a84@nxp.com> To: Sudeep Holla , Cristian Marussi , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Oleksii Moisieiev , Linus Walleij , Shawn Guo , Sascha Hauer , Pengutronix Kernel Team , Fabio Estevam , NXP Linux Team Cc: linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, linux-gpio@vger.kernel.org, AKASHI Takahiro , Peng Fan X-Mailer: b4 0.12.3 X-Developer-Signature: v=1; a=ed25519-sha256; t=1704365357; l=7141; i=peng.fan@nxp.com; s=20230812; h=from:subject:message-id; bh=UNtnAacrD3p6okC7/cMkcE6UWw1ah8KQZQ8RD/XuU/k=; b=GOZgKd/GkYX7pMK64yjn1d0EAU+PVNhTMg1f+mLIolo8VAHyleMZxffiIFVksVFsOiaJ2cuGh xWRhzaSy0DtBgooNFr4GO3CxP3Voyseju3pWtLJs2pbActjsSKcAB3q X-Developer-Key: i=peng.fan@nxp.com; a=ed25519; pk=I4sJg7atIT1g63H7bb5lDRGR2gJW14RKDD0wFL8TT1g= X-ClientProxiedBy: SG3P274CA0004.SGPP274.PROD.OUTLOOK.COM (2603:1096:4:be::16) To DU0PR04MB9417.eurprd04.prod.outlook.com (2603:10a6:10:358::11) Precedence: bulk X-Mailing-List: linux-gpio@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: DU0PR04MB9417:EE_|DBBPR04MB7994:EE_ X-MS-Office365-Filtering-Correlation-Id: 606560c9-afb2-4428-b17a-08dc0d123daf X-MS-Exchange-SharedMailbox-RoutingAgent-Processed: True X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: Rl5N3EZQM4u7OQ3GnxEVX6HihkvCV94CwXO/CWbJuUY3YX5PR/wUchg7izm7IL2f2n+8970QE6n1ppG/hm+QQ2nA8MxPr8zcd4t4BCqIS8IGpZ3nvGmJphB1K8FRyvuNeAYF19oWGmYfud2HGBnSbzZtc0/t/CPQ3Dap8hRkyAiZ296eg/KYin8nQOhj3lpnv3fDJkxlF7DTRt1eD9ES6PZb3Sj9+IZZnAyWYcQ345TdO96xdPDVYa+v2dmiXMhVFHCLqgT1C6/W3xwmrwtd6B6q7dkWMLiLxGAESNqw9yuxUWb9fznRjPfF4xpnFVpzKwQQhRdgR5f3y+d85fdlNLADcrB4P73yHJd2Ai4mnknQpEOQBTbF26FlL3WZng5fXv8uIQKPOGkiISqPylHdgJw0sRf9oOcUoqQoiDz/CmgyaD2DhDke5+tnXENG3GgWIOj6ShHPjYbEnc1b7SP0IYn/wqwhkiFCD1RMuT7upojkYrSqail5Lm2Ol2jI8SMZkCphbiR7tTSDT8xAnfhn7vsoWIpzVbmKEhswhcjLVyv3CM0Zohnhfgo/1RG7EuZIO3Z9haNlCp1kZ/PmtaMhUitkY/HNAr4ttmdS8wufwMySjvJZfwjNE07e/CIDfp/RPTOISzSm8qy8ZNsh6fmbMQ== X-Forefront-Antispam-Report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:DU0PR04MB9417.eurprd04.prod.outlook.com; PTR:; CAT:NONE; SFS:(13230031)(136003)(346002)(376002)(396003)(39860400002)(366004)(230922051799003)(451199024)(64100799003)(186009)(1800799012)(26005)(38100700002)(83380400001)(41300700001)(8676002)(8936002)(110136005)(54906003)(5660300002)(2906002)(7416002)(316002)(4326008)(6666004)(66946007)(478600001)(9686003)(6512007)(6506007)(66556008)(52116002)(66476007)(921011)(6486002)(38350700005)(86362001)(36756003); DIR:OUT; SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?q?w0D6Anx+chcg2kakGpzx0c2uWpVu?= =?utf-8?q?Qmm6NPT23fu/IHQ69qAWPwSaE8wIogwslH5Urf1hetsX4kMIJigGRPvJZqEe2pCa+?= =?utf-8?q?9Qa6disFmdtvZH8RhFLvazW6AKu5Y2E/ttzZ17EkTe4Zaf8uDVBVRHukyW+wTE5oS?= =?utf-8?q?i7pVXyaPnuzvr/HKKpjgHrSDIVoexKrJLxXbiru2Xf0borwFqbh5h2EIQYC29dCVD?= =?utf-8?q?L4y7UcK+DbZj4wCmx1X/jqDe1LOmN4Fk26jYlhFJGagwNbBhAm8OI7FPu6+OnVbvU?= =?utf-8?q?HB7wo6lOiX8o4ifBHANqkjas/i1qfBIhwoi/WK4b2LrDaZjvSKclVvUR8vTCFOTOc?= =?utf-8?q?gM+lVXg+mXarJ+Dt82XcGWtzvDxjaPESfy+BDXRJiWttTLR84uhCRJQ8dxK9hiIB2?= =?utf-8?q?Kp9R3ZUXXgjlgOOLrYj4+sn799fBuSaMXeGuXAJ+vKiZUTJJ4CDm9eczMO0KR9ZZI?= =?utf-8?q?8ySBtwKaNL4DQlkqpoUS1QPrzvZANMZtY28IazzM7NCVnQRek7Rw4JrZ+ySxlBTDN?= =?utf-8?q?sXO3+mQ7e28pz1mwxemhfaMvCfF/ZXbBkDk38wlH27QNlB58G4BHKXDeP4hZKK6Z0?= =?utf-8?q?g0y18+4T3lrxk2T3qpJyvd025qKZcTSpwv6PeeKK0198aKjlrcIFcUGSeQSUlAHTb?= =?utf-8?q?g1u/rt0E4yI3aVSDkFVOdSe35KobYP0LpqvTcMox15j31SUILgW5c+2NXYgK/z83L?= =?utf-8?q?boV5zW6YidXvuung9eWCVSRscNvUMtlrSR04t+RBcIs3HWkZxTISid/q9zVtr8WzZ?= =?utf-8?q?tgGges32FNONOHVYlUBkl7rZC6ui7AaqS9YbQbg7UWXKCXoZqENoOfd2MKQw7weBe?= =?utf-8?q?jZ2sY0L8vBJivRakbc23YRblhGpFOTLqggOUjIcva259msRjXe0d+B8uZxN4hr5gv?= =?utf-8?q?f69tb4e2GThBd/P7gB8kEB7Nn+loDpFyDD5o6PZQrcVNn7r8VQJla/nKUn+SshFWh?= =?utf-8?q?78GmrHTjGXdiC9tImR24oSCGHx5X79/xX3GyPyFo+WnVJVTXcxyXzn3YY32avCmBw?= =?utf-8?q?nQWznRoVdA48FbB+tb0BzG0GmLiRN95oh36nEZxrwLC5lSBtPrieccXtuG461wTfg?= =?utf-8?q?otg+6LcR2hIqB/luvgkt8BI1ooJ/zv+yFcI5fV6Ms7TcwoXMqTY+GcjEsf+1JzWrm?= =?utf-8?q?qRtAORk42nn29qJ/B0fCz2RQG4r9YZo3gg51cVE1m6kMd2sgLOtFumZWKHPudeiYm?= =?utf-8?q?ylZM/C+UWMFgMPuuL0XEekYZsDAnpbSyaH/YfgdOiCZWsRcSLgv0BY659NdXDgRX4?= =?utf-8?q?gi6LgJcxgkQSWWJfyGwCogOW8ubus+uVX3SHK7gUrE1uTl7G9RA1apWi0rB/KDs2V?= =?utf-8?q?DXAEzSVFiKLzrVTEwX1PVKOkBBfWa3DiqDteU8uDL28Y5eMFqbORghRWHsxTqVS7q?= =?utf-8?q?LRgSssj7LOxKS09jzJ8Nq5LzQ73hX370Xw8VZU7QXKiNJZj9zQMD3dy52/rHqIdPq?= =?utf-8?q?c1QV+UlOfIcvUh9bN1XxN84RavBZ0F+vvaPDF+1VFtn8D9eJMAu6GadPDFjp0FzWh?= =?utf-8?q?F6TCpGbd/Ezc?= X-OriginatorOrg: oss.nxp.com X-MS-Exchange-CrossTenant-Network-Message-Id: 606560c9-afb2-4428-b17a-08dc0d123daf X-MS-Exchange-CrossTenant-AuthSource: DU0PR04MB9417.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 04 Jan 2024 10:45:17.6746 (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: M819BMnj+cTa7uayhto4iA5nUrHzUECxk7EOHFN8Nr5bQCdPOLWOiHmnyJiPLcbh6gJ+B0vWLkQnPrVNdsOI2g== X-MS-Exchange-Transport-CrossTenantHeadersStamped: DBBPR04MB7994 From: Peng Fan i.MX95 System Manager FW supports SCMI PINCTRL protocol, but uses OEM Pin Configuration type, so need i.MX specific dt_node_to_map. Signed-off-by: Peng Fan --- drivers/pinctrl/Makefile | 2 +- drivers/pinctrl/pinctrl-scmi-imx.c | 117 +++++++++++++++++++++++++++++++++++++ drivers/pinctrl/pinctrl-scmi.c | 16 +++++ drivers/pinctrl/pinctrl-scmi.h | 12 ++++ 4 files changed, 146 insertions(+), 1 deletion(-) diff --git a/drivers/pinctrl/Makefile b/drivers/pinctrl/Makefile index ba755ed2d46c..d96b7ede1355 100644 --- a/drivers/pinctrl/Makefile +++ b/drivers/pinctrl/Makefile @@ -44,7 +44,7 @@ obj-$(CONFIG_PINCTRL_PIC32) += pinctrl-pic32.o obj-$(CONFIG_PINCTRL_PISTACHIO) += pinctrl-pistachio.o obj-$(CONFIG_PINCTRL_RK805) += pinctrl-rk805.o obj-$(CONFIG_PINCTRL_ROCKCHIP) += pinctrl-rockchip.o -obj-$(CONFIG_PINCTRL_SCMI) += pinctrl-scmi.o +obj-$(CONFIG_PINCTRL_SCMI) += pinctrl-scmi.o pinctrl-scmi-imx.o obj-$(CONFIG_PINCTRL_SINGLE) += pinctrl-single.o obj-$(CONFIG_PINCTRL_ST) += pinctrl-st.o obj-$(CONFIG_PINCTRL_STMFX) += pinctrl-stmfx.o diff --git a/drivers/pinctrl/pinctrl-scmi-imx.c b/drivers/pinctrl/pinctrl-scmi-imx.c new file mode 100644 index 000000000000..e9d02e4c2cc1 --- /dev/null +++ b/drivers/pinctrl/pinctrl-scmi-imx.c @@ -0,0 +1,117 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright 2023 NXP + */ + +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "pinctrl-scmi.h" +#include "pinctrl-utils.h" +#include "core.h" +#include "pinconf.h" + +/* SCMI pin control types, aligned with SCMI firmware */ +#define IMX_SCMI_PIN_TYPE_MUX 192 +#define IMX_SCMI_PIN_TYPE_CONFIG 193 +#define IMX_SCMI_PIN_TYPE_DAISY_ID 194 +#define IMX_SCMI_PIN_TYPE_DAISY_CFG 195 + +#define IMX_SCMI_NO_PAD_CTL BIT(31) +#define IMX_SCMI_PAD_SION BIT(30) +#define IMX_SCMI_IOMUXC_CONFIG_SION BIT(4) + +#define IMX_SCMI_NUM_CFG 4 +#define IMX_SCMI_PIN_SIZE 24 + +int pinctrl_scmi_imx_dt_node_to_map(struct pinctrl_dev *pctldev, struct device_node *np, + struct pinctrl_map **map, unsigned int *num_maps) +{ + struct pinctrl_map *new_map; + const __be32 *list; + unsigned long *configs = NULL; + unsigned long cfg[IMX_SCMI_NUM_CFG]; + int map_num, size, pin_size, pin_id, num_pins; + int mux_reg, conf_reg, input_reg, mux_val, conf_val, input_val; + int i, j; + uint32_t ncfg; + static uint32_t daisy_off; + + if (!daisy_off) { + if (of_machine_is_compatible("fsl,imx95")) + daisy_off = 0x408; + else + dev_err(pctldev->dev, "platform not support scmi pinctrl\n"); + } + + list = of_get_property(np, "fsl,pins", &size); + if (!list) { + dev_err(pctldev->dev, "no fsl,pins property in node %pOF\n", np); + return -EINVAL; + } + + pin_size = IMX_SCMI_PIN_SIZE; + + if (!size || size % pin_size) { + dev_err(pctldev->dev, "Invalid fsl,pins or pins property in node %pOF\n", np); + return -EINVAL; + } + + num_pins = size / pin_size; + map_num = num_pins; + + new_map = kmalloc_array(map_num, sizeof(struct pinctrl_map), + GFP_KERNEL); + if (!new_map) + return -ENOMEM; + + *map = new_map; + *num_maps = map_num; + + /* create config map */ + for (i = 0; i < num_pins; i++) { + j = 0; + ncfg = IMX_SCMI_NUM_CFG; + mux_reg = be32_to_cpu(*list++); + conf_reg = be32_to_cpu(*list++); + input_reg = be32_to_cpu(*list++); + mux_val = be32_to_cpu(*list++); + input_val = be32_to_cpu(*list++); + conf_val = be32_to_cpu(*list++); + if (conf_val & IMX_SCMI_PAD_SION) + mux_val |= IMX_SCMI_IOMUXC_CONFIG_SION; + + pin_id = mux_reg / 4; + + cfg[j++] = pinconf_to_config_packed(IMX_SCMI_PIN_TYPE_MUX, mux_val); + + if (!conf_reg || (conf_val & IMX_SCMI_NO_PAD_CTL)) + ncfg--; + else + cfg[j++] = pinconf_to_config_packed(IMX_SCMI_PIN_TYPE_CONFIG, conf_val); + + if (!input_reg) { + ncfg -= 2; + } else { + cfg[j++] = pinconf_to_config_packed(IMX_SCMI_PIN_TYPE_DAISY_ID, + (input_reg - daisy_off) / 4); + cfg[j++] = pinconf_to_config_packed(IMX_SCMI_PIN_TYPE_DAISY_CFG, input_val); + } + + configs = kmemdup(cfg, ncfg * sizeof(unsigned long), GFP_KERNEL); + + new_map[i].type = PIN_MAP_TYPE_CONFIGS_PIN; + new_map[i].data.configs.group_or_pin = pin_get_name(pctldev, pin_id); + new_map[i].data.configs.configs = configs; + new_map[i].data.configs.num_configs = ncfg; + } + + return 0; +} diff --git a/drivers/pinctrl/pinctrl-scmi.c b/drivers/pinctrl/pinctrl-scmi.c index 146308d27f54..b49cbfbddbc9 100644 --- a/drivers/pinctrl/pinctrl-scmi.c +++ b/drivers/pinctrl/pinctrl-scmi.c @@ -9,6 +9,7 @@ #include #include #include +#include #include #include #include @@ -19,6 +20,7 @@ #include #include +#include "pinctrl-scmi.h" #include "pinctrl-utils.h" #include "core.h" #include "pinconf.h" @@ -89,6 +91,16 @@ static const struct pinctrl_ops pinctrl_scmi_pinctrl_ops = { #endif }; +static const struct pinctrl_ops pinctrl_scmi_imx_pinctrl_ops = { + .get_groups_count = pinctrl_scmi_get_groups_count, + .get_group_name = pinctrl_scmi_get_group_name, + .get_group_pins = pinctrl_scmi_get_group_pins, +#ifdef CONFIG_OF + .dt_node_to_map = pinctrl_scmi_imx_dt_node_to_map, + .dt_free_map = pinconf_generic_dt_free_map, +#endif +}; + static int pinctrl_scmi_get_functions_count(struct pinctrl_dev *pctldev) { struct scmi_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev); @@ -439,6 +451,7 @@ static int pinctrl_scmi_get_pins(struct scmi_pinctrl *pmx, static const struct scmi_device_id scmi_id_table[] = { { SCMI_PROTOCOL_PINCTRL, "pinctrl" }, + { SCMI_PROTOCOL_PINCTRL, "pinctrl-scmi-imx", "fsl,imx95-scmi-pinctrl" }, { } }; MODULE_DEVICE_TABLE(scmi, scmi_id_table); @@ -481,6 +494,9 @@ static int scmi_pinctrl_probe(struct scmi_device *sdev) pmx->pctl_desc.pmxops = &pinctrl_scmi_pinmux_ops; pmx->pctl_desc.confops = &pinctrl_scmi_pinconf_ops; + if (device_is_compatible(dev, "fsl,imx95-scmi-pinctrl")) + pmx->pctl_desc.pctlops = &pinctrl_scmi_imx_pinctrl_ops; + ret = pinctrl_scmi_get_pins(pmx, &pmx->pctl_desc.npins, &pmx->pctl_desc.pins); if (ret) diff --git a/drivers/pinctrl/pinctrl-scmi.h b/drivers/pinctrl/pinctrl-scmi.h new file mode 100644 index 000000000000..25863b4428fe --- /dev/null +++ b/drivers/pinctrl/pinctrl-scmi.h @@ -0,0 +1,12 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright 2023 NXP + */ + +#ifndef __DRIVERS_PINCTRL_SCMI_H +#define __DRIVERS_PINCTRL_SCMI_H + +int pinctrl_scmi_imx_dt_node_to_map(struct pinctrl_dev *pctldev, struct device_node *np, + struct pinctrl_map **map, unsigned int *num_maps); + +#endif /* __DRIVERS_PINCTRL_SCMI_H */