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: 87875 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:b0ea:0:b0:3b6:4342:cba0 with SMTP id b10csp274941vqo; Wed, 26 Apr 2023 07:13:53 -0700 (PDT) X-Google-Smtp-Source: ACHHUZ5QJBgRYGS3qqEKrR3gD/7EW2iDBQfxkZN0oYPb+5yTLYY2aJMY15g6W7nOB4CEtATjF+CV X-Received: by 2002:a17:902:d2c2:b0:1a9:a408:a502 with SMTP id n2-20020a170902d2c200b001a9a408a502mr2004994plc.1.1682518432741; Wed, 26 Apr 2023 07:13:52 -0700 (PDT) ARC-Seal: i=2; a=rsa-sha256; t=1682518432; cv=pass; d=google.com; s=arc-20160816; b=J8KrLv1Vgih6aYV/TAN2Etyzn4Sam7xV02gtCNrw27J3Sdi2yTlPYMYSNlYr/RKPuz z+bwLND1Ip2bc8J5gAr2+SbMnMOtlvkN7PWXHpG6MQxEmvTG3kOv74W0CC2IRcODsQ63 OHNDyJ00ZDgWDybmougKzFnjo5mimJYeq/HEyVHyu+TFhvFabjuLH4PoD0ML4EGbYsbi qIZgj/jKBVvI3P2yd9Tso1/MZCANp5D6zTeh+ahqAmWysXw62kLVHNcWwWWPSgo3iwCp 0gU6pridJXF0H13JSqa7SwI6al8s/v4jCBrLUQiuQWgtf1FjBvLjEgJFbm8ZWp+lRBfv zjJQ== ARC-Message-Signature: i=2; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:mime-version:content-transfer-encoding :content-language:accept-language:in-reply-to:references:message-id :date:thread-index:thread-topic:subject:cc:to:from:dkim-signature; bh=0hnEd7OmhgbGKOGW2Yvc9Ggk0ZUsMiZTdI8WLVe2kMU=; b=ZEcyUamIf1EoYM3uN1bFY6LFnvZilvyXX0PHX2Vg6iXt/++Tug0Gu2f1hGrJOEmuCl tQdVqNQFiwSjDNESAEcUSqCIEcpbbWdAg/uFP0zuRhccik3LM2TaY81yfYDOnvu4x415 42sQf+V8izHa49zin6Gn1CtorcjWnNzv7wefoX6dpAbGsrm6H1X5C74GyukX9hjn0YyG BoNHdaMznx4w62m0oRiG3FFQ60SctjC6zgbNBSHLZjK16MQKSHCLe2S9brbEdTNjhEdH ri+zO6XhXLQ6Q+VGCW3sFnwqx+WdmQIQC6oUI8foUzc3Mwj1jFxmBa3r+AvpeOKhEX1g oqmA== ARC-Authentication-Results: i=2; mx.google.com; dkim=pass header.i=@epam.com header.s=selector2 header.b=R3X85GE2; arc=pass (i=1 spf=pass spfdomain=epam.com dkim=pass dkdomain=epam.com dmarc=pass fromdomain=epam.com); spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=QUARANTINE sp=QUARANTINE dis=NONE) header.from=epam.com Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id l192-20020a6391c9000000b0051344de1eb8si16470328pge.276.2023.04.26.07.13.37; Wed, 26 Apr 2023 07:13:52 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@epam.com header.s=selector2 header.b=R3X85GE2; arc=pass (i=1 spf=pass spfdomain=epam.com dkim=pass dkdomain=epam.com dmarc=pass fromdomain=epam.com); spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=QUARANTINE sp=QUARANTINE dis=NONE) header.from=epam.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S240482AbjDZN1M (ORCPT + 99 others); Wed, 26 Apr 2023 09:27:12 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:56958 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241170AbjDZN1F (ORCPT ); Wed, 26 Apr 2023 09:27:05 -0400 Received: from mx0b-0039f301.pphosted.com (mx0b-0039f301.pphosted.com [148.163.137.242]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 8A6EC26AC; Wed, 26 Apr 2023 06:27:00 -0700 (PDT) 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-Spam-Status: No, score=-2.8 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,RCVD_IN_DNSWL_LOW,SPF_HELO_NONE, SPF_NONE,T_SCC_BODY_TEXT_LINE,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1764248448047881554?= X-GMAIL-MSGID: =?utf-8?q?1764248448047881554?= 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 {