From patchwork Wed Apr 26 13:26:37 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Oleksii Moisieiev X-Patchwork-Id: 13224615 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 90654C77B60 for ; Wed, 26 Apr 2023 13:28:03 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:In-Reply-To:References: Message-ID:Date:Subject:CC:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=NhTywqzxkrqhAyjSTrD61vEiFvH6RIO1yf02v+n2dJA=; b=cnDIs9gpjBcTxL RIhrRkrlFwTIAoxLZRD9E2z0sJ7dVqy3j7qYwoC+K3Z/ov7dvC9P2S2NyDNFcGyvpU88VEy96Q/1U S11hMhKq3xgaF78yl28AWxRsZCGJ0Q8LfzRS9gqqVG32tO5jj9AVXfzv1SlgbfKILm5IIth8eYdMa 78CbDAH5cfJmc9G8y1o0q3oHtt9RImx7adDH506N0mzd4/WcZFX7SQpHnOz52C32nZNBj6orHS01M Dt67XDAcV05OGjXg4NxHCOESYVK8rlrlEjs4uFohkJv9eNXpzVkDB3bNPVSq/Khu7H8UCLjbSHLIX +43KoAFMP9M/vzIWGZtg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1prfAl-0044rP-2f; Wed, 26 Apr 2023 13:27:03 +0000 Received: from mx0b-0039f301.pphosted.com ([148.163.137.242]) by bombadil.infradead.org with esmtps (Exim 4.96 #2 (Red Hat Linux)) id 1prfAb-0044n8-2X for linux-arm-kernel@lists.infradead.org; Wed, 26 Apr 2023 13:26:57 +0000 Received: from pps.filterd (m0174681.ppops.net [127.0.0.1]) by mx0b-0039f301.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 33Q9vWUD011543; Wed, 26 Apr 2023 13:26:48 GMT Received: from eur05-vi1-obe.outbound.protection.outlook.com (mail-vi1eur05lp2168.outbound.protection.outlook.com [104.47.17.168]) by mx0b-0039f301.pphosted.com (PPS) with ESMTPS id 3q6uwpt2nb-2 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 26 Apr 2023 13:26:47 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=U2bcN5KfuA/msOmxpjv1geQx9zAY/IAIFvjnfL/XZolt1/G/hXW+uswg+4hc4eaD+uDWWic10kPMSH7xVvGTzHOd5nK67IZGsxJM03rtJ7GsFZa+CzCA+uwcaeRYrJUAHHFGj8E5+l7aXOAGcqDeVGNj8T4VyiLPtD4+rDj5yQzBWmy2GH7ghhnyi0rIXbTUT8yvgq9nsYua6yp8TzSmBRWUoH80vNNZ06SpHCrUsyqfwHEHp51wsBAFa2rqJGLkb6+bU2BHtmywfAD37QQkvJtHwS+zsj4r2uXjsrPH/dGp4OYIscAmq4MR67bj7znXCtYRcnshRwhKoH4aYUHkTw== 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=0hnEd7OmhgbGKOGW2Yvc9Ggk0ZUsMiZTdI8WLVe2kMU=; b=d1nbbsLP2N/m+8TcYmzPRn/Fsk/t6ulRK8GX4LNRP24TleBHh/BVWBNVEaBZTxR2owhiIVUKAn0AnUnytDrigGC96B4wjcq6bav6oLw/hdEhpZcMvIznHs6xH/jDsEEcpF+0qnPh543fCVY6OWZZESUnlRgCErQ7CzuZfBkH2AaUvLCW8bmJ7Fz4lr8vr9e6PlR1c72/ThbfijjBdDar+txlInQ5ipwp8Vp8rEvLD1490YnLhSQaUFO620SwCAwzR5Q6rBvaME33FRM/SKBvAqG0NhPgIuU2cDRq/Jz0Z2vkY1PuD6cuFaaUWuE3P3e/OAuwI1z3yRNBw1tyegJtCQ== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=epam.com; dmarc=pass action=none header.from=epam.com; dkim=pass header.d=epam.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=epam.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=0hnEd7OmhgbGKOGW2Yvc9Ggk0ZUsMiZTdI8WLVe2kMU=; b=R3X85GE2LNOwadzF5dPJu9KzeCChC2WJPjbAeMYSVuHy6Jz93oav8OgQld7m7BV7WJ8t/bjQYRKugvev/rVgpacC3U8bpMyFS7RPphL87uoC/T46qzK40GrU4zLOoGpxGiz17yz4HAJM3JrLBRGqabsEunWGspSt6M8Nfj7LLxGITr1Dn0yHSqQkzIS1wvPgpFzRcgQbzbRtxnssD2kmOngV3ShS2C8I9waZOjcBsr5HPFWBCB++1N085aCwqI0//f89U7+y7LUAogV0fBs2SNJtTrVzlxthEuUWH95jhHBIe1YyljiMty8Y0Jnh+yTtK4SUwPKUlPOblnFSHOQwnw== Received: from PA4PR03MB7136.eurprd03.prod.outlook.com (2603:10a6:102:ea::23) by GV2PR03MB9380.eurprd03.prod.outlook.com (2603:10a6:150:d2::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6298.54; Wed, 26 Apr 2023 13:26:38 +0000 Received: from PA4PR03MB7136.eurprd03.prod.outlook.com ([fe80::bcf5:cd14:fd35:1300]) by PA4PR03MB7136.eurprd03.prod.outlook.com ([fe80::bcf5:cd14:fd35:1300%8]) with mapi id 15.20.6340.021; Wed, 26 Apr 2023 13:26:38 +0000 From: Oleksii Moisieiev To: "sudeep.holla@arm.com" CC: Oleksii Moisieiev , Linus Walleij , Cristian Marussi , Peng Fan , Michal Simek , "linux-kernel@vger.kernel.org" , "linux-arm-kernel@lists.infradead.org" , "linux-gpio@vger.kernel.org" Subject: [RFC v2 1/3] firmware: arm_scmi: Add SCMI v3.2 pincontrol protocol basic support Thread-Topic: [RFC v2 1/3] firmware: arm_scmi: Add SCMI v3.2 pincontrol protocol basic support Thread-Index: AQHZeEK6SX8vcPOUbkqIYZzlwR9d3Q== Date: Wed, 26 Apr 2023 13:26:37 +0000 Message-ID: References: In-Reply-To: Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-ms-publictraffictype: Email x-ms-traffictypediagnostic: PA4PR03MB7136:EE_|GV2PR03MB9380:EE_ x-ms-office365-filtering-correlation-id: 8fcf30be-d2da-4dbe-67b6-08db4659dd54 x-ms-exchange-senderadcheck: 1 x-ms-exchange-antispam-relay: 0 x-microsoft-antispam: BCL:0; x-microsoft-antispam-message-info: awfJ2VXE+E3zSZ0PsJEvCJSCVNCAcCD4e3sbqbOYV5EHOid7eIj30UFS/JGGL/42W5arnCx9KruqVJ43RVup0lVbFRjktWbVb/Zjjq7seYq5BbJOm5e4Np6BN/8WLnkqNFC6Fdx9fmQR2FX/1BelRi3WTsMdCsJICRsd4Iv4QMPBe1sgjHmlzX+1tHKpEkU5Iy3zwS4UrAat3jbrm1GwKmiucQqPDKaAD4LNElbjGOBtKh1ndgcg9ikpJua5fUHugiFgFNxPRuPOJRYqv7pkCUy1l1l2BWIbhW10CQcnbH484ygYouZvnH6cZzmnbE0yG4ebqhGcoWu9DcnMZNBJPmo4c4d2z32lpKw4eu9bJL1Af10LY+CNfUEn16YZA71TpATB+LovEgMYvEIrHC1mbAprJUyV2CTYW6sbMbIMyXVeDeQDmizVY8k+xYEBpInYhjuJ/R2Lqi3L/N33TsaT/h8HvxulVQCWCWkLrpEOtlM4kFlauVsnzME2trBoFK2jju5XBQL4mlmwEhB2G0q5K8zU5sYih2rvpbj9IqH7w4CbVXYqaXDaGPvkTiBNSjvr5u1VaL6Y3lMV1cCfkf3lYjTdPmdvkB4GyFX0Cv35JfwPwPBTqnVfASeHKW+08az6 x-forefront-antispam-report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:PA4PR03MB7136.eurprd03.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230028)(4636009)(346002)(396003)(376002)(136003)(366004)(39860400002)(451199021)(8936002)(2616005)(122000001)(8676002)(478600001)(36756003)(91956017)(316002)(76116006)(66946007)(71200400001)(66476007)(66446008)(41300700001)(6916009)(4326008)(66556008)(64756008)(6486002)(83380400001)(86362001)(54906003)(6506007)(26005)(6512007)(186003)(30864003)(2906002)(38070700005)(5660300002)(38100700002)(579004)(559001);DIR:OUT;SFP:1101; x-ms-exchange-antispam-messagedata-chunkcount: 1 x-ms-exchange-antispam-messagedata-0: =?iso-8859-1?q?NDHyJv4DKFOLGL0hLIhH+gI?= =?iso-8859-1?q?/EmtxMgJG/clbXzYu7SPWwolcrNXsrw92FQTyE2vwEzZKOmo3N8BWmW+M/Ps?= =?iso-8859-1?q?R8Tb/9v8ga6LUw0kJe5jZ3qneqvmC6LP57T0VV0KJAw8iM/kDjfEPz4Fr69H?= =?iso-8859-1?q?ez0m6k6OK8BlyMBskUrKxOoSF4miGxjHZvPC3acXwyOkGa+UQvZLl5JMcDzt?= =?iso-8859-1?q?vY6GXnwOaGVYW6N95lLtQN/ykV2tJEZO7jYGZxfPPFErAUZ1v7HKqd6gD4mS?= =?iso-8859-1?q?ww4jwOOrfzfRWHUETGJTO4KvLOg0tw3sDM0ygDtzXXjvH9xywfW4uEr2zOEP?= =?iso-8859-1?q?hd6Ie4rL6cIeXKgd2jvOcoufpXs2HXnWSJYcHYsE6AxiCnxufCAB9y4iAofp?= =?iso-8859-1?q?vMcljcMw9JRQPYhh1byQsQJHoCSL7MIM1wOg0iWeDjRRZlfth21PA3x2LEY5?= =?iso-8859-1?q?GfOXpozVALnUjiVjZqMO0lg+lVBly3xP3gD7dNVMKzcb17QhZmXxtbnfbNvT?= =?iso-8859-1?q?dwQb3odRrW2sgkOTMX4JVSQd16z4BhVRD4p4PFa2rUJGEPhrux3MaDv2yY8b?= =?iso-8859-1?q?gfyIvWCM7sDG8SHbNDkpe8IUloalqq7cNIcUn3erB7D+/FLy1KNwAXmmsbpi?= =?iso-8859-1?q?uiOGaKBSVr8i9QvyAEiM2AyXUqeVDi+FQbVwb5tXDa/4h0PU65kJTnq3PrJ6?= =?iso-8859-1?q?NDeucVq8AWb7vK5opURB2Xve/pwM3Q2CDVSpS/pZUaeA9CO5u6lj8X10MkmG?= =?iso-8859-1?q?mreCwMYuRAceVh9mFfn/RMnYAmJJ4VZ4GesocLPUrT3nVOG6ciQ6Jrrx82+M?= =?iso-8859-1?q?0n4re05lrWSK4oOj1BPKF+fT2WG3lkPMUJXPkFVXD1mHq29EK3efynYlawJZ?= =?iso-8859-1?q?OdNHkD+LrgexSi77Nmb7a+t7lLW/4TTwMvr+ezMDFjkVOzlk+ft/dAJ+QmFP?= =?iso-8859-1?q?HlDIOxSj7G6n3SabWxB+Tzwch5prB2y+Dpq1I9dpAw8D1FTp7v1GNxgXGdVc?= =?iso-8859-1?q?u3lI6hAEusQAw1pkVdnB6z/mxDoS5Cu9FQYgh7a5YX2Ch8xj0nENY9iDOpfi?= =?iso-8859-1?q?DKawLv9cTm/4ivcLCA9l/hHL6VbwNKEHeX42BOvxY+L/98yEeRcizzMTIvtG?= =?iso-8859-1?q?5dKCglIZatupEDBlh/yH4pZIz4K8rTkkYihNqi0Hc7E34/xh54WZJZdXsK6s?= =?iso-8859-1?q?O3lDFHgNuy3S9xmN1MCzCSKf/QmwQokjGCc2QT2vedpMbjZE/acNPA4u2CDJ?= =?iso-8859-1?q?MOc3RpEoth4nJMvPmBroqrBqvgDa+XC00Wvjw5wVWKM/gHgNHK6GmE23LoIr?= =?iso-8859-1?q?Ioau+Dqi76UiNPBffWtDdB2BQ9Xj7Md/bFkeqWaxG/OyAC9D6KazuxSSW7po?= =?iso-8859-1?q?rxaZPBkNR2wCfI69pVAmyhK/5I8kF/AThg2MqbouZ4VYtHFmTPRyHiyRJ346?= =?iso-8859-1?q?HUy6+Dz07CLqM9zB6lpuwoLGSfaNTsXVh5YVdcTipX5GMMfvZXSv5qWbTl+d?= =?iso-8859-1?q?QPFC+NhVCA7gKncMR0EiybUP0MJW0bPxxXw+tisVc5b0GaEzgX//rIL2eAg1?= =?iso-8859-1?q?m17hp2dHQt19QERCVPCIao/n5/jrfOppIq7+jbgomrQB/XcZWqN7fuk+IAdm?= =?iso-8859-1?q?K5C4KDXZJmgSYnTQDLxD9ZMfsgs/aasD4E5TDoA=3D=3D?= MIME-Version: 1.0 X-OriginatorOrg: epam.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-AuthSource: PA4PR03MB7136.eurprd03.prod.outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: 8fcf30be-d2da-4dbe-67b6-08db4659dd54 X-MS-Exchange-CrossTenant-originalarrivaltime: 26 Apr 2023 13:26:37.4781 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Hosted X-MS-Exchange-CrossTenant-id: b41b72d0-4e9f-4c26-8a69-f949f367c91d X-MS-Exchange-CrossTenant-mailboxtype: HOSTED X-MS-Exchange-CrossTenant-userprincipalname: x+DPamQjz8AUSy2pXvP5T+DKk76Ui78vbt/MNIWgqlNLay2vClc9iM7SqZw2O4ee2SJEzZDOx3gh00yxEjOhxhvteI/V8Cnr5iIw3llNXOM= X-MS-Exchange-Transport-CrossTenantHeadersStamped: GV2PR03MB9380 X-Proofpoint-ORIG-GUID: 22Em8f-hJzD3r4l_0DdplRxEbIAXkEQT X-Proofpoint-GUID: 22Em8f-hJzD3r4l_0DdplRxEbIAXkEQT X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.254,Aquarius:18.0.942,Hydra:6.0.573,FMLib:17.11.170.22 definitions=2023-04-26_06,2023-04-26_03,2023-02-09_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 impostorscore=0 lowpriorityscore=0 clxscore=1015 phishscore=0 adultscore=0 malwarescore=0 mlxscore=0 spamscore=0 bulkscore=0 priorityscore=1501 suspectscore=0 mlxlogscore=999 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2303200000 definitions=main-2304260119 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20230426_062653_949140_74262FD5 X-CRM114-Status: GOOD ( 19.67 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org scmi: Introduce pinctrl SCMI protocol driver Add basic implementation of the SCMI v3.2 pincontrol protocol excluding GPIO support. All pinctrl related callbacks and operations are exposed in the include/linux/scmi_protocol.h Signed-off-by: Oleksii Moisieiev --- MAINTAINERS | 6 + drivers/firmware/arm_scmi/Makefile | 3 +- drivers/firmware/arm_scmi/driver.c | 2 + drivers/firmware/arm_scmi/pinctrl.c | 932 ++++++++++++++++++++++++++ drivers/firmware/arm_scmi/protocols.h | 1 + include/linux/scmi_protocol.h | 47 ++ 6 files changed, 990 insertions(+), 1 deletion(-) create mode 100644 drivers/firmware/arm_scmi/pinctrl.c diff --git a/MAINTAINERS b/MAINTAINERS index 0e64787aace8..0d251ebac437 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -20317,6 +20317,12 @@ F: include/linux/sc[mp]i_protocol.h F: include/trace/events/scmi.h F: include/uapi/linux/virtio_scmi.h +PINCTRL DRIVER FOR SYSTEM CONTROL & POWER/MANAGEMENT INTERFACE (SCPI/SCMI) +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 b31d78fa66cc..071ac65f22b9 100644 --- a/drivers/firmware/arm_scmi/Makefile +++ b/drivers/firmware/arm_scmi/Makefile @@ -3,6 +3,7 @@ scmi-bus-y = bus.o scmi-core-objs := $(scmi-bus-y) scmi-driver-y = driver.o notify.o + scmi-driver-$(CONFIG_ARM_SCMI_RAW_MODE_SUPPORT) += raw_mode.o scmi-transport-$(CONFIG_ARM_SCMI_HAVE_SHMEM) = shmem.o scmi-transport-$(CONFIG_ARM_SCMI_TRANSPORT_MAILBOX) += mailbox.o @@ -10,7 +11,7 @@ scmi-transport-$(CONFIG_ARM_SCMI_TRANSPORT_SMC) += smc.o 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 = base.o clock.o perf.o power.o reset.o sensors.o system.o voltage.o powercap.o 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 dbc474ff62b7..fc7ba587ae6e 100644 --- a/drivers/firmware/arm_scmi/driver.c +++ b/drivers/firmware/arm_scmi/driver.c @@ -3021,6 +3021,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); } @@ -3038,6 +3039,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..1c643d21390f --- /dev/null +++ b/drivers/firmware/arm_scmi/pinctrl.c @@ -0,0 +1,932 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * System Control and Management Interface (SCMI) Pinctrl Protocol + * + * Copyright (C) 2023 EPAM + */ + +#include +#include +#include + +#include "protocols.h" + +#define SET_TYPE(x) FIELD_PREP(GENMASK(1, 0), (x)) + +#define REG_TYPE_BITS GENMASK(9, 8) +#define REG_CONFIG GENMASK(7, 0) + +#define GET_GROUPS_NR(x) FIELD_GET(GENMASK(31, 16), (x)) +#define GET_PINS_NR(x) FIELD_GET(GENMASK(15, 0), (x)) +#define GET_FUNCTIONS_NR(x) FIELD_GET(GENMASK(15, 0), (x)) + +#define EXT_NAME_FLAG(x) FIELD_GET(BIT(31), (x)) +#define NUM_ELEMS(x) FIELD_GET(GENMASK(15, 0), (x)) + +#define REMAINING(x) FIELD_GET(GENMASK(31, 16), (x)) +#define RETURNED(x) FIELD_GET(GENMASK(11, 0), (x)) + +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 config_value; +}; + +struct scmi_msg_conf_get { + __le32 identifier; + __le32 attributes; +}; + +struct scmi_msg_pinctrl_protocol_attributes { + __le32 attributes_low; + __le32 attributes_high; +}; + +struct scmi_msg_ext_name { + __le32 identifier; + __le32 flags; +}; + +struct scmi_resp_ext_name { + __le32 flags; + u8 name[SCMI_MAX_STR_SIZE]; +}; + +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 { + bool present; + char *name; + unsigned int *group_pins; + unsigned int nr_pins; +}; + +struct scmi_function_info { + bool present; + char *name; + unsigned int *groups; + unsigned int nr_groups; +}; + +struct scmi_pin_info { + bool present; + char *name; +}; + +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; + + if (!pi) + return -EINVAL; + + 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 = + le16_to_cpu(GET_FUNCTIONS_NR(attr->attributes_high)); + pi->nr_groups = le16_to_cpu(GET_GROUPS_NR(attr->attributes_low)); + pi->nr_pins = le16_to_cpu(GET_PINS_NR(attr->attributes_low)); + } + + ph->xops->xfer_put(ph, t); + return ret; +} + +static int scmi_pinctrl_get_count(const struct scmi_protocol_handle *ph, + enum scmi_pinctrl_selector_type type) +{ + struct scmi_pinctrl_info *pi; + + if (!ph) + return -ENODEV; + + pi = ph->get_priv(ph); + if (!pi) + return -ENODEV; + + 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; + + if (!ph) + return -ENODEV; + + value = scmi_pinctrl_get_count(ph, type); + if (value < 0) + return value; + + if (identifier >= value) + return -EINVAL; + + return 0; +} + +static int scmi_pinctrl_get_ext_name(const struct scmi_protocol_handle *ph, + u32 identifier, + enum scmi_pinctrl_selector_type type, + char **name) +{ + struct scmi_xfer *t; + int ret = 0; + struct scmi_msg_ext_name *tx; + struct scmi_resp_ext_name *rx; + + if (!ph || !name) + return -EINVAL; + + ret = scmi_pinctrl_validate_id(ph, identifier, type); + if (ret) + return ret; + + ret = ph->xops->xfer_get_init(ph, PINCTRL_NAME_GET, sizeof(*tx), + sizeof(*rx), &t); + + tx = t->tx.buf; + rx = t->rx.buf; + tx->identifier = identifier; + tx->flags = SET_TYPE(cpu_to_le32(type)); + + ret = ph->xops->do_xfer(ph, t); + if (ret) + goto out; + + if (rx->flags) { + ret = -EINVAL; + goto out; + } + + *name = kasprintf(GFP_KERNEL, "%s", rx->name); + if (!*name) + ret = -ENOMEM; + out: + ph->xops->xfer_put(ph, t); + + return ret; +} + +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 = 0; + struct scmi_xfer *t; + struct scmi_msg_pinctrl_attributes *tx; + struct scmi_resp_pinctrl_attributes *rx; + + if (!ph || !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 = selector; + tx->flags = SET_TYPE(cpu_to_le32(type)); + + ret = ph->xops->do_xfer(ph, t); + if (ret) + goto out; + + *n_elems = NUM_ELEMS(rx->attributes); + + if (!EXT_NAME_FLAG(rx->attributes)) { + *name = kasprintf(GFP_KERNEL, "%s", rx->name); + if (!*name) + ret = -ENOMEM; + } else { + ret = scmi_pinctrl_get_ext_name(ph, selector, type, name); + } + out: + ph->xops->xfer_put(ph, t); + 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 = SET_TYPE(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 = le32_to_cpu(RETURNED(r->flags)); + st->num_remaining = le32_to_cpu(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 (!ph || !array || !size) + return -EINVAL; + + if (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); +} + +static int scmi_pinctrl_get_config(const struct scmi_protocol_handle *ph, + u32 selector, + enum scmi_pinctrl_selector_type type, + u8 config_type, u32 *config_value) +{ + struct scmi_xfer *t; + struct scmi_msg_conf_get *tx; + __le32 *le_config; + u32 attributes = 0; + int ret; + + if (!ph || !config_value || type == FUNCTION_TYPE) + return -EINVAL; + + ret = scmi_pinctrl_validate_id(ph, selector, type); + if (ret) + return ret; + + ret = ph->xops->xfer_get_init(ph, PINCTRL_CONFIG_GET, sizeof(*tx), + sizeof(*le_config), &t); + if (ret) + return ret; + + tx = t->tx.buf; + le_config = t->rx.buf; + tx->identifier = cpu_to_le32(selector); + attributes = FIELD_PREP(REG_TYPE_BITS, type) | + FIELD_PREP(REG_CONFIG, config_type); + + tx->attributes = cpu_to_le32(attributes); + + ret = ph->xops->do_xfer(ph, t); + + if (!ret) + *config_value = le32_to_cpu(*le_config); + + ph->xops->xfer_put(ph, t); + return ret; +} + +static int scmi_pinctrl_set_config(const struct scmi_protocol_handle *ph, + u32 selector, + enum scmi_pinctrl_selector_type type, + u8 config_type, u32 config_value) +{ + struct scmi_xfer *t; + struct scmi_msg_conf_set *tx; + u32 attributes = 0; + int ret; + + if (!ph || type == FUNCTION_TYPE) + return -EINVAL; + + ret = scmi_pinctrl_validate_id(ph, selector, type); + if (ret) + return ret; + + ret = ph->xops->xfer_get_init(ph, PINCTRL_CONFIG_SET, + sizeof(*tx), 0, &t); + if (ret) + return ret; + + tx = t->tx.buf; + tx->identifier = cpu_to_le32(selector); + attributes = FIELD_PREP(REG_TYPE_BITS, type) | + FIELD_PREP(REG_CONFIG, config_type); + tx->attributes = cpu_to_le32(attributes); + tx->config_value = cpu_to_le32(config_value); + + ret = ph->xops->do_xfer(ph, t); + + ph->xops->xfer_put(ph, t); + 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) +{ + struct scmi_xfer *t; + struct scmi_msg_func_set *tx; + int ret; + + if (!ph || 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 = SET_TYPE(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) +{ + struct scmi_xfer *t; + int ret; + struct scmi_msg_request *tx; + + if (!ph || 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 = identifier; + tx->flags = SET_TYPE(cpu_to_le32(type)); + + ret = ph->xops->do_xfer(ph, t); + ph->xops->xfer_put(ph, t); + + return ret; +} + +static int scmi_pinctrl_request_pin(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) +{ + struct scmi_xfer *t; + int ret; + struct scmi_msg_request *tx; + + if (!ph || 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 = identifier; + tx->flags = SET_TYPE(cpu_to_le32(type)); + + ret = ph->xops->do_xfer(ph, t); + ph->xops->xfer_put(ph, t); + + return ret; +} + +static int scmi_pinctrl_free_pin(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 = 0; + + if (!ph || !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 = devm_kmalloc_array(ph->dev, group->nr_pins, + sizeof(*group->group_pins), + GFP_KERNEL); + if (!group->group_pins) { + ret = -ENOMEM; + goto err; + } + + ret = scmi_pinctrl_list_associations(ph, selector, GROUP_TYPE, + group->nr_pins, group->group_pins); + if (ret) + goto err_groups; + + group->present = true; + return 0; + + err_groups: + kfree(group->group_pins); + err: + kfree(group->name); + return ret; +} + +static int scmi_pinctrl_get_group_name(const struct scmi_protocol_handle *ph, + u32 selector, const char **name) +{ + int ret; + struct scmi_pinctrl_info *pi; + + if (!ph || !name) + return -EINVAL; + + pi = ph->get_priv(ph); + if (!pi) + return -EINVAL; + + if (selector > pi->nr_groups) + return -EINVAL; + + if (!pi->groups[selector].present) { + 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_get_group_pins(const struct scmi_protocol_handle *ph, + u32 selector, const unsigned int **pins, + unsigned int *nr_pins) +{ + int ret; + struct scmi_pinctrl_info *pi; + + if (!ph || !pins || !nr_pins) + return -EINVAL; + + pi = ph->get_priv(ph); + if (!pi) + return -EINVAL; + + if (selector > pi->nr_groups) + return -EINVAL; + + if (!pi->groups[selector].present) { + 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 ret; +} + +static int scmi_pinctrl_get_function_info(const struct scmi_protocol_handle *ph, + u32 selector, + struct scmi_function_info *func) +{ + int ret = 0; + + if (!ph || !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 = devm_kmalloc_array(ph->dev, func->nr_groups, + sizeof(*func->groups), + GFP_KERNEL); + if (!func->groups) { + ret = -ENOMEM; + goto err; + } + + ret = scmi_pinctrl_list_associations(ph, selector, FUNCTION_TYPE, + func->nr_groups, func->groups); + if (ret) + goto err_funcs; + + func->present = true; + return 0; + + err_funcs: + kfree(func->groups); + err: + kfree(func->name); + return ret; +} + +static int scmi_pinctrl_get_function_name(const struct scmi_protocol_handle *ph, + u32 selector, const char **name) +{ + int ret; + struct scmi_pinctrl_info *pi; + + if (!ph || !name) + return -EINVAL; + + pi = ph->get_priv(ph); + if (!pi) + return -EINVAL; + + if (selector > pi->nr_functions) + return -EINVAL; + + if (!pi->functions[selector].present) { + 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_get_function_groups(const struct scmi_protocol_handle *ph, + u32 selector, + unsigned int *nr_groups, + const unsigned int **groups) +{ + int ret; + struct scmi_pinctrl_info *pi; + + if (!ph || !groups || !nr_groups) + return -EINVAL; + + pi = ph->get_priv(ph); + if (!pi) + return -EINVAL; + + if (selector > pi->nr_functions) + return -EINVAL; + + if (!pi->functions[selector].present) { + 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 ret; +} + +static int scmi_pinctrl_set_mux(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 = 0; + struct scmi_pinctrl_info *pi; + unsigned int n_elems; + + if (!ph || !pin) + return -EINVAL; + + pi = ph->get_priv(ph); + if (!pi) + return -EINVAL; + + ret = scmi_pinctrl_attributes(ph, PIN_TYPE, selector, + &pin->name, + &n_elems); + if (ret) + return ret; + + if (n_elems != pi->nr_pins) { + dev_err(ph->dev, "Wrong pin count expected %d has %d", + pi->nr_pins, n_elems); + return -ENODATA; + } + + if (*pin->name == 0) { + dev_err(ph->dev, "Pin name is empty"); + goto err; + } + + pin->present = true; + return 0; + + err: + kfree(pin->name); + return ret; +} + +static int scmi_pinctrl_get_pin_name(const struct scmi_protocol_handle *ph, + u32 selector, const char **name) +{ + int ret; + struct scmi_pinctrl_info *pi; + + if (!ph || !name) + return -EINVAL; + + pi = ph->get_priv(ph); + if (!pi) + return -EINVAL; + + if (selector > pi->nr_pins) + return -EINVAL; + + if (!pi->pins[selector].present) { + 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_get_name(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 = { + .get_count = scmi_pinctrl_get_count, + .get_name = scmi_pinctrl_get_name, + .get_group_pins = scmi_pinctrl_get_group_pins, + .get_function_groups = scmi_pinctrl_get_function_groups, + .set_mux = scmi_pinctrl_set_mux, + .get_config = scmi_pinctrl_get_config, + .set_config = scmi_pinctrl_set_config, + .request_pin = scmi_pinctrl_request_pin, + .free_pin = scmi_pinctrl_free_pin +}; + +static int scmi_pinctrl_protocol_init(const struct scmi_protocol_handle *ph) +{ + u32 version; + struct scmi_pinctrl_info *pinfo; + int ret; + + if (!ph) + return -EINVAL; + + 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); +} + +static int scmi_pinctrl_protocol_deinit(const struct scmi_protocol_handle *ph) +{ + int i; + struct scmi_pinctrl_info *pi; + + if (!ph) + return -EINVAL; + + pi = ph->get_priv(ph); + if (!pi) + return -EINVAL; + + for (i = 0; i < pi->nr_groups; i++) + if (pi->groups[i].present) { + devm_kfree(ph->dev, pi->groups[i].group_pins); + pi->groups[i].present = false; + } + + for (i = 0; i < pi->nr_functions; i++) + if (pi->functions[i].present) { + devm_kfree(ph->dev, 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, +}; + +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 78e1a01eb656..533b94c9a9a7 100644 --- a/drivers/firmware/arm_scmi/protocols.h +++ b/drivers/firmware/arm_scmi/protocols.h @@ -345,5 +345,6 @@ DECLARE_SCMI_REGISTER_UNREGISTER(sensors); DECLARE_SCMI_REGISTER_UNREGISTER(voltage); DECLARE_SCMI_REGISTER_UNREGISTER(system); DECLARE_SCMI_REGISTER_UNREGISTER(powercap); +DECLARE_SCMI_REGISTER_UNREGISTER(pinctrl); #endif /* _SCMI_PROTOCOLS_H */ diff --git a/include/linux/scmi_protocol.h b/include/linux/scmi_protocol.h index 0ce5746a4470..8e15d2912045 100644 --- a/include/linux/scmi_protocol.h +++ b/include/linux/scmi_protocol.h @@ -735,6 +735,52 @@ struct scmi_notify_ops { struct notifier_block *nb); }; +enum scmi_pinctrl_selector_type { + PIN_TYPE = 0, + GROUP_TYPE, + FUNCTION_TYPE +}; + +/** + * struct scmi_pinctrl_protocol_ops - represents the various operations provided + * by SCMI Pinctrl Protocol + * + * @get_count: returns count of the registered elements in given type + * @get_name: returns name by index of given type + * @get_group_pins: returns the set of pins, assigned to the specified group + * @get_function_groups: returns the set of groups, assigned to the specified + * function + * @set_mux: set muxing function for groups of pins + * @get_config: returns configuration parameter for pin or group + * @set_config: sets the configuration parameter for pin or group + * @request_pin: aquire pin before selecting mux setting + * @free_pin: frees pin, acquired by request_pin call + */ +struct scmi_pinctrl_proto_ops { + int (*get_count)(const struct scmi_protocol_handle *ph, + enum scmi_pinctrl_selector_type type); + int (*get_name)(const struct scmi_protocol_handle *ph, + u32 selector, + enum scmi_pinctrl_selector_type type, + const char **name); + int (*get_group_pins)(const struct scmi_protocol_handle *ph, + u32 selector, + const unsigned int **pins, unsigned int *nr_pins); + int (*get_function_groups)(const struct scmi_protocol_handle *ph, + u32 selector, unsigned int *nr_groups, + const unsigned int **groups); + int (*set_mux)(const struct scmi_protocol_handle *ph, u32 selector, + u32 group); + int (*get_config)(const struct scmi_protocol_handle *ph, u32 selector, + enum scmi_pinctrl_selector_type type, + u8 config_type, u32 *config_value); + int (*set_config)(const struct scmi_protocol_handle *ph, u32 selector, + enum scmi_pinctrl_selector_type type, + u8 config_type, u32 config_value); + int (*request_pin)(const struct scmi_protocol_handle *ph, u32 pin); + int (*free_pin)(const struct scmi_protocol_handle *ph, u32 pin); +}; + /** * struct scmi_handle - Handle returned to ARM SCMI clients for usage. * @@ -783,6 +829,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 Wed Apr 26 13:26:38 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Oleksii Moisieiev X-Patchwork-Id: 13224613 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 04D0EC7618E for ; Wed, 26 Apr 2023 13:27:52 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:In-Reply-To:References: Message-ID:Date:Subject:CC:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=z86INyTnT7zRsf8rsRFWoCq8aVjM0BAeDxKvEeX3gW0=; b=p6DkCy0rhND3Wr gXyilRapzkj6ZXu9Lx5nIc/JUA2Ha+xmmoiEXd7noT0GGIzkroWDUiTJPJat65McHVPx0UF61q0rj 1k7LwyF5To/kChuUxPKAv74+nrQyJ2CMg8FRhSv/OIjBjhGfr9L7gJauXGlfAYggeIOOutOJ53DUK D7LAl2C2Uuq+PJjNYtUgXmYo3QnrVF54nKMiPbuNYfWLYm+K4Dl7sPrgzvFOnXDc2s/ugC+0MF/Af QPPimxznT4h/POWLhd/7DbeA4QHeU65W8XHorW3Ffx6V4QAYZjmOdlq/oZ61qcKiRfjctDWBfQccB IQJGO/Ij35B50IK1wXdQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1prfAd-0044oR-3B; Wed, 26 Apr 2023 13:26:56 +0000 Received: from mx0a-0039f301.pphosted.com ([148.163.133.242]) by bombadil.infradead.org with esmtps (Exim 4.96 #2 (Red Hat Linux)) id 1prfAa-0044mX-1b for linux-arm-kernel@lists.infradead.org; Wed, 26 Apr 2023 13:26:54 +0000 Received: from pps.filterd (m0174678.ppops.net [127.0.0.1]) by mx0a-0039f301.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 33Q9uUQw029566; Wed, 26 Apr 2023 13:26:45 GMT Received: from eur01-he1-obe.outbound.protection.outlook.com (mail-he1eur01lp2054.outbound.protection.outlook.com [104.47.0.54]) by mx0a-0039f301.pphosted.com (PPS) with ESMTPS id 3q6ahkwm6b-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 26 Apr 2023 13:26:44 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=LNoN8U6No9BJlQkSIvV76CeaTY4QfbLiEIWvXJOr9jsMVrpjCoB1HsOtTMHXFMe6M+m9foiKJOehRQTdmN5K2+mqAnwZfriaAWEgHzDDrzVS+4A9lbdDIPRSf8MqHIYUQ/XQoU5UqWjImDOBgJiDGhdTzDcOdKC1FhUg4vhyCPiRMGDjmznvzudu7RUa6awlmJS1eBfbzU7hAg1J9m0rWCOMsnpDoK6ql3dVtDnKqDwH59cFuKA/IzZc09Z2nwrwZ9g21VzWMYxDghvtnHF6cqq1PyIlEkCEckM7EcfD5+E5vh/32Z6el0QwLsKV8YECD/AQCQnrir4YyaE2NWeMOQ== 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=pyof/IvHyf2ZBLD2cKuGurdEc+LS5/o9SwZ6hqrgSJI=; b=Dpstp540/MOrtmdYtDU6j/sdPEQEAO41VqsMjq+wkMmMhXyIFrVqxAjmX2Heku8fJ3uVAITkhbaG0HJEqLwDvvUawK7BM/DkfvMnxFXBKfXvAhq0QmeKn9MY5sTlbTteFacVkRYz+UlFUgZ3qZHv/0zYkhDEJ4XCUg6kfsfFOkBcM7Aj8e6KvHa1kcquZNgQKRnRtxw/XVBUC+NId4K6Zp4RXULVlsPCjnntSLR5hTj2HSNZPxDaZYoiAvmQdw1qXS2sMiLxeu7x/uD0nHj6r0Wyqaiv2ANeSTfsLUUbUMP9XSU9FLG2XW5GNFsIgeiM/XO3+d8COsSCrETHYRH5+Q== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=epam.com; dmarc=pass action=none header.from=epam.com; dkim=pass header.d=epam.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=epam.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=pyof/IvHyf2ZBLD2cKuGurdEc+LS5/o9SwZ6hqrgSJI=; b=sNLL2FLJbO8mti75yGLgSxiYO5BaXrhxHYU2ojgwpfAqDURE3r0jx1sLjq4kOiYsX3f14/cdwfkg2Wrbieu+r39CPXABFtjF7UqvEXVxSYqnWjYwjOx1/9+C45idygxuVLhqpz9q2QEXzeuRhCFYAd1KsusiY4AIdslUL3J82paH+vPXmxEVaQuqarLp0X1qyF9otYYhhT6IyueJ5BPqHUXrDMhkobrzBWlk2CcFwlXNSxSndwTXqLBV4AW6EBGahNXYOCzs0QFzdlCCwB6FIcGD9h1SYLM5feXZcvmX7eaJQNniV2DBExeFuPaosBkrChhouxgBw2sw4pvHHQqtyg== Received: from PA4PR03MB7136.eurprd03.prod.outlook.com (2603:10a6:102:ea::23) by GV2PR03MB9380.eurprd03.prod.outlook.com (2603:10a6:150:d2::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6298.54; Wed, 26 Apr 2023 13:26:39 +0000 Received: from PA4PR03MB7136.eurprd03.prod.outlook.com ([fe80::bcf5:cd14:fd35:1300]) by PA4PR03MB7136.eurprd03.prod.outlook.com ([fe80::bcf5:cd14:fd35:1300%8]) with mapi id 15.20.6340.021; Wed, 26 Apr 2023 13:26:39 +0000 From: Oleksii Moisieiev To: "sudeep.holla@arm.com" CC: Oleksii Moisieiev , Linus Walleij , Cristian Marussi , Peng Fan , Michal Simek , "linux-kernel@vger.kernel.org" , "linux-arm-kernel@lists.infradead.org" , "linux-gpio@vger.kernel.org" Subject: [RFC v2 3/3] dt-bindings: firmware: arm,scmi: Add support for pinctrl protocol Thread-Topic: [RFC v2 3/3] dt-bindings: firmware: arm,scmi: Add support for pinctrl protocol Thread-Index: AQHZeEK6qDUGtqz4K06E9chyDcKW7g== Date: Wed, 26 Apr 2023 13:26:38 +0000 Message-ID: References: In-Reply-To: Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-ms-publictraffictype: Email x-ms-traffictypediagnostic: PA4PR03MB7136:EE_|GV2PR03MB9380:EE_ x-ms-office365-filtering-correlation-id: 4b85c04f-9786-4e42-6e0e-08db4659dde3 x-ms-exchange-senderadcheck: 1 x-ms-exchange-antispam-relay: 0 x-microsoft-antispam: BCL:0; x-microsoft-antispam-message-info: sB7jkFcrAisKbBhIX8tEXnt0jCtyHudfiovAomSOe7kortmUJq00hubfca39pQYjJv6dPYlUtlrCvMDNxadXSCIvgwU9qkI9SWqhIbba1b14ObXYVG66Gs9BXjxblv2F3RJgUbDIlnau8Pcmw5+8ohNhgz5SmWhkOSHO6x7F4p4lN2c3TRayAGrNYHaFP/+bydtF5h/tflt4WRAUQvj5cSJHSVX21Or+iD5jtau0UmkZHeZ0o5xTvTskSFvLleFwMMejoAGDOidtDfMeYj0GVH/d8gBdLqbbeK359TpTx9LeuTQa7iEF5J25p2jpqGB2/0kRkM0OOvdFiSijLGWHnaSQr8J/G51g2KMYSDzJ17Cp0g2hkF6Hi/RTjeYFWRMOMvJ9O1QDiC0lqQ8fMxFcN0f2Jrp6w7s6PzToLQpHEc8qH0N8jylc8oF13hNe0SWkPjfwqj4uTgh8ZBMie4T2G2D6CcRnsJIDxfqFFUvAPykNAolXA/FYep5koin+Gj6Z1f3d4lsPXD4t+S1XRyBx7EPHOKkbAPjr9q0QFHfPxihkW1LjrYOHquT/XCH310or74rs2BNTkHjhC4SRsfpGuOL61Bxr5pO174ZwkY0OXv8Zb5hUKQOm709DftZggoR9 x-forefront-antispam-report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:PA4PR03MB7136.eurprd03.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230028)(4636009)(346002)(396003)(376002)(136003)(366004)(39860400002)(451199021)(8936002)(2616005)(122000001)(8676002)(478600001)(36756003)(91956017)(316002)(76116006)(66946007)(71200400001)(66476007)(66446008)(41300700001)(6916009)(4326008)(66556008)(64756008)(6486002)(86362001)(54906003)(6506007)(26005)(6512007)(186003)(2906002)(38070700005)(5660300002)(38100700002);DIR:OUT;SFP:1101; x-ms-exchange-antispam-messagedata-chunkcount: 1 x-ms-exchange-antispam-messagedata-0: =?iso-8859-1?q?VNu2IY3P5h4I73alhbw/6xc?= =?iso-8859-1?q?K/baqO7/GhYsSqBOBlLvFziqbPVtYxq6GG8cCT5C97YoilxpuCvyIpHpYuMg?= =?iso-8859-1?q?P49O+9lq/Mt8BpgJcgxfn+gv3SrrXgC9rBP7fg8uE3EcuY12F5dLGEWh71KZ?= =?iso-8859-1?q?U0aSER8Z8bNTkVxTKHHGf4W2K6LJcKy3WHAdai9l28IPg64za+4TvwP00Dt4?= =?iso-8859-1?q?7B3rY9PWwxmvUMUKOEBqXtEbcbq4zF31H95EOUsfEhRrblHcs6UHxZLUOg8/?= =?iso-8859-1?q?pY3xjeptRH/3fa4kTzu2rWTT1AAPT6+aT2DggHGJSSatX43cyuDrKHvjniTt?= =?iso-8859-1?q?H6iVT8t/Y/PHY+HkypnljDzP2Hx4eIKObBmzPsUKW74Muf/O/7+PCdM4a1Eo?= =?iso-8859-1?q?bUBHui+tdv/yatbGjnqQHXwfbqQJfh4ruKjIqzr1XBAa2AaaZyHJjm/uQ45H?= =?iso-8859-1?q?P2wF2n4jX8nslnhTHbHnan6Tn4q0/IHOWoYhykdI8mILIvhWJPlOaybuMqU2?= =?iso-8859-1?q?QOIS51YAGVhyR1BUZDFTWY3JnxSzdoWWLJEhrfxvFfZpwoVYmSqc0mgS0RnG?= =?iso-8859-1?q?wPGuJB4uW6SpPyO/86THwPIs/ssp9dZxF0I+nWnE4kodJajtpj1L69O9ymvD?= =?iso-8859-1?q?3zd0le9oxEy6XowZU4Eiqy8dUdHt8RRK5fj8/6nL/WdlH1NzZDv7umhEpLtf?= =?iso-8859-1?q?vu6u04Y2Gg/necSTJhxtLmXk7uFmike7xLRO9VlReC5KkQu41J1CYpYVSc72?= =?iso-8859-1?q?I2BiudvGtk+TrunehooGOmOr0oDy6k4UFZxSM1VBpQEuzIV2f0LglFsywgND?= =?iso-8859-1?q?oAZ3gOP5vCoSE5EVPuzoPCiGBffbd/JuoTOhgaP5J/1Vh3zQTaZ9XfMlFoDx?= =?iso-8859-1?q?Jez+JNlzvNOHVKHCEQ+MLgD8b0jgl/KAk9QWtY/iE1zx6aO4OgJSBXnK7PVq?= =?iso-8859-1?q?3lwh2lVxWK3j5A2/X6/N0vcWFK5V4jVXf/MwSGOACyPeiZs2Xh3CSwcpAgDJ?= =?iso-8859-1?q?f+27G4IVNG3Xc1R8WxOE3qkv9s1lb3HcmbJm9migkrKNeoNmZ8Mw4c12T2P4?= =?iso-8859-1?q?bBIFCUv976t36GcDTmmDFPMErEoPhR6TWPpeuDIk9tOGQwGlAfMvDJ+KH7co?= =?iso-8859-1?q?j7ufERZPvJ4IixLMHjQWq5MWtxpH9srnVa1kY1iIQsyOcnNh1ZqbauLjXnoz?= =?iso-8859-1?q?P35FcOFzOqEkvpWDkPYfdQkKjqTdfOW2cr4oohtTU/FXl/LPxR7Ogb13c1o5?= =?iso-8859-1?q?esAzVSw5OszVJWQ/deQdyimoe9Gl+g2dlhLWEfpuZGJde75Sna3rjKv3OEKD?= =?iso-8859-1?q?/nx1zFwg/6QNjpPxzCn9gUNc2SU/d+qTcY8b0c/acy5/TLGToNPVI4p1oFrC?= =?iso-8859-1?q?0d5+B9oME6+Njdqv2cpRleRc3+LXN9t9Pk2DNwD+8k40ML+XWexHVe6bLaVL?= =?iso-8859-1?q?+PeXKYY1j/LI9gX/bOMt4IJHPAK55ojdFWMvdlYlS0//SkSbRDS41Z+ns/vG?= =?iso-8859-1?q?lFwo5uL+nCmdE39Y3A4iJ5SEdygjveONtb08uiWnYe6uQrmsUxs4UG9UdpOX?= =?iso-8859-1?q?5ksrva+5ZM8BQXLFBAYrrAwGKvpiKTNyY0il7yACQtpljbRHTZTZ3WB/y0GF?= =?iso-8859-1?q?VGBnpw2urRQsggf2rrYqGFEEp8DzxltpCjl1YIQ=3D=3D?= MIME-Version: 1.0 X-OriginatorOrg: epam.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-AuthSource: PA4PR03MB7136.eurprd03.prod.outlook.com X-MS-Exchange-CrossTenant-Network-Message-Id: 4b85c04f-9786-4e42-6e0e-08db4659dde3 X-MS-Exchange-CrossTenant-originalarrivaltime: 26 Apr 2023 13:26:38.3498 (UTC) X-MS-Exchange-CrossTenant-fromentityheader: Hosted X-MS-Exchange-CrossTenant-id: b41b72d0-4e9f-4c26-8a69-f949f367c91d X-MS-Exchange-CrossTenant-mailboxtype: HOSTED X-MS-Exchange-CrossTenant-userprincipalname: nBrjQMVOGk5rVqTcnCFBILkaPLNL7sN0K8ZCA51mBhrl89IEsuSBqCidrCrESLaUKlUQUfPN4vEQk1Fr1d9x6J7P72GBrWcgA16By34N7YM= X-MS-Exchange-Transport-CrossTenantHeadersStamped: GV2PR03MB9380 X-Proofpoint-ORIG-GUID: 2SX5shMOSi0Uup788ZcpSqux5_CEH-j3 X-Proofpoint-GUID: 2SX5shMOSi0Uup788ZcpSqux5_CEH-j3 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.254,Aquarius:18.0.942,Hydra:6.0.573,FMLib:17.11.170.22 definitions=2023-04-26_05,2023-04-26_03,2023-02-09_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 lowpriorityscore=0 clxscore=1015 malwarescore=0 suspectscore=0 adultscore=0 mlxlogscore=999 spamscore=0 bulkscore=0 priorityscore=1501 mlxscore=0 impostorscore=0 phishscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2303200000 definitions=main-2304260119 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20230426_062652_744940_6B82DDC0 X-CRM114-Status: GOOD ( 12.88 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org Add new SCMI v3.2 pinctrl protocol bindings definitions and example. Signed-off-by: Oleksii Moisieiev --- .../bindings/firmware/arm,scmi.yaml | 77 +++++++++++++++++++ 1 file changed, 77 insertions(+) diff --git a/Documentation/devicetree/bindings/firmware/arm,scmi.yaml b/Documentation/devicetree/bindings/firmware/arm,scmi.yaml index 2f7c51c75e85..41ba5b8d8151 100644 --- a/Documentation/devicetree/bindings/firmware/arm,scmi.yaml +++ b/Documentation/devicetree/bindings/firmware/arm,scmi.yaml @@ -212,6 +212,63 @@ properties: reg: const: 0x18 + protocol@19: + $ref: '#/$defs/protocol-node' + + properties: + reg: + const: 0x19 + + '#pinctrl-cells': + const: 0 + + allOf: + - $ref: "/schemas/pinctrl/pinctrl.yaml#" + + required: + - reg + + additionalProperties: + anyOf: + - type: object + allOf: + - $ref: /schemas/pinctrl/pincfg-node.yaml# + - $ref: /schemas/pinctrl/pinmux-node.yaml# + + 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. + + properties: + phandle: true + function: true + groups: true + pins: true + bias-bus-hold: true + bias-disable: true + bias-high-impedance: true + bias-pull-up: true + bias-pull-default: true + bias-pull-down: true + drive-open-drain: true + drive-open-source: true + drive-push-pull: true + drive-strength: true + input-debounce: true + input-value: true + input-schmitt: true + low-power-mode: true + output-mode: true + output-value: true + power-source: true + skew-rate: true + + additionalProperties: true + additionalProperties: false $defs: @@ -356,6 +413,26 @@ examples: scmi_powercap: protocol@18 { reg = <0x18>; }; + + scmi_pinctrl: protocol@19 { + reg = <0x19>; + #pinctrl-cells = <0>; + + i2c2 { + groups = "i2c2_a", "i2c2_b"; + function = "i2c2"; + }; + + pins_mdio { + groups = "avb_mdio"; + drive-strength = <24>; + }; + + keys_pins: keys { + pins = "GP_5_17", "GP_5_20", "GP_5_22", "GP_2_1"; + bias-pull-up; + }; + }; }; };