From patchwork Thu Oct 5 14:44:54 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 148801 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:612c:2016:b0:403:3b70:6f57 with SMTP id fe22csp371890vqb; Thu, 5 Oct 2023 08:19:55 -0700 (PDT) X-Google-Smtp-Source: AGHT+IG/h/tzHvnIa0heYAL8uxyNKoLFE8rTn8RbHh1yQgpkth744qK32AuevulCK0BkFN1cBZsF X-Received: by 2002:a05:6a00:ccd:b0:68b:e29c:b61 with SMTP id b13-20020a056a000ccd00b0068be29c0b61mr6586710pfv.19.1696519195615; Thu, 05 Oct 2023 08:19:55 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696519195; cv=none; d=google.com; s=arc-20160816; b=MghxgHub+wT9vayG6ROHcjm6WIEXpu6cvuRMQlSekDqmtfdzE+30GX+26vT/TQLQLV mFhCvRqZQgJGspj4IUyFzZITL7rujNx98wgizMpC0DaGwAY15AHpzOWtqoWOZdz/GoHB dDM8WGhDCo/x+QWjAlBwM0FXtChko1+8uVsCnxT+UFi2QYzaxITf/7PvVo3cG9zhv+4A vXfgjrsU7nFDE38HnxEHT7fmhwQLUocQXgxTldoRCtroBPxjsM1XVuvGKzKms2q5bfzp DmIN6K2NAcR7Z0C0T5qJMHem6RoQf5J3JccJIqfkSYy2Rj4r4YM1rwBKRn4uHLceQrDo hcuQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:to:in-reply-to:references:message-id :content-transfer-encoding:mime-version:subject:date:from; bh=BdXa1jBsVldzSXDZAC8SnOpYZl/ld2hnSo5wvgUIGb0=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=uO+QiP8cbZ7wDxRk7cJpLbeIChVtvwTmg85gM28gjyqKILsT3yxv8Xyu0hA7JqT6TF YkmTMt2wSoWVDDhrtviYgWAx1UZ4g4TjH7srm69QZ1vXEfXTUyB+gkzLsnn98zQUEgCl IgIHrmd1UsgsfkrWsjeR0QgdZCyP+Uj5Uw3VtvMx1weAzphUYFOmAkPq7UDoVpKhLjV5 gD686vw9ujv8zaDnWoV0smWw8j4oiqfvsyZIgZv7V8TFSirlJiDHwxbMOZdUAQ503hT3 zSoOxxOl5Bk1Li4n6gu6FpxjrQmFK7+WsSkH4hqX41IWdUCMrLTBez5NRLOshyGKYC3F 0f3g== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.34 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from howler.vger.email (howler.vger.email. [23.128.96.34]) by mx.google.com with ESMTPS id g25-20020a633759000000b005698cf29f75si1645408pgn.222.2023.10.05.08.19.55 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 05 Oct 2023 08:19:55 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.34 as permitted sender) client-ip=23.128.96.34; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.34 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from out1.vger.email (depot.vger.email [IPv6:2620:137:e000::3:0]) by howler.vger.email (Postfix) with ESMTP id D91ED8706565; Thu, 5 Oct 2023 08:19:54 -0700 (PDT) X-Virus-Status: Clean X-Virus-Scanned: clamav-milter 0.103.10 at howler.vger.email Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229764AbjJEPTq (ORCPT + 19 others); Thu, 5 Oct 2023 11:19:46 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58156 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232999AbjJEPTD (ORCPT ); Thu, 5 Oct 2023 11:19:03 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id 9C32A3850 for ; Thu, 5 Oct 2023 07:45:10 -0700 (PDT) Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id B3951DA7; Thu, 5 Oct 2023 07:45:48 -0700 (PDT) Received: from e103737-lin.cambridge.arm.com (e103737-lin.cambridge.arm.com [10.1.197.49]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 099FA3F641; Thu, 5 Oct 2023 07:45:08 -0700 (PDT) From: Sudeep Holla Date: Thu, 05 Oct 2023 15:44:54 +0100 Subject: [PATCH v4 01/17] firmware: arm_ffa: Update the FF-A command list with v1.1 additions MIME-Version: 1.0 Message-Id: <20231005-ffa_v1-1_notif-v4-1-cddd3237809c@arm.com> References: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> In-Reply-To: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> To: linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Sudeep Holla , Marc Bonnici , Jens Wiklander , Coboy Chen , Lorenzo Pieralisi , Olivier Deprez X-Mailer: b4 0.12.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=3114; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=278KahauozE45XUUmHl11QnvUebKx7Dm6zTUaEvv3Cs=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlHsvwExh2e02foBJMzeMrAazRi+haUyLVwCFry sj7SSL7VMWJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZR7L8AAKCRAAQbq8MX7i mMeED/4pLumUe+LTTAquMVWC2OYtNXXQuLnLgaiSrgDLjpPeCYpasHYXpdF6zFoqoExrlcgrGFp gkByGXQSVkqoDUz4nilUhFkxHbVuLqyZ1z604MEe5xJkUDd1OXodi/gP53BfHKU81GzddyzHey0 JaICJRZqPdChQV2sOXbwraD9LffsenQCB6tbu2GvZ6b+b/QENbErv+gIw8dOj0X9yitqJOmTPge 3JVsxo8alTbZl6Z9Mn8JOQxt1JsLw4BsNCnShWXR+tBKX2wIpIEUXyx1ItzApPqbMiqFc8GZZEn ZLcY7qwpDU6FvfrSf41pTpc/Ql+iSosMdup7Z5Qe1FUVMgpWtR7F9dFQ/+XmOYaQibkyygUhJOa cXl5DCthQ6kGxbrtABxpDNfC/B7uE71gLxpQjwAr4bkOxPcVvYg8S5ndxlBvWBrbiqCNQ1nEMSG trn/8ofng02cTJqQyrlLS0vYF0Mwl3HfaivO7n0S/BgGQR1KeKNR38IaDKS/G22sYGUyE0bBLwT Yj515gl2lFlLYCEebRc9VcUhQuI+FSgfXDAG0CwPY/2kglmaHfAO2HeZS+gFz9OFhRrE/R451Hm oym3CG+WkD0iSxY87/WZq3VWdUogn2+F0W2WOfMfHQyXV+I/R4pLrOaret/D2Zh+1sevtSxVQMA hJPBFpxiyt0IUbQ== X-Developer-Key: i=sudeep.holla@arm.com; a=openpgp; fpr=7360A21742ADF5A11767C1C139CFD4755FE2D5B4 X-Spam-Status: No, score=-4.2 required=5.0 tests=BAYES_00,RCVD_IN_DNSWL_MED, SPF_HELO_NONE,SPF_NONE 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-Greylist: Sender passed SPF test, not delayed by milter-greylist-4.6.4 (howler.vger.email [0.0.0.0]); Thu, 05 Oct 2023 08:19:54 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778929311858783203 X-GMAIL-MSGID: 1778929311858783203 Arm Firmware Framework for A-profile(FFA) v1.1 introduces notifications and indirect messaging based upon notifications support and extends some of the memory interfaces. Let us add all the newly supported FF-A function IDs in the spec. Also update to the error values and associated handling. Signed-off-by: Sudeep Holla --- drivers/firmware/arm_ffa/driver.c | 1 + include/linux/arm_ffa.h | 20 ++++++++++++++++++++ 2 files changed, 21 insertions(+) diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c index 7cd6b1564e80..a64512388ea5 100644 --- a/drivers/firmware/arm_ffa/driver.c +++ b/drivers/firmware/arm_ffa/driver.c @@ -64,6 +64,7 @@ static const int ffa_linux_errmap[] = { -EACCES, /* FFA_RET_DENIED */ -EAGAIN, /* FFA_RET_RETRY */ -ECANCELED, /* FFA_RET_ABORTED */ + -ENODATA, /* FFA_RET_NO_DATA */ }; static inline int ffa_to_linux_errno(int errno) diff --git a/include/linux/arm_ffa.h b/include/linux/arm_ffa.h index cc060da51bec..2ea1717a0825 100644 --- a/include/linux/arm_ffa.h +++ b/include/linux/arm_ffa.h @@ -20,6 +20,7 @@ #define FFA_ERROR FFA_SMC_32(0x60) #define FFA_SUCCESS FFA_SMC_32(0x61) +#define FFA_FN64_SUCCESS FFA_SMC_64(0x61) #define FFA_INTERRUPT FFA_SMC_32(0x62) #define FFA_VERSION FFA_SMC_32(0x63) #define FFA_FEATURES FFA_SMC_32(0x64) @@ -54,6 +55,23 @@ #define FFA_MEM_FRAG_RX FFA_SMC_32(0x7A) #define FFA_MEM_FRAG_TX FFA_SMC_32(0x7B) #define FFA_NORMAL_WORLD_RESUME FFA_SMC_32(0x7C) +#define FFA_NOTIFICATION_BITMAP_CREATE FFA_SMC_32(0x7D) +#define FFA_NOTIFICATION_BITMAP_DESTROY FFA_SMC_32(0x7E) +#define FFA_NOTIFICATION_BIND FFA_SMC_32(0x7F) +#define FFA_NOTIFICATION_UNBIND FFA_SMC_32(0x80) +#define FFA_NOTIFICATION_SET FFA_SMC_32(0x81) +#define FFA_NOTIFICATION_GET FFA_SMC_32(0x82) +#define FFA_NOTIFICATION_INFO_GET FFA_SMC_32(0x83) +#define FFA_FN64_NOTIFICATION_INFO_GET FFA_SMC_64(0x83) +#define FFA_RX_ACQUIRE FFA_SMC_32(0x84) +#define FFA_SPM_ID_GET FFA_SMC_32(0x85) +#define FFA_MSG_SEND2 FFA_SMC_32(0x86) +#define FFA_SECONDARY_EP_REGISTER FFA_SMC_32(0x87) +#define FFA_FN64_SECONDARY_EP_REGISTER FFA_SMC_64(0x87) +#define FFA_MEM_PERM_GET FFA_SMC_32(0x88) +#define FFA_FN64_MEM_PERM_GET FFA_SMC_64(0x88) +#define FFA_MEM_PERM_SET FFA_SMC_32(0x89) +#define FFA_FN64_MEM_PERM_SET FFA_SMC_64(0x89) /* * For some calls it is necessary to use SMC64 to pass or return 64-bit values. @@ -76,6 +94,7 @@ #define FFA_RET_DENIED (-6) #define FFA_RET_RETRY (-7) #define FFA_RET_ABORTED (-8) +#define FFA_RET_NO_DATA (-9) /* FFA version encoding */ #define FFA_MAJOR_VERSION_MASK GENMASK(30, 16) @@ -86,6 +105,7 @@ (FIELD_PREP(FFA_MAJOR_VERSION_MASK, (major)) | \ FIELD_PREP(FFA_MINOR_VERSION_MASK, (minor))) #define FFA_VERSION_1_0 FFA_PACK_VERSION_INFO(1, 0) +#define FFA_VERSION_1_1 FFA_PACK_VERSION_INFO(1, 1) /** * FF-A specification mentions explicitly about '4K pages'. This should From patchwork Thu Oct 5 14:44:55 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 148803 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:612c:2016:b0:403:3b70:6f57 with SMTP id fe22csp372178vqb; Thu, 5 Oct 2023 08:20:23 -0700 (PDT) X-Google-Smtp-Source: AGHT+IFINobSbXtl48x9WSMd5Dh9+1KJnqAbXOCEAg8kTfgJDWxDFZOGdzgJVu2w1LL8lbT6cfAM X-Received: by 2002:a05:6a00:39a0:b0:68f:c4a2:fb1f with SMTP id fi32-20020a056a0039a000b0068fc4a2fb1fmr2497787pfb.8.1696519222848; Thu, 05 Oct 2023 08:20:22 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696519222; cv=none; d=google.com; s=arc-20160816; b=BYjEBTdcEez+WaZjb5l/N24X8HVqXfdt9SRrStXCQrrdPnsAUABQkz49jTmyZQqeg/ /rv7j+RYyOFN9VUs+ePi6BosiyebV7k5biqUgyuFQkF6+qDarCBBmikbRApB4OOxJk1h SMLXjnnxAz0UlXBDHF9MnM0Lc4DI2s+iHB6I7On6XbilFWr3XaysAVbqPHcd0TeP20mC PCkZ4iSSI/lneH2Hk1mfEZEaqiHnwEcZ47FLvijMvpTjLXGTRaqzgFJMnfCEffvIJJ1l KtXgBLOaSaSW1u96vZ4K4NZtNCPug0IkwI4seid288EYAj7QXkQSMNwsk3qiA+x1/FBi jqpQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:to:in-reply-to:references:message-id :content-transfer-encoding:mime-version:subject:date:from; bh=ZXMDhhhnMtt2PKtHwz8rEjJN6QCRX7oMuDCuJgD50I8=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=gWFULoyFUPkD1ZgTaSerqMb8B9RF+EIbkOD1cicCSfDpDEZuizF1eDF1LovxAtbE+B +S3yu8n2lP38ileeY+yHh/+zw5PnwBYSi7fyFq7OGnuS78YpnQ+pd+8E/DnvJM1UzaqM jQAKaT9+btX9TYmsn5m5Jl3DzAPZKfBGJwMANWVq2FYzsT79EH6hW2+E3vC7o0wFP3ap ilWw41hvxggKLrzn/74++mxGhi11l6Fw8Ph5MkeQKjyua1t0CknFhyIa3BlkzqKi4BqR ZTwaAgxC+jMSzPZ+ni2RYGY3jLeO3B90m3Ar2wgyhp59pSKDnqv+MUMGgYcDPmCffUtR xsoQ== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.34 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from howler.vger.email (howler.vger.email. [23.128.96.34]) by mx.google.com with ESMTPS id n18-20020a056a000d5200b006933caa6f03si1485673pfv.165.2023.10.05.08.20.22 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 05 Oct 2023 08:20:22 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.34 as permitted sender) client-ip=23.128.96.34; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.34 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from out1.vger.email (depot.vger.email [IPv6:2620:137:e000::3:0]) by howler.vger.email (Postfix) with ESMTP id 0A22A871829B; Thu, 5 Oct 2023 08:20:22 -0700 (PDT) X-Virus-Status: Clean X-Virus-Scanned: clamav-milter 0.103.10 at howler.vger.email Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232198AbjJEPUR (ORCPT + 19 others); Thu, 5 Oct 2023 11:20:17 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58894 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233191AbjJEPTJ (ORCPT ); Thu, 5 Oct 2023 11:19:09 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id AFD773866 for ; Thu, 5 Oct 2023 07:45:11 -0700 (PDT) Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id E58FD139F; Thu, 5 Oct 2023 07:45:49 -0700 (PDT) Received: from e103737-lin.cambridge.arm.com (e103737-lin.cambridge.arm.com [10.1.197.49]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 3B6EE3F641; Thu, 5 Oct 2023 07:45:10 -0700 (PDT) From: Sudeep Holla Date: Thu, 05 Oct 2023 15:44:55 +0100 Subject: [PATCH v4 02/17] firmware: arm_ffa: Implement notification bitmap create and destroy interfaces MIME-Version: 1.0 Message-Id: <20231005-ffa_v1-1_notif-v4-2-cddd3237809c@arm.com> References: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> In-Reply-To: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> To: linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Sudeep Holla , Marc Bonnici , Jens Wiklander , Coboy Chen , Lorenzo Pieralisi , Olivier Deprez X-Mailer: b4 0.12.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=3477; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=uUL2ZAphmbDP68h5pYnBIMj7pjeetUE+/DHcD8KcBDo=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlHsvwJYa5tKnQfZaTKhzLY4WPPK31PNv/mf0ul VCCjuqGifWJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZR7L8AAKCRAAQbq8MX7i mIqlD/9ZEzkQ5vVuCRL2ahSlui8c006jtP9sHnonqbqj/uQI25nWgyFlpfjkONGVjuCMTyUxRWu xPfCEn94+9Nx50JUjhdjNc9lCj3k8PvmC0kPUGwP96/dA4nNBdeYQmENzZNAnTMdDmj42UsCr7D /uBP0aJtAoA1lT2tLSqmsRx0ACpfaysMnTu/D+G4ZHuqNhzPXHiW+bE3EJm2lWc+yLY7UttbGGI vEUFMRS6Iz3/H5CJeDNSmvB94k6cnvNXEWdQeuL+cVAiiQLnls8iQ2ZLgqVVxjJlwHZ9C1Ol83D /voSUdLmKmDyfFcqxQR/VsZGakRzJKhgHgsqNYETj3VcVLBGvbKimPHA/QXXGejKWaRKtdb1M2d 64QcsZkswWyn0Vfz/Ku/ImS0Bt6teVWNbP6Yt7Edi+whd9/b3AmfUSY6WD3N55nrfD4W6FJwP0b EunSKSrbY9qbWhzejMYfZS+vRZnVxLu7/Su1ZJEtVEjPLH+Fcpg2G7ffClOyyRswQtBvL14hXzJ R2ca4WEMv1PAzoWFn6gik8c77a9suhCesDI9ubXm4+Y4/uU6mGDTMxalUn0DcDeN/qmha7Dmt5j uXreRXJ/pFpNCmG5vwW6+Fn2aGF5i6McW5N6lLQjbzFqbHvq/nKgVAZy+rJdR+cBAMEiZnfN7YO m82V4mWUYhJq3mQ== X-Developer-Key: i=sudeep.holla@arm.com; a=openpgp; fpr=7360A21742ADF5A11767C1C139CFD4755FE2D5B4 X-Spam-Status: No, score=-4.2 required=5.0 tests=BAYES_00,RCVD_IN_DNSWL_MED, SPF_HELO_NONE,SPF_NONE 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-Greylist: Sender passed SPF test, not delayed by milter-greylist-4.6.4 (howler.vger.email [0.0.0.0]); Thu, 05 Oct 2023 08:20:22 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778929340963261011 X-GMAIL-MSGID: 1778929340963261011 On systems without a hypervisor the responsibility of requesting the creation of the notification bitmaps in the SPM falls to the FF-A driver. We use FFA features to determine if the ABI is supported, if it is not we can assume there is a hypervisor present and will take care of ensure the relevant notifications bitmaps are created on this partitions behalf. An endpoint’s notification bitmaps needs to be setup before it configures its notifications and before other endpoints and partition managers can start signaling these notifications. Add interface to create and destroy the notification bitmaps and use the same to do the necessary setup during the initialisation and cleanup during the module exit. Signed-off-by: Sudeep Holla --- drivers/firmware/arm_ffa/driver.c | 63 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 62 insertions(+), 1 deletion(-) diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c index a64512388ea5..c2ab6f4cf296 100644 --- a/drivers/firmware/arm_ffa/driver.c +++ b/drivers/firmware/arm_ffa/driver.c @@ -84,6 +84,7 @@ struct ffa_drv_info { void *rx_buffer; void *tx_buffer; bool mem_ops_native; + bool bitmap_created; }; static struct ffa_drv_info *drv_info; @@ -555,6 +556,37 @@ static int ffa_features(u32 func_feat_id, u32 input_props, return 0; } +static int ffa_notification_bitmap_create(void) +{ + ffa_value_t ret; + u16 vcpu_count = nr_cpu_ids; + + invoke_ffa_fn((ffa_value_t){ + .a0 = FFA_NOTIFICATION_BITMAP_CREATE, + .a1 = drv_info->vm_id, .a2 = vcpu_count, + }, &ret); + + if (ret.a0 == FFA_ERROR) + return ffa_to_linux_errno((int)ret.a2); + + return 0; +} + +static int ffa_notification_bitmap_destroy(void) +{ + ffa_value_t ret; + + invoke_ffa_fn((ffa_value_t){ + .a0 = FFA_NOTIFICATION_BITMAP_DESTROY, + .a1 = drv_info->vm_id, + }, &ret); + + if (ret.a0 == FFA_ERROR) + return ffa_to_linux_errno((int)ret.a2); + + return 0; +} + static void ffa_set_up_mem_ops_native_flag(void) { if (!ffa_features(FFA_FN_NATIVE(MEM_LEND), 0, NULL, NULL) || @@ -704,6 +736,34 @@ static void ffa_setup_partitions(void) kfree(pbuf); } +static int ffa_notifications_setup(void) +{ + int ret; + + ret = ffa_features(FFA_NOTIFICATION_BITMAP_CREATE, 0, NULL, NULL); + if (ret) { + pr_err("Notifications not supported, continuing with it ..\n"); + return 0; + } + + ret = ffa_notification_bitmap_create(); + if (ret) { + pr_err("notification_bitmap_create error %d\n", ret); + return ret; + } + drv_info->bitmap_created = true; + + return 0; +} + +static void ffa_notifications_cleanup(void) +{ + if (drv_info->bitmap_created) { + ffa_notification_bitmap_destroy(); + drv_info->bitmap_created = false; + } +} + static int __init ffa_init(void) { int ret; @@ -759,7 +819,7 @@ static int __init ffa_init(void) ffa_set_up_mem_ops_native_flag(); - return 0; + return ffa_notifications_setup(); free_pages: if (drv_info->tx_buffer) free_pages_exact(drv_info->tx_buffer, RXTX_BUFFER_SIZE); @@ -774,6 +834,7 @@ subsys_initcall(ffa_init); static void __exit ffa_exit(void) { + ffa_notifications_cleanup(); ffa_rxtx_unmap(drv_info->vm_id); free_pages_exact(drv_info->tx_buffer, RXTX_BUFFER_SIZE); free_pages_exact(drv_info->rx_buffer, RXTX_BUFFER_SIZE); From patchwork Thu Oct 5 14:44:56 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 148851 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:612c:2016:b0:403:3b70:6f57 with SMTP id fe22csp403801vqb; Thu, 5 Oct 2023 09:07:22 -0700 (PDT) X-Google-Smtp-Source: AGHT+IH5Ts9/Ca1kEDBiru7pcpvle4dfGO7ed6BXEW8AsvP4VUxeCD0us9DmfZ6JVwllnjITFhjr X-Received: by 2002:a05:6e02:20ee:b0:349:2d48:66ac with SMTP id q14-20020a056e0220ee00b003492d4866acmr6888471ilv.12.1696522042783; Thu, 05 Oct 2023 09:07:22 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696522042; cv=none; d=google.com; s=arc-20160816; b=ZXjSYoRHeVq5c+4Y8lIoPpfO0t+9YJ/PlMS4hnDW7F0c5GNfzEKO+FNIvmolXm3lxU 4ZU3Hx9AZRZFfbV2yvom9PCACU4K+VTgJRGfrbr4bsNCD0+BZAIguRO/+LsTqIpPjOlQ NGNxSdhDt6Z7UonR0UauOBFHBe5CE1UWjmvOPxTFky7OJ7be0bNLRoKvJ21fq5AK7jmN m79c0UVcx+dHaCaKemNOoN4utn1S4ZD+PYAiBFAon/zj7is17WNJUWJNIisJdPaZ6Xo/ EzPvpWWLqVFfYs+bs67N1rSczXiCY73egPbF315Wk+FGmPz7UWEfXQnoOASlpnZrjFFG mAKg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:to:in-reply-to:references:message-id :content-transfer-encoding:mime-version:subject:date:from; bh=Tv3FntbeVPyVE6jWt1kTAHu1ZEVQQ35hz7TED+X2gNM=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=Uabj9jgTrHXvuE1SUI5O5P2KfjPNRAQWyHmjMjslLkJ3X7n4IO24hXLxJPC4t83crF Uwic1MvkHBQ+qUFz2kIbPSsJHRWD4Bs+08xthyInHhh3FKm8wqiueorQUnlQlP+hS90y Zv5sjdTxHB5lsBSRj70rydxz9vGBnJ6MdTyl1wH0FqrpGF1Bcj5rS16vKi995cGQoT0Y ji6mNDnMoCL1/3zsqiyErPiDAplhAR3omp8/xvpdTgVM6QYIjPBDkC048qKENbpSkzHU bmTdtZgJxQDV1+xsz1SisBgH/XhrbFcoFYQtSL0e1ityHN7ip9xyLfRtpm3Dvtd8wdE+ Zliw== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:6 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from pete.vger.email (pete.vger.email. [2620:137:e000::3:6]) by mx.google.com with ESMTPS id b11-20020a63d80b000000b00578b63123desi1739361pgh.789.2023.10.05.09.07.22 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 05 Oct 2023 09:07:22 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:6 as permitted sender) client-ip=2620:137:e000::3:6; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:6 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from out1.vger.email (depot.vger.email [IPv6:2620:137:e000::3:0]) by pete.vger.email (Postfix) with ESMTP id 633C481C57FF; Thu, 5 Oct 2023 09:06:45 -0700 (PDT) X-Virus-Status: Clean X-Virus-Scanned: clamav-milter 0.103.10 at pete.vger.email Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237326AbjJEQFD (ORCPT + 19 others); Thu, 5 Oct 2023 12:05:03 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34536 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234733AbjJEQDY (ORCPT ); Thu, 5 Oct 2023 12:03:24 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id D11C03869 for ; Thu, 5 Oct 2023 07:45:12 -0700 (PDT) Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 23273150C; Thu, 5 Oct 2023 07:45:51 -0700 (PDT) Received: from e103737-lin.cambridge.arm.com (e103737-lin.cambridge.arm.com [10.1.197.49]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 6D3DD3F641; Thu, 5 Oct 2023 07:45:11 -0700 (PDT) From: Sudeep Holla Date: Thu, 05 Oct 2023 15:44:56 +0100 Subject: [PATCH v4 03/17] firmware: arm_ffa: Implement the notification bind and unbind interface MIME-Version: 1.0 Message-Id: <20231005-ffa_v1-1_notif-v4-3-cddd3237809c@arm.com> References: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> In-Reply-To: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> To: linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Sudeep Holla , Marc Bonnici , Jens Wiklander , Coboy Chen , Lorenzo Pieralisi , Olivier Deprez X-Mailer: b4 0.12.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=2207; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=tCh7LbKeNAevFd5uQSx03qEkiVl/aQEeXvD/r/UF4UU=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlHsvwFDa1dLaZiLdaBoo+tK3/uFpNRlVXwQfJU v79YnQB7lKJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZR7L8AAKCRAAQbq8MX7i mLWQD/wLXEyJRAXmNV7481V9rRrEOHvJ36UfKSIWMkvKASOA5tN91M1Orlf6679gmfJJDBvv8SP X8CpzgeqIgLndGOcvlgUc6sKgXdT2QHLzGMqSlp1zh6NNBzuH0CCY9YjZ+CGIHBB+vWPPL47OQR VcuIKfuU9VXpea+xynjlRpwkoqgjz/YGTSL19m3GOfUW6GSzopPt0aAVibxZK7PQBGRnqYbKMcO NkgOexysE6f9G4lhGDOJfhErVsR4D3jNpMh5UZfLxCi1Jd7Ehjxo8qT2SmQQ9Kf79rwsRbGakpv j/sU7v5lEMsDfKRyJPc9QT+mGcVv4FpPNySXQDWLWk35gS7Vk1hZxkkocYP1z/6HYsJMkhCSsyJ 4mGhqnGr9KiRwMhuUNBBi4vJjI4tXqCP+QahymeH4WfnlAt4P70SMXy4TTadgIPeoloJYQQa298 TG0iIjeHhIsvuVombabM1TmrG5EGsfhwomwXxhzl6KAojYWradn5YXCbOWOfoTJXeueuxfvASH6 p/YqWegmTZ7RtKxys24QRT1RvxOnCj5phnY8nqFHrkicnZL8uiHewpV4UN6yNvPdSdEwEIP96mC jXGiYEKjH2d9OYaTf779pGMbGf6ha1eNRMyOeoa/Vq6iilHIcNcBSoqvxabFOqVMo9FFGz2/BYJ eN6H/Li3w/s+KLw== X-Developer-Key: i=sudeep.holla@arm.com; a=openpgp; fpr=7360A21742ADF5A11767C1C139CFD4755FE2D5B4 X-Spam-Status: No, score=-0.8 required=5.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS autolearn=unavailable autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on pete.vger.email Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-Greylist: Sender passed SPF test, not delayed by milter-greylist-4.6.4 (pete.vger.email [0.0.0.0]); Thu, 05 Oct 2023 09:06:45 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778932297570937302 X-GMAIL-MSGID: 1778932297570937302 A receiver endpoint must bind a notification to any sender endpoint before the latter can signal the notification to the former. The receiver assigns one or more doorbells to a specific sender. Only the sender can ring these doorbells. A receiver uses the FFA_NOTIFICATION_BIND interface to bind one or more notifications to the sender. A receiver un-binds a notification from a sender endpoint to stop the notification from being signaled. It uses the FFA_NOTIFICATION_UNBIND interface to do this. Allow the FF-A driver to be able to bind and unbind a given notification ID to a specific partition ID. This will be used to register and unregister notification callbacks from the FF-A client drivers. Signed-off-by: Sudeep Holla --- drivers/firmware/arm_ffa/driver.c | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c index c2ab6f4cf296..20f8f4ca8e89 100644 --- a/drivers/firmware/arm_ffa/driver.c +++ b/drivers/firmware/arm_ffa/driver.c @@ -587,6 +587,35 @@ static int ffa_notification_bitmap_destroy(void) return 0; } +#define NOTIFICATION_LOW_MASK GENMASK(31, 0) +#define NOTIFICATION_HIGH_MASK GENMASK(63, 32) +#define NOTIFICATION_BITMAP_HIGH(x) \ + ((u32)(FIELD_GET(NOTIFICATION_HIGH_MASK, (x)))) +#define NOTIFICATION_BITMAP_LOW(x) \ + ((u32)(FIELD_GET(NOTIFICATION_LOW_MASK, (x)))) + +static int ffa_notification_bind_common(u16 dst_id, u64 bitmap, + u32 flags, bool is_bind) +{ + ffa_value_t ret; + u32 func, src_dst_ids = PACK_TARGET_INFO(dst_id, drv_info->vm_id); + + func = is_bind ? FFA_NOTIFICATION_BIND : FFA_NOTIFICATION_UNBIND; + + invoke_ffa_fn((ffa_value_t){ + .a0 = func, .a1 = src_dst_ids, .a2 = flags, + .a3 = NOTIFICATION_BITMAP_LOW(bitmap), + .a4 = NOTIFICATION_BITMAP_HIGH(bitmap), + }, &ret); + + if (ret.a0 == FFA_ERROR) + return ffa_to_linux_errno((int)ret.a2); + else if (ret.a0 != FFA_SUCCESS) + return -EINVAL; + + return 0; +} + static void ffa_set_up_mem_ops_native_flag(void) { if (!ffa_features(FFA_FN_NATIVE(MEM_LEND), 0, NULL, NULL) || From patchwork Thu Oct 5 14:44:57 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 148802 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:612c:2016:b0:403:3b70:6f57 with SMTP id fe22csp372153vqb; Thu, 5 Oct 2023 08:20:20 -0700 (PDT) X-Google-Smtp-Source: AGHT+IGQevmTnxqOBek2shdEgzxj7usuh3h7J7lbjnP+kG0iFlt7d9CLIcibfJRRSOgtknFsKwaR X-Received: by 2002:a05:6358:6f06:b0:13c:eea2:d021 with SMTP id r6-20020a0563586f0600b0013ceea2d021mr5279686rwn.9.1696519220358; Thu, 05 Oct 2023 08:20:20 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696519220; cv=none; d=google.com; s=arc-20160816; b=o9XA2/E341D36rg7omNhqsyw7bTBEXSZjMhdGdpaqgr553g3aT6/deCye/Q0FhU6be tXDmTxnF1DbRS/Zwxln7iln6MeW3UtfMBf+nY0bjtJwrpP3UnjszflB8fX3vtGikvTM4 ug0mVBg5y5/iQchF5fGgi9l+k9grBSvsGjuIavw0Y4S4Rw9aQr1G9vYRj7ihOUwpIZJZ LDs8VVPPBy8wooMBBwkNcMcnUvjvJUOWuTJEbCugPFd+63c+KMpnYT8lNJea3Rao8xc1 pTILmyBmyGuuDpWFqROL1zjpEjhB/pDfe4cgF5KkT5Kb/zW6uhYMA7Gb/KLetTvfi6mv f1xQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:to:in-reply-to:references:message-id :content-transfer-encoding:mime-version:subject:date:from; bh=53hCyt3tU1lh7hvgG5mVhd7/qKFv9dK2z6tKV7lkn8k=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=AvsHZxqKxgBXQ9CVmDxiPRH+1EXFoiToCiZFE+akGT7eszakXFIn76p85aCQTFFJ5x s8/1uyxl/WRxgjoz29odb3/sxfOjrRNKoC0zPn5dCGXJdWkDv/GySzYOIKYXIfLFkMcJ WSyqxcah+TrJv+mieuybpakLbWeAbFqPqFYHgJQLisH3Q618i9DMFi4W29W1wRXuiS5u i9TIUAnRRjPuWHaHF3h6E3rsgVBtzf29grlL27ixOnEsNHfxbnThmFsjq7ZfnuiyM8wn +h9vgeQ3wiDtMHHCWA/VIYcuV9z/+2M1SoL9HPj/+fXothakqwS2HxPTDPPThuysdJS3 BiWg== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.34 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from howler.vger.email (howler.vger.email. [23.128.96.34]) by mx.google.com with ESMTPS id m9-20020a654389000000b00584ac935a98si1530844pgp.828.2023.10.05.08.20.20 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 05 Oct 2023 08:20:20 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.34 as permitted sender) client-ip=23.128.96.34; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.34 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from out1.vger.email (depot.vger.email [IPv6:2620:137:e000::3:0]) by howler.vger.email (Postfix) with ESMTP id 20E3C8718291; Thu, 5 Oct 2023 08:20:19 -0700 (PDT) X-Virus-Status: Clean X-Virus-Scanned: clamav-milter 0.103.10 at howler.vger.email Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231932AbjJEPUP (ORCPT + 19 others); Thu, 5 Oct 2023 11:20:15 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58896 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233193AbjJEPTJ (ORCPT ); Thu, 5 Oct 2023 11:19:09 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id 87C6B386F for ; Thu, 5 Oct 2023 07:45:14 -0700 (PDT) Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 54E351515; Thu, 5 Oct 2023 07:45:52 -0700 (PDT) Received: from e103737-lin.cambridge.arm.com (e103737-lin.cambridge.arm.com [10.1.197.49]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 9EF643F641; Thu, 5 Oct 2023 07:45:12 -0700 (PDT) From: Sudeep Holla Date: Thu, 05 Oct 2023 15:44:57 +0100 Subject: [PATCH v4 04/17] firmware: arm_ffa: Implement the FFA_RUN interface MIME-Version: 1.0 Message-Id: <20231005-ffa_v1-1_notif-v4-4-cddd3237809c@arm.com> References: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> In-Reply-To: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> To: linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Sudeep Holla , Marc Bonnici , Jens Wiklander , Coboy Chen , Lorenzo Pieralisi , Olivier Deprez X-Mailer: b4 0.12.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=2472; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=PdtsxMbWHMsPxE3UREG0cqF5vyZGskCvDY/GrQFa0NE=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlHsvw8PoKVnG2NHbjO9VKHIkzUeI3tmEoRMZG4 CcZ3zhBb9iJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZR7L8AAKCRAAQbq8MX7i mJGAD/9T3ada0rAJvvmdm4qPS7qlrINgtkmqLi3Kf2JYBUErUpdZ9bQfUD1yvZquHAA5O5ATiRu GDBcpn+mkMSOAOjQ5bmbwwSKb37jWU8zyryDMzbqUAF4bt72WWsr2nJqBeYO+gBvgNX6/A21j0V txxuE1Eai5zxYoAntxc3ND/8iEZDkHyL4lrz6KzJP6+Uny/NJngaFfCt+dFVAIot5azBIDqOSsm S5+Ae70YY1Fsh9XmTsSdlBCkgNuZZ2luTyhtDyhnZQpMlAbDh1TksFq3MshGvnWl5g6diNEx3EF BaYASOCTcWO/I2Pck5cMDkd2F+kYCUrc1c5gVa5GkMlRmFW1y9sUMXz08M98VAxyso4ADG23epZ s+5WMm+x4p2KfMXSba5EDeucauhkjWSwOZTtmz8h68H/YiveyVJv3b13GyDAUWOuaOvqyFrOeWy ca5z0JUUTmHEP5v8Jw7E6OFhsie/0uSByFsm99bjEdMAKiTBef41nweztaesSB9xvHpF2eLYjdv rUYKP0EVnUFhT7Tcj+R5PaZ1Gyj6HD+SIGGrDjVsw26gnZDLolIqu0b5lFtc2OjrC8LRd3ndkcc Z/lFQk6x8A+rsiOk0Jgp8mYUu+GE6+bAp/cJgi9H5jMtmmkDVc0UKICHlTxtH5azRoGSmRwyzrd AvR/xApIzrT8qFw== X-Developer-Key: i=sudeep.holla@arm.com; a=openpgp; fpr=7360A21742ADF5A11767C1C139CFD4755FE2D5B4 X-Spam-Status: No, score=-4.2 required=5.0 tests=BAYES_00,RCVD_IN_DNSWL_MED, SPF_HELO_NONE,SPF_NONE 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-Greylist: Sender passed SPF test, not delayed by milter-greylist-4.6.4 (howler.vger.email [0.0.0.0]); Thu, 05 Oct 2023 08:20:19 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778929338117354210 X-GMAIL-MSGID: 1778929338117354210 FFA_RUN is used by a scheduler to allocate CPU cycles to a target endpoint execution context specified in the target information parameter. If the endpoint execution context is in the waiting/blocked state, it transitions to the running state. Expose the ability to call FFA_RUN in order to give any partition in the system cpu cycles to perform IMPDEF functionality. Signed-off-by: Sudeep Holla --- drivers/firmware/arm_ffa/driver.c | 22 ++++++++++++++++++++++ include/linux/arm_ffa.h | 5 +++++ 2 files changed, 27 insertions(+) diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c index 20f8f4ca8e89..82e54d231074 100644 --- a/drivers/firmware/arm_ffa/driver.c +++ b/drivers/firmware/arm_ffa/driver.c @@ -616,6 +616,23 @@ static int ffa_notification_bind_common(u16 dst_id, u64 bitmap, return 0; } +static int ffa_run(struct ffa_device *dev, u16 vcpu) +{ + ffa_value_t ret; + u32 target = dev->vm_id << 16 | vcpu; + + invoke_ffa_fn((ffa_value_t){ .a0 = FFA_RUN, .a1 = target, }, &ret); + + while (ret.a0 == FFA_INTERRUPT) + invoke_ffa_fn((ffa_value_t){ .a0 = FFA_RUN, .a1 = ret.a1, }, + &ret); + + if (ret.a0 == FFA_ERROR) + return ffa_to_linux_errno((int)ret.a2); + + return 0; +} + static void ffa_set_up_mem_ops_native_flag(void) { if (!ffa_features(FFA_FN_NATIVE(MEM_LEND), 0, NULL, NULL) || @@ -700,10 +717,15 @@ static const struct ffa_mem_ops ffa_drv_mem_ops = { .memory_lend = ffa_memory_lend, }; +static const struct ffa_cpu_ops ffa_drv_cpu_ops = { + .run = ffa_run, +}; + static const struct ffa_ops ffa_drv_ops = { .info_ops = &ffa_drv_info_ops, .msg_ops = &ffa_drv_msg_ops, .mem_ops = &ffa_drv_mem_ops, + .cpu_ops = &ffa_drv_cpu_ops, }; void ffa_device_match_uuid(struct ffa_device *ffa_dev, const uuid_t *uuid) diff --git a/include/linux/arm_ffa.h b/include/linux/arm_ffa.h index 2ea1717a0825..12fd134bf670 100644 --- a/include/linux/arm_ffa.h +++ b/include/linux/arm_ffa.h @@ -387,10 +387,15 @@ struct ffa_mem_ops { int (*memory_lend)(struct ffa_mem_ops_args *args); }; +struct ffa_cpu_ops { + int (*run)(struct ffa_device *dev, u16 vcpu); +}; + struct ffa_ops { const struct ffa_info_ops *info_ops; const struct ffa_msg_ops *msg_ops; const struct ffa_mem_ops *mem_ops; + const struct ffa_cpu_ops *cpu_ops; }; #endif /* _LINUX_ARM_FFA_H */ From patchwork Thu Oct 5 14:44:58 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 148849 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:612c:2016:b0:403:3b70:6f57 with SMTP id fe22csp403677vqb; Thu, 5 Oct 2023 09:07:11 -0700 (PDT) X-Google-Smtp-Source: AGHT+IE1zJ0O0cNFe3hOXWNyixnahgaxf9rKMxEkCXZosAMoERcQ2yw9F4IAmSPhEIwpCqR+0iFe X-Received: by 2002:a05:6a20:a11f:b0:163:4288:1c3d with SMTP id q31-20020a056a20a11f00b0016342881c3dmr6319141pzk.43.1696522031348; Thu, 05 Oct 2023 09:07:11 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696522031; cv=none; d=google.com; s=arc-20160816; b=AaumsLSBVCskwyB7WZ5Ss9C10H4dKrl/hsSWkT8AB3vMAXyqPgbNcEhqT9b3xpfGLs sGeDqswMuqP/QmC/9a8wVGLXDaCm3zhciv5qSMp6RkZRSBuvDEwNI60G+fmCn2/WMaGJ IFzkbk8TSlqeuZA9jJA5UyqzPlGLgxXkfE3L5M6SPWRQH9A4ctNnhU4qGWSQOzUpxNvs GovX+gYQ8oIK8tMWsBoD9V2b5UGcdX6actMF+2ReCuwCich4NnTIHmatRmPNzt1fDIrU EpP8uxxjwu7P201cnXpPPO4ioAHsT50PK56fabybI9N+sw3tA4XbdHYF3xhr3e4hVu1L Te3g== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:to:in-reply-to:references:message-id :content-transfer-encoding:mime-version:subject:date:from; bh=4j/VoRIvYR9XbIbBn9oHawbWku6KL37hsXJoeEqoAC0=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=fg0kIVskJuz9Np9o2YSIc7U2lATGt5Xp60P3ink2Dfwmg2HepTNGpX4RqEmjnNi+LY e1YOwJrnUoQqJ6OXJ9RqJMfk3s835xuuEHpWBhCLTYkYfqDR5mAWne8PGhfbRrUfQlf3 d7l7eFUn1DS2rNK+R6PPemrvp2IAngIBN0OS9siIBEYeQlnXcwO5WI6jaE5JAeh64XxU 3sN3M3Z/k2as9H1b1xKg8WMBqK3pz+M5KpsiBoED3EngGtiz83y6ky5wD+Nk3qlfRxeB 8IUHEsZ2lxLJBDP0Iz9i+9X3jpo+7qvnkY0iYSERlTdGT9gGvSx+Pu927arwtWC058tD Bruw== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:5 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from groat.vger.email (groat.vger.email. [2620:137:e000::3:5]) by mx.google.com with ESMTPS id p27-20020a63951b000000b0058974d3c296si1101019pgd.815.2023.10.05.09.07.11 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 05 Oct 2023 09:07:11 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:5 as permitted sender) client-ip=2620:137:e000::3:5; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:5 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from out1.vger.email (depot.vger.email [IPv6:2620:137:e000::3:0]) by groat.vger.email (Postfix) with ESMTP id 71DF8806697C; Thu, 5 Oct 2023 09:06:38 -0700 (PDT) X-Virus-Status: Clean X-Virus-Scanned: clamav-milter 0.103.10 at groat.vger.email Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236515AbjJEQFA (ORCPT + 19 others); Thu, 5 Oct 2023 12:05:00 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34508 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234464AbjJEQDY (ORCPT ); Thu, 5 Oct 2023 12:03:24 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id 44EFA9ED2 for ; Thu, 5 Oct 2023 07:45:38 -0700 (PDT) Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 86B101516; Thu, 5 Oct 2023 07:45:53 -0700 (PDT) Received: from e103737-lin.cambridge.arm.com (e103737-lin.cambridge.arm.com [10.1.197.49]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id D0B8D3F641; Thu, 5 Oct 2023 07:45:13 -0700 (PDT) From: Sudeep Holla Date: Thu, 05 Oct 2023 15:44:58 +0100 Subject: [PATCH v4 05/17] firmware: arm_ffa: Implement the FFA_NOTIFICATION_SET interface MIME-Version: 1.0 Message-Id: <20231005-ffa_v1-1_notif-v4-5-cddd3237809c@arm.com> References: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> In-Reply-To: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> To: linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Sudeep Holla , Marc Bonnici , Jens Wiklander , Coboy Chen , Lorenzo Pieralisi , Olivier Deprez X-Mailer: b4 0.12.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=1504; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=4q7IiagFj1+jcbEerM+tVmHVjhNoYEy9g+TfTOniWJY=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlHsvxU+OC43JQZl2rh/aQ5hxCbL/2rnY6mISRn pGTv/huwB2JAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZR7L8QAKCRAAQbq8MX7i mONFD/91SNwLzgvbqoev7AcemtwFwEIcUq5ymafJb0GYsSNhSIHyE2Fc0QDnD5JgTQvF8Ww7bCa MyrtPbAxmPj+VkfD75JZmgXC7v0nVPjZ69uR+7D2kP2PxNOFiz2q0HCYkpTe6MumZGA4a+xWlrW il9Rc3Ylp2GYlRp/k4nA+JIhTSoqlqo4p+2Mzr52ESdNQrMyqiPIXM+qjcL13Tlb922K0ZfoNJd ElfDaqGRnnn/6yMZGzItAbsp3BnOXpjZtv4s1ogVe9+P+5RCwTGSrx4J1LM2lD71mQKB2ibjp2R OmErG7UrdKtHSNkfII9fiAffYeIJ++KnBX/1KWzpoRS7ssxnSy42bsi1DxKYUrbuTKLHC3brOxw 1hU8XanUC/u+SxI4ciJ+xpVxxBfdGP0aQQ65qwfgyTAKFNka9IYXK2mDCHjVg51VqEV0Mr8IlK1 VoggYkLvIFjuDM4mdGSf3Hi40v2Jvw2vNmCc05bXgg8re0mkLkdb9QgPbnmtE7y1cQeMiz8PxgL iuvKwiuOc0AFBXYA/pJlKmV3mGH47ffFqhOvSxDGcdYqIG/uh41kL6g+S381gOSz7VPfG/S4ZXS W3YPGIu6toky30eaLCxxby8VqYvn2IRsTMMcrh/6BZmuSXm27BykzpyPoIA9iDds6LVrS+okCZK +vJMXWVolUaXsHw== X-Developer-Key: i=sudeep.holla@arm.com; a=openpgp; fpr=7360A21742ADF5A11767C1C139CFD4755FE2D5B4 X-Spam-Status: No, score=-0.8 required=5.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS autolearn=unavailable autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on groat.vger.email Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-Greylist: Sender passed SPF test, not delayed by milter-greylist-4.6.4 (groat.vger.email [0.0.0.0]); Thu, 05 Oct 2023 09:06:38 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778932285397235832 X-GMAIL-MSGID: 1778932285397235832 The framework provides an interface to the sender to specify the notification to signal to the receiver. A sender signals a notification by requesting its partition manager to set the corresponding bit in the notifications bitmap of the receiver invoking FFA_NOTIFICATION_SET. Implement the FFA_NOTIFICATION_SET to enable the caller(sender) to send the notifications for any other partitions in the system. Signed-off-by: Sudeep Holla --- drivers/firmware/arm_ffa/driver.c | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c index 82e54d231074..4edb3cb48014 100644 --- a/drivers/firmware/arm_ffa/driver.c +++ b/drivers/firmware/arm_ffa/driver.c @@ -616,6 +616,26 @@ static int ffa_notification_bind_common(u16 dst_id, u64 bitmap, return 0; } +static +int ffa_notification_set(u16 src_id, u16 dst_id, u32 flags, u64 bitmap) +{ + ffa_value_t ret; + u32 src_dst_ids = PACK_TARGET_INFO(dst_id, src_id); + + invoke_ffa_fn((ffa_value_t) { + .a0 = FFA_NOTIFICATION_SET, .a1 = src_dst_ids, .a2 = flags, + .a3 = NOTIFICATION_BITMAP_LOW(bitmap), + .a4 = NOTIFICATION_BITMAP_HIGH(bitmap), + }, &ret); + + if (ret.a0 == FFA_ERROR) + return ffa_to_linux_errno((int)ret.a2); + else if (ret.a0 != FFA_SUCCESS) + return -EINVAL; + + return 0; +} + static int ffa_run(struct ffa_device *dev, u16 vcpu) { ffa_value_t ret; From patchwork Thu Oct 5 14:44:59 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 148925 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:612c:2016:b0:403:3b70:6f57 with SMTP id fe22csp434125vqb; Thu, 5 Oct 2023 09:57:56 -0700 (PDT) X-Google-Smtp-Source: AGHT+IG5KxbAgMmNKxVPQD+Am2TjDKK2sav08RKq8+JFhtBh9HhS7q8T4qEi91AQNQgOOe2OfTPX X-Received: by 2002:a05:6808:138d:b0:3ae:5c48:6f41 with SMTP id c13-20020a056808138d00b003ae5c486f41mr7108386oiw.28.1696525076277; Thu, 05 Oct 2023 09:57:56 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696525076; cv=none; d=google.com; s=arc-20160816; b=MH83fqzAc0OhaMfG+TkhPolIJfEJge96CGLQbGp0RDvMWezVbwCq+6MNvCbiLnp0on fy7D2DgwoRB/8OM6ronSGtu/oaaxVVU4lyR3ilg+sAVOFvmoh9gcEGxaykNvifMKQlyb uGv0FPBkY2RL4iqSxsTYrbiOZryW9vt6XeVcueKHPCNExHlzyXr0mfhAZmXUJNnNbMqi plErsUcB+GivPzehtteZ5Tld5/BlVqKwNUOpAjY7QkTRtvxZPeSLSHKEYLIUh2+YdV3W s3EuBeMiD1ZlAIakKpuINL7Jk06IPfs0QnwIM3gxU17EpkJTUBM2tstQXWzV5TRyQtWU 3iXw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:to:in-reply-to:references:message-id :content-transfer-encoding:mime-version:subject:date:from; bh=Najkg1aInljFHybjXNaCpqEcJ58T/sfGk24/Ez/DTeY=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=Qbzwhn8Z5AWVRoJz+G0g7+MhbayFv1pR5z3IpYGV745VDbDcXorY1xpHQS3hxZU83J oUKnbmcWamS/HPofBPupzt3Bgvdc7VEOm2EZXEewrFdidC34vzveVz7u9QmofXyEih7l tTmm+PxzMD4PCKRy6vvl6gD8TxdYrKWHZaxvbEtmyPsESiQjrWiII1+Pohf+AEbW+ocN sGg3Xt9L2tLOW8h+qt8+D6JYr2UicTfwEclc0Wg8FvbZfAxo650BdRqLh7b8myQVoZZw 8ofSuk52Omhph+xrYeUF2pzP5q8eyZW9ronZ/9V4NX43ms7vqo0SMI/nbXmvzH6lu+XW nahQ== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:7 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from snail.vger.email (snail.vger.email. [2620:137:e000::3:7]) by mx.google.com with ESMTPS id i14-20020a63cd0e000000b0057e21f51ab3si1819984pgg.665.2023.10.05.09.57.55 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 05 Oct 2023 09:57:56 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:7 as permitted sender) client-ip=2620:137:e000::3:7; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:7 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from out1.vger.email (depot.vger.email [IPv6:2620:137:e000::3:0]) by snail.vger.email (Postfix) with ESMTP id 8E99F8331E15; Thu, 5 Oct 2023 09:57:55 -0700 (PDT) X-Virus-Status: Clean X-Virus-Scanned: clamav-milter 0.103.10 at snail.vger.email Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S240047AbjJEQFR (ORCPT + 18 others); Thu, 5 Oct 2023 12:05:17 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57558 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234575AbjJEQDY (ORCPT ); Thu, 5 Oct 2023 12:03:24 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id 448519B7D for ; Thu, 5 Oct 2023 07:45:38 -0700 (PDT) Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id B8444152B; Thu, 5 Oct 2023 07:45:54 -0700 (PDT) Received: from e103737-lin.cambridge.arm.com (e103737-lin.cambridge.arm.com [10.1.197.49]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 0E3F83F641; Thu, 5 Oct 2023 07:45:14 -0700 (PDT) From: Sudeep Holla Date: Thu, 05 Oct 2023 15:44:59 +0100 Subject: [PATCH v4 06/17] firmware: arm_ffa: Implement the FFA_NOTIFICATION_GET interface MIME-Version: 1.0 Message-Id: <20231005-ffa_v1-1_notif-v4-6-cddd3237809c@arm.com> References: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> In-Reply-To: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> To: linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Sudeep Holla , Marc Bonnici , Jens Wiklander , Coboy Chen , Lorenzo Pieralisi , Olivier Deprez X-Mailer: b4 0.12.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=2442; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=JcT3Ibz8prcH4LEIf0QXidGEqQ8ig8451gBfq+wr8D4=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlHsvxvFGznmnDBqCTWy0NqxVWxtJHCRuDBexLt 2bYjTzDE3OJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZR7L8QAKCRAAQbq8MX7i mERnD/4qCvT3/HHxEq/b26JmL747hInAIaYIfi/Td6/7hwAKc2U4VIbtgn31Q0N7BZqt6uPqV1Z MsN/KoXXC80NrC7hIewgMZvSbz6Qyqd6iM1O87L/9YHjWM2tqsFAu2BP7eQqhvkJROEUYtvNeSK JVYdpJo9CwznRP91qloacnqHJlWhIT0ijwEN3zJzsRiQ5f9jPHAml3B4j6SokSNdhmqrnJqNMK5 t9/gwH2aAMbB6bOI6+fdizycB2HOu9/YLMW6JgsjhGitHgNj7q+7mZzeQ24F+vdGcvS/rAHJvTW fNFQlvLo927ZLqLRzBeSFHAv28cDK59Y2l5+2QmsDukXZwDbcf478OAqxWq6SnRTJzLvZwx9Rbx cMkupybn+cuV/Y5eOG4bh0t7txXL4ElvmELHOZrg+HlBuEwNoc6SiEi3/T2baSKSkEWpbMRBb72 hy9VECbyvs+IcizjiQopX19+J0OEMkTpkL+WFOiyJEBrnHDACfdSuGlZf44KePvCTTUyDGWKttd OTIvugwJSoRNpyLayc6QLbQWDDgl0bYO9dTeNNUZOx4HQAJldZ1dBlHF66Apewk91pfo7oQ9EAx AhnfDhPYiczjb22X6q6NU9BNIBLKQomgJuqqZaA4fXfUVSHOPP+oWsZJGPl8q0iJy5pXDrxd0ZY I+vqGuQmy4LPt+w== X-Developer-Key: i=sudeep.holla@arm.com; a=openpgp; fpr=7360A21742ADF5A11767C1C139CFD4755FE2D5B4 X-Spam-Status: No, score=-4.2 required=5.0 tests=BAYES_00,RCVD_IN_DNSWL_MED, SPF_HELO_NONE,SPF_NONE 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-Greylist: Sender passed SPF test, not delayed by milter-greylist-4.6.4 (snail.vger.email [0.0.0.0]); Thu, 05 Oct 2023 09:57:55 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778935478347839189 X-GMAIL-MSGID: 1778935478347839189 The framework provides an interface to the receiver to determine the identity of the notification. A receiver endpoint must use the FFA_NOTIFICATION_GET interface to retrieve its pending notifications and handle them. Add the support for FFA_NOTIFICATION_GET to allow the caller(receiver) to fetch its pending notifications from other partitions in the system. Signed-off-by: Sudeep Holla --- drivers/firmware/arm_ffa/driver.c | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c index 4edb3cb48014..7a0ac4f496bb 100644 --- a/drivers/firmware/arm_ffa/driver.c +++ b/drivers/firmware/arm_ffa/driver.c @@ -593,6 +593,14 @@ static int ffa_notification_bitmap_destroy(void) ((u32)(FIELD_GET(NOTIFICATION_HIGH_MASK, (x)))) #define NOTIFICATION_BITMAP_LOW(x) \ ((u32)(FIELD_GET(NOTIFICATION_LOW_MASK, (x)))) +#define PACK_NOTIFICATION_BITMAP(low, high) \ + (FIELD_PREP(NOTIFICATION_LOW_MASK, (low)) | \ + FIELD_PREP(NOTIFICATION_HIGH_MASK, (high))) + +#define RECEIVER_VCPU_MASK GENMASK(31, 16) +#define PACK_NOTIFICATION_GET_RECEIVER_INFO(vcpu_r, r) \ + (FIELD_PREP(RECEIVER_VCPU_MASK, (vcpu_r)) | \ + FIELD_PREP(RECEIVER_ID_MASK, (r))) static int ffa_notification_bind_common(u16 dst_id, u64 bitmap, u32 flags, bool is_bind) @@ -636,6 +644,35 @@ int ffa_notification_set(u16 src_id, u16 dst_id, u32 flags, u64 bitmap) return 0; } +struct ffa_notify_bitmaps { + u64 sp_map; + u64 vm_map; + u64 arch_map; +}; + +static int ffa_notification_get(u32 flags, struct ffa_notify_bitmaps *notify) +{ + ffa_value_t ret; + u16 src_id = drv_info->vm_id; + u16 cpu_id = smp_processor_id(); + u32 rec_vcpu_ids = PACK_NOTIFICATION_GET_RECEIVER_INFO(cpu_id, src_id); + + invoke_ffa_fn((ffa_value_t){ + .a0 = FFA_NOTIFICATION_GET, .a1 = rec_vcpu_ids, .a2 = flags, + }, &ret); + + if (ret.a0 == FFA_ERROR) + return ffa_to_linux_errno((int)ret.a2); + else if (ret.a0 != FFA_SUCCESS) + return -EINVAL; /* Something else went wrong. */ + + notify->sp_map = PACK_NOTIFICATION_BITMAP(ret.a2, ret.a3); + notify->vm_map = PACK_NOTIFICATION_BITMAP(ret.a4, ret.a5); + notify->arch_map = PACK_NOTIFICATION_BITMAP(ret.a6, ret.a7); + + return 0; +} + static int ffa_run(struct ffa_device *dev, u16 vcpu) { ffa_value_t ret; From patchwork Thu Oct 5 14:45:00 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 148807 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:612c:2016:b0:403:3b70:6f57 with SMTP id fe22csp374203vqb; Thu, 5 Oct 2023 08:23:36 -0700 (PDT) X-Google-Smtp-Source: AGHT+IHs9wfFymxTo7c6n0ddVLENE7BEIuw1RupRtQHJSjCpbRAcggoYGDVpUxP151nn5VrUKejb X-Received: by 2002:a05:6a00:2293:b0:690:449f:5e96 with SMTP id f19-20020a056a00229300b00690449f5e96mr6103437pfe.33.1696519416551; Thu, 05 Oct 2023 08:23:36 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696519416; cv=none; d=google.com; s=arc-20160816; b=xUQepi7C5XU2HUbdaTFWjuJLY3hj0n36bqn6M1dhTUEeTezrBvXaxB4M2AAh4Jfyc/ t3CKqf+mHV624W5iKZ0ZFplptlH+aY85akcC5KIy2A7ew9HlR8bSVvgkBSrQ63qMqhTs Hrw+X/SBilGsAwiCRdGv0jDPKiFmTcFJbbk3myXQZwdL4e7/uNWmzFbPju8ZjZ1o7UEF HC+2tgQuIU5Lk/IyEQ9FavzbpKnz0x2JB9h0onzmu556yDFp2UfKL30wWiqGVJIS6HRw yUVKqhf860zarH05qqf1mlCCRSvGk+wx4xp1vbrUka9VVjX4kAWZb+bfXxxjf82XrFCJ ulcQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:to:in-reply-to:references:message-id :content-transfer-encoding:mime-version:subject:date:from; bh=nMDHLBAyQ+UQFcCk3yVSmpiQpHSvHZlI/z8HomXrlbg=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=ReDMCLWBklfg2noZqQ2IHRzfYJReFXeoT96swe1fpbNH/OO9teynQOeN05Xi/rptqx lkZd9f5CgwHsJzqt5BbmCjNmDp7LDWOPSUMgnrKaHkmGfxs+pVrxmTu455JGDY4n5uUQ RwmICxYYC/xUzXySTWU7mjloX/CECZYn4yL3u0QDBCxr18llS+wPgzmttikIFbb/Jne6 B78ul7qLxPOfUC/QKhH4SZogBmQEo5DcS8bPWVn+SajSMI22LJARTV+K4itu2BPIUhlT XJiFFkgxcMOklQedS/8lVpJvkQcsyn1iJMX/1Sk64TetmY6fi1cUzy6XNZS/tV+CjTqa w5vA== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:4 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from howler.vger.email (howler.vger.email. [2620:137:e000::3:4]) by mx.google.com with ESMTPS id eg23-20020a056a00801700b006933746d6edsi1573647pfb.22.2023.10.05.08.23.36 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 05 Oct 2023 08:23:36 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:4 as permitted sender) client-ip=2620:137:e000::3:4; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:4 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from out1.vger.email (depot.vger.email [IPv6:2620:137:e000::3:0]) by howler.vger.email (Postfix) with ESMTP id 2FC938085F8D; Thu, 5 Oct 2023 08:22:26 -0700 (PDT) X-Virus-Status: Clean X-Virus-Scanned: clamav-milter 0.103.10 at howler.vger.email Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232660AbjJEPV6 (ORCPT + 19 others); Thu, 5 Oct 2023 11:21:58 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:51002 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233589AbjJEPVF (ORCPT ); Thu, 5 Oct 2023 11:21:05 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id 508AA9EE0 for ; Thu, 5 Oct 2023 07:45:38 -0700 (PDT) Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id E9B60153B; Thu, 5 Oct 2023 07:45:55 -0700 (PDT) Received: from e103737-lin.cambridge.arm.com (e103737-lin.cambridge.arm.com [10.1.197.49]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 3FEBB3F641; Thu, 5 Oct 2023 07:45:16 -0700 (PDT) From: Sudeep Holla Date: Thu, 05 Oct 2023 15:45:00 +0100 Subject: [PATCH v4 07/17] firmware: arm_ffa: Implement the NOTIFICATION_INFO_GET interface MIME-Version: 1.0 Message-Id: <20231005-ffa_v1-1_notif-v4-7-cddd3237809c@arm.com> References: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> In-Reply-To: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> To: linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Sudeep Holla , Marc Bonnici , Jens Wiklander , Coboy Chen , Lorenzo Pieralisi , Olivier Deprez X-Mailer: b4 0.12.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=3589; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=CxdxAVY/MTl/iCsvKjrPq0pC+5xP2GJmZN5U5PgPO4U=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlHsvxEQ3Lxe6D8SGBgmlxd7WIweA9a2k9e1/F8 qW6cSsYxT+JAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZR7L8QAKCRAAQbq8MX7i mCVBD/9Xn3XgDDApkwxp7KVKVIg7rGT1Sq9ths7IIjgjpfYaRJ6zeZFgdeS58z8U1QkcvWwU7Vf 3x6ZaO4qOQvFBclszikt9H58PtlFYKbt2PcYJDKCduZizKD/nOsjZvSOQJYzj4LHVJgkaSP9q5h X7dt7grFJgUOYHQYANvQ+/Ime/WfxFqvGOUppRjF43r8ULCJFm7YB+WnGvWhaKFkHDeHuSDK29o rzd1XL3DcZgRwPjyBDqxfTPyzhQkBJL9syVxjaiWDkeFvtO43kugc0S7UzvbhghsQyhvyBCZQKu SwlHDORZbwvv5kguLGz7iVG4hoatsia+GSRo+w5idN6w8BpcOqYV9E8zTs3KY13hNM7dw6dCl2s cYVjNGdJyE/8NVGbBmOaaD7LWm01HgmiA5PjRuIq1UiauwSrjr3HRXCf6oOfemPCp2psr+vH/8d cl/A3fLYh3QX+KneRzUrbahJ4KW5bTaQ99XhbLxkZH22a7zYZl+IV8MrXXTaTZ18TeXr9p3s7kx CIOnftd/qbT9XiQyB+9Tf/+0gwUWPvHNwA/oe0wT0EBzQOWggsmiQp5VoJ1mpzud8O+mIvNbSbM R4P7GNVFn7yD76gDTZk8/RD39Pqyu/qCIjyrla8bogW+DUYW7wkb2wW1tza5b0zbwNzie2vZl89 6IaQKwjmzuV/+SA== X-Developer-Key: i=sudeep.holla@arm.com; a=openpgp; fpr=7360A21742ADF5A11767C1C139CFD4755FE2D5B4 X-Spam-Status: No, score=-4.2 required=5.0 tests=BAYES_00,RCVD_IN_DNSWL_MED, SPF_HELO_NONE,SPF_NONE 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-Greylist: Sender passed SPF test, not delayed by milter-greylist-4.6.4 (howler.vger.email [0.0.0.0]); Thu, 05 Oct 2023 08:22:26 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778929543570509242 X-GMAIL-MSGID: 1778929543570509242 The receiver’s scheduler uses the FFA_NOTIFICATION_INFO_GET interface to retrieve the list of endpoints that have pending notifications and must be run. A notification could be signaled by a sender in the secure world to a VM. The Hypervisor needs to determine which VM and vCPU (in case a per-vCPU notification is signaled) has a pending notification in this scenario. It must obtain this information through an invocation of the FFA_NOTIFICATION_INFO_GET. Add the implementation of the NOTIFICATION_INFO_GET interface and prepare to use this to handle the schedule receiver interrupt. Implementation of handling notifications will be added later. Signed-off-by: Sudeep Holla --- drivers/firmware/arm_ffa/driver.c | 73 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 73 insertions(+) diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c index 7a0ac4f496bb..b1dd8539ab0d 100644 --- a/drivers/firmware/arm_ffa/driver.c +++ b/drivers/firmware/arm_ffa/driver.c @@ -602,6 +602,13 @@ static int ffa_notification_bitmap_destroy(void) (FIELD_PREP(RECEIVER_VCPU_MASK, (vcpu_r)) | \ FIELD_PREP(RECEIVER_ID_MASK, (r))) +#define NOTIFICATION_INFO_GET_MORE_PEND_MASK BIT(0) +#define NOTIFICATION_INFO_GET_ID_COUNT GENMASK(11, 7) +#define ID_LIST_MASK_64 GENMASK(51, 12) +#define ID_LIST_MASK_32 GENMASK(31, 12) +#define MAX_IDS_64 20 +#define MAX_IDS_32 10 + static int ffa_notification_bind_common(u16 dst_id, u64 bitmap, u32 flags, bool is_bind) { @@ -673,6 +680,72 @@ static int ffa_notification_get(u32 flags, struct ffa_notify_bitmaps *notify) return 0; } +static void __do_sched_recv_cb(u16 partition_id, u16 vcpu, bool is_per_vcpu) +{ + pr_err("Callback for partition 0x%x failed.\n", partition_id); +} + +static void ffa_notification_info_get(void) +{ + int idx, list, max_ids, lists_cnt, ids_processed, ids_count[MAX_IDS_64]; + bool is_64b_resp; + ffa_value_t ret; + u64 id_list; + + do { + invoke_ffa_fn((ffa_value_t){ + .a0 = FFA_FN_NATIVE(NOTIFICATION_INFO_GET), + }, &ret); + + if (ret.a0 != FFA_FN_NATIVE(SUCCESS) && ret.a0 != FFA_SUCCESS) { + if (ret.a2 != FFA_RET_NO_DATA) + pr_err("Notification Info fetch failed: 0x%lx (0x%lx)", + ret.a0, ret.a2); + return; + } + + is_64b_resp = (ret.a0 == FFA_FN64_SUCCESS); + + ids_processed = 0; + lists_cnt = FIELD_GET(NOTIFICATION_INFO_GET_ID_COUNT, ret.a2); + if (is_64b_resp) { + max_ids = MAX_IDS_64; + id_list = FIELD_GET(ID_LIST_MASK_64, ret.a2); + } else { + max_ids = MAX_IDS_32; + id_list = FIELD_GET(ID_LIST_MASK_32, ret.a2); + } + + for (idx = 0; idx < lists_cnt; idx++, id_list >>= 2) + ids_count[idx] = (id_list & 0x3) + 1; + + /* Process IDs */ + for (list = 0; list < lists_cnt; list++) { + u16 vcpu_id, part_id, *packed_id_list = (u16 *)&ret.a3; + + if (ids_processed >= max_ids - 1) + break; + + part_id = packed_id_list[++ids_processed]; + + if (!ids_count[list]) { /* Global Notification */ + __do_sched_recv_cb(part_id, 0, false); + continue; + } + + /* Per vCPU Notification */ + for (idx = 0; idx < ids_count[list]; idx++) { + if (ids_processed >= max_ids - 1) + break; + + vcpu_id = packed_id_list[++ids_processed]; + + __do_sched_recv_cb(part_id, vcpu_id, true); + } + } + } while (ret.a2 & NOTIFICATION_INFO_GET_MORE_PEND_MASK); +} + static int ffa_run(struct ffa_device *dev, u16 vcpu) { ffa_value_t ret; From patchwork Thu Oct 5 14:45:01 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 148853 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:612c:2016:b0:403:3b70:6f57 with SMTP id fe22csp404023vqb; Thu, 5 Oct 2023 09:07:38 -0700 (PDT) X-Google-Smtp-Source: AGHT+IEioPVAuIYFEmXGWfhsaaKSHCld1A7N8+xw0sUvMmQdx55Rm9dn0HI9EpW65XOf9grec7Uw X-Received: by 2002:a17:903:41d2:b0:1c7:71d2:a96a with SMTP id u18-20020a17090341d200b001c771d2a96amr6473107ple.12.1696522058290; Thu, 05 Oct 2023 09:07:38 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696522058; cv=none; d=google.com; s=arc-20160816; b=xEWKnEwJ8eEjAgNqYkCvIcxJO/Meq1v+KZs7hk0j3fb8BIFyQtAMxuFwZMN6zLY+td VQWeUThtUkejDTuHX1rwbQA2MhhVDEr8EVvm82uTE086Ry5kIM7gFxtFyMn331Gg06VK TvGy/eTmxWUtYo+yl7epxaqOPsYBBINgb12XQOwZOLnkyAiCExnboPWK1JYIkDPOoQfw 5L4I6ZHL52G/HhMslBMJwxXIup9Pc1gsdEvJOKtp1XQYAbCzHnEghOlf6b++wO3CXbt5 gWJpSW0+nrl1Tniw/ZQrP1hjfjhsmiYoDl6WIbIWQIb9iaa2IRWfBAPluZLNBxjBaY5C HRvg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:to:in-reply-to:references:message-id :content-transfer-encoding:mime-version:subject:date:from; bh=ubEGYm0fSNWXXAVNSrCwS64/XhIzzKe2PlHQroq6/+c=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=qSvwi7eltZtd8OAgdrP6kiKS5aen99Mr6tmlEHQ1IHR37t4LQo9MlXl8NelV0Ua7a+ 0PZmtmvBo+uv/opg5geE8PgdeSJ/jaiwrEyQ1GQTXvf1yiYMyjwz9+MTzHw9ZDLWKYbF MvAKlU45zBdOo1yXIwj6AOFllv4aMg6dIjzNX49WF2oMgjmWpPx0GxACyqKu+thkdGV2 fd5k9P6nQBjGgBwbNLDFp5CUbhijGFUWq0CZDTkybqdO25vc3dPPWQFo2SVB0cVTpF8b K+17oMsXfLFq4Fjc8SWLDGv3R0b8wwIkOmcUuUhm6250qXuNxZO1yIfb7nI3EaYiVwaF +Djw== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:4 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from howler.vger.email (howler.vger.email. [2620:137:e000::3:4]) by mx.google.com with ESMTPS id w9-20020a1709026f0900b001c20db25104si205266plk.117.2023.10.05.09.07.36 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 05 Oct 2023 09:07:38 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:4 as permitted sender) client-ip=2620:137:e000::3:4; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:4 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from out1.vger.email (depot.vger.email [IPv6:2620:137:e000::3:0]) by howler.vger.email (Postfix) with ESMTP id 0A3C380B6C0E; Thu, 5 Oct 2023 09:06:02 -0700 (PDT) X-Virus-Status: Clean X-Virus-Scanned: clamav-milter 0.103.10 at howler.vger.email Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234812AbjJEQFZ (ORCPT + 19 others); Thu, 5 Oct 2023 12:05:25 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34520 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234632AbjJEQDY (ORCPT ); Thu, 5 Oct 2023 12:03:24 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id 50D719EFA for ; Thu, 5 Oct 2023 07:45:38 -0700 (PDT) Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 275C01570; Thu, 5 Oct 2023 07:45:57 -0700 (PDT) Received: from e103737-lin.cambridge.arm.com (e103737-lin.cambridge.arm.com [10.1.197.49]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 719143F641; Thu, 5 Oct 2023 07:45:17 -0700 (PDT) From: Sudeep Holla Date: Thu, 05 Oct 2023 15:45:01 +0100 Subject: [PATCH v4 08/17] firmware: arm_ffa: Initial support for scheduler receiver interrupt MIME-Version: 1.0 Message-Id: <20231005-ffa_v1-1_notif-v4-8-cddd3237809c@arm.com> References: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> In-Reply-To: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> To: linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Sudeep Holla , Marc Bonnici , Jens Wiklander , Coboy Chen , Lorenzo Pieralisi , Olivier Deprez X-Mailer: b4 0.12.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=7668; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=yU+hWtBWbLNiVtAMPUpIWeJRLZY4AERdKc+TThgbkq8=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlHsvxPVH0CxF7HA2KS9+I8Bsy1VybqF81R5Ap0 SepshdLeK+JAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZR7L8QAKCRAAQbq8MX7i mOFID/4yQcSmODzazuTJAo2qCM/wRZ1K9colo9iGkyq2Bvf+QlxB71uQbOiwTIUzecMhAAnawZm mdrYi2an/rCfTkPO3SUUTEeBofdZzw7HmIQ1MaFnmEAMzPg7xa9B+DRZd3u3cdvbk0ixmz3btL9 v7RB4Uf+6/aulhX6sZ6m4PpIP/sarkjLNPg7kIsJsYW1oMeQ9DcgYXVCubSRcamdb+kDH+wdwbc rzCs2/5qXsiCIvNZ7DrchAl8GZztkphtUs/scloQcVP70N/TwaO04rspoOpoiQCBaVvWlNk79mp 2ZhfoEBcb5ekI3kxnTG6ej5tRiU2yd37IqKm4rVUIraF8+LJqKJh72HSeSethCmFK0xiRz1dD+s px0VefwJn52EgylDgmgRn/DF2Y4tRfFnzRrJ38GBsRtswEyKr6JIpjKZ4ytzkzY5gLLLCkFwtIT s6t2xlculC6/zXk8Ftbce+ie/HDOitgPWjL/wvc1mM7UE/aZv7OffunAAvLDCGmwBPyLB/MeTaI 9IBqMCFQPjEx7dQPaDd+zk9sjElWRKBtNRLh68rs6U7JLZcbk4O9ifRmb3hKxDgCqAD7XfAVZPX pSPW2/ij0UD8pC3IeHiO3CdXVLxu+OlVmOcEsI88juRU21Khq11M4Lg7O52PL0Aedtj7kK1j2KL KQoTgS+6nEN3SRA== X-Developer-Key: i=sudeep.holla@arm.com; a=openpgp; fpr=7360A21742ADF5A11767C1C139CFD4755FE2D5B4 X-Spam-Status: No, score=-4.2 required=5.0 tests=BAYES_00,RCVD_IN_DNSWL_MED, SPF_HELO_NONE,SPF_NONE,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-Greylist: Sender passed SPF test, not delayed by milter-greylist-4.6.4 (howler.vger.email [0.0.0.0]); Thu, 05 Oct 2023 09:06:02 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778932314103327228 X-GMAIL-MSGID: 1778932314103327228 The Framework uses the schedule receiver interrupt to inform the receiver’s scheduler that the receiver must be run to handle a pending notification. A receiver’s scheduler can obtain the description of the schedule receiver interrupt by invoking the FFA_FEATURES interface. The delivery of the physical schedule receiver interrupt from the secure state to the non-secure state depends upon the state of the interrupt controller as configured by the hypervisor. The schedule seceiver interrupt is assumed to be a SGI. The Arm GIC specification defines 16 SGIs. It recommends that they are equally divided between the non-secure and secure states. OS like Linux kernel in the non-secure state typically do not have SGIs to spare. The usage of SGIs in the secure state is however limited. It is more likely that software in the Secure world does not use all the SGIs allocated to it. It is recommended that the secure world software donates an unused SGI to the normal world for use as the schedule receiver interrupt. This implies that secure world software must configure the SGI in the GIC as a non-secure interrupt before presenting it to the normal world. Signed-off-by: Sudeep Holla --- drivers/firmware/arm_ffa/driver.c | 186 ++++++++++++++++++++++++++++++++++++-- 1 file changed, 176 insertions(+), 10 deletions(-) diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c index b1dd8539ab0d..f8d01840f5ec 100644 --- a/drivers/firmware/arm_ffa/driver.c +++ b/drivers/firmware/arm_ffa/driver.c @@ -22,15 +22,20 @@ #define DRIVER_NAME "ARM FF-A" #define pr_fmt(fmt) DRIVER_NAME ": " fmt +#include #include #include +#include #include +#include #include #include #include #include +#include #include #include +#include #include #include "common.h" @@ -76,6 +81,10 @@ static inline int ffa_to_linux_errno(int errno) return -EINVAL; } +struct ffa_pcpu_irq { + struct ffa_drv_info *info; +}; + struct ffa_drv_info { u32 version; u16 vm_id; @@ -85,6 +94,11 @@ struct ffa_drv_info { void *tx_buffer; bool mem_ops_native; bool bitmap_created; + unsigned int sched_recv_irq; + unsigned int cpuhp_state; + struct ffa_pcpu_irq __percpu *irq_pcpu; + struct workqueue_struct *notif_pcpu_wq; + struct work_struct irq_work; }; static struct ffa_drv_info *drv_info; @@ -917,34 +931,182 @@ static void ffa_setup_partitions(void) kfree(pbuf); } -static int ffa_notifications_setup(void) +/* FFA FEATURE IDs */ +#define FFA_FEAT_NOTIFICATION_PENDING_INT (1) +#define FFA_FEAT_SCHEDULE_RECEIVER_INT (2) +#define FFA_FEAT_MANAGED_EXIT_INT (3) + +static irqreturn_t irq_handler(int irq, void *irq_data) { - int ret; + struct ffa_pcpu_irq *pcpu = irq_data; + struct ffa_drv_info *info = pcpu->info; - ret = ffa_features(FFA_NOTIFICATION_BITMAP_CREATE, 0, NULL, NULL); - if (ret) { - pr_err("Notifications not supported, continuing with it ..\n"); - return 0; + queue_work(info->notif_pcpu_wq, &info->irq_work); + + return IRQ_HANDLED; +} + +static void ffa_sched_recv_irq_work_fn(struct work_struct *work) +{ + ffa_notification_info_get(); +} + +static int ffa_sched_recv_irq_map(void) +{ + int ret, irq, sr_intid; + + /* The returned sr_intid is assumed to be SGI donated to NS world */ + ret = ffa_features(FFA_FEAT_SCHEDULE_RECEIVER_INT, 0, &sr_intid, NULL); + if (ret < 0) { + if (ret != -EOPNOTSUPP) + pr_err("Failed to retrieve scheduler Rx interrupt\n"); + return ret; } - ret = ffa_notification_bitmap_create(); + if (acpi_disabled) { + struct of_phandle_args oirq = {}; + struct device_node *gic; + + /* Only GICv3 supported currently with the device tree */ + gic = of_find_compatible_node(NULL, NULL, "arm,gic-v3"); + if (!gic) + return -ENXIO; + + oirq.np = gic; + oirq.args_count = 1; + oirq.args[0] = sr_intid; + irq = irq_create_of_mapping(&oirq); + of_node_put(gic); +#ifdef CONFIG_ACPI + } else { + irq = acpi_register_gsi(NULL, sr_intid, ACPI_EDGE_SENSITIVE, + ACPI_ACTIVE_HIGH); +#endif + } + + if (irq <= 0) { + pr_err("Failed to create IRQ mapping!\n"); + return -ENODATA; + } + + return irq; +} + +static void ffa_sched_recv_irq_unmap(void) +{ + if (drv_info->sched_recv_irq) + irq_dispose_mapping(drv_info->sched_recv_irq); +} + +static int ffa_cpuhp_pcpu_irq_enable(unsigned int cpu) +{ + enable_percpu_irq(drv_info->sched_recv_irq, IRQ_TYPE_NONE); + return 0; +} + +static int ffa_cpuhp_pcpu_irq_disable(unsigned int cpu) +{ + disable_percpu_irq(drv_info->sched_recv_irq); + return 0; +} + +static void ffa_uninit_pcpu_irq(void) +{ + if (drv_info->cpuhp_state) + cpuhp_remove_state(drv_info->cpuhp_state); + + if (drv_info->notif_pcpu_wq) + destroy_workqueue(drv_info->notif_pcpu_wq); + + if (drv_info->sched_recv_irq) + free_percpu_irq(drv_info->sched_recv_irq, drv_info->irq_pcpu); + + if (drv_info->irq_pcpu) + free_percpu(drv_info->irq_pcpu); +} + +static int ffa_init_pcpu_irq(unsigned int irq) +{ + struct ffa_pcpu_irq __percpu *irq_pcpu; + int ret, cpu; + + irq_pcpu = alloc_percpu(struct ffa_pcpu_irq); + if (!irq_pcpu) + return -ENOMEM; + + for_each_present_cpu(cpu) + per_cpu_ptr(irq_pcpu, cpu)->info = drv_info; + + drv_info->irq_pcpu = irq_pcpu; + + ret = request_percpu_irq(irq, irq_handler, "ARM-FFA", irq_pcpu); if (ret) { - pr_err("notification_bitmap_create error %d\n", ret); + pr_err("Error registering notification IRQ %d: %d\n", irq, ret); return ret; } - drv_info->bitmap_created = true; + INIT_WORK(&drv_info->irq_work, ffa_sched_recv_irq_work_fn); + drv_info->notif_pcpu_wq = create_workqueue("ffa_pcpu_irq_notification"); + if (!drv_info->notif_pcpu_wq) + return -EINVAL; + + ret = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "ffa/pcpu-irq:starting", + ffa_cpuhp_pcpu_irq_enable, + ffa_cpuhp_pcpu_irq_disable); + + if (ret < 0) + return ret; + + drv_info->cpuhp_state = ret; return 0; } static void ffa_notifications_cleanup(void) { + ffa_uninit_pcpu_irq(); + ffa_sched_recv_irq_unmap(); + if (drv_info->bitmap_created) { ffa_notification_bitmap_destroy(); drv_info->bitmap_created = false; } } +static int ffa_notifications_setup(void) +{ + int ret, irq; + + ret = ffa_features(FFA_NOTIFICATION_BITMAP_CREATE, 0, NULL, NULL); + if (ret) { + pr_err("Notifications not supported, continuing with it ..\n"); + return 0; + } + + ret = ffa_notification_bitmap_create(); + if (ret) { + pr_err("notification_bitmap_create error %d\n", ret); + return ret; + } + drv_info->bitmap_created = true; + + irq = ffa_sched_recv_irq_map(); + if (irq <= 0) { + ret = irq; + goto cleanup; + } + + drv_info->sched_recv_irq = irq; + + ret = ffa_init_pcpu_irq(irq); + if (ret) + goto cleanup; + + return 0; +cleanup: + ffa_notifications_cleanup(); + return ret; +} + static int __init ffa_init(void) { int ret; @@ -1000,7 +1162,11 @@ static int __init ffa_init(void) ffa_set_up_mem_ops_native_flag(); - return ffa_notifications_setup(); + ret = ffa_notifications_setup(); + if (ret) + goto free_pages; + + return 0; free_pages: if (drv_info->tx_buffer) free_pages_exact(drv_info->tx_buffer, RXTX_BUFFER_SIZE); From patchwork Thu Oct 5 14:45:02 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 148809 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:612c:2016:b0:403:3b70:6f57 with SMTP id fe22csp376292vqb; Thu, 5 Oct 2023 08:26:49 -0700 (PDT) X-Google-Smtp-Source: AGHT+IHvtJCX03BWZpKFKIUYjlJySs05gvZpn8z6Tn1K86SYZynvn2BeIG6zkR8qfVQ5GIB9d7TI X-Received: by 2002:a92:cd8b:0:b0:34f:7e36:5f8b with SMTP id r11-20020a92cd8b000000b0034f7e365f8bmr6538861ilb.25.1696519609423; Thu, 05 Oct 2023 08:26:49 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696519609; cv=none; d=google.com; s=arc-20160816; b=xYmwuGBQN1100R4D/LM3Gq+usAn2u6CR1CfZfaZdLn+vVYF9c2ts6WiZiGdDZZe44e t60R1acuViaPxPw7y2ayVo5hmLNY3oBkhZEsdUWpRDsdWnLZhKqhFTktDK6S7qA9by8O 0BCDcSNxNK7OR1fznVMagCmbrcasrSOXzSteVESGF62HspsSaKRhHVLgwSHpaAE8pqIq Wu0CAw8aj5FkyRAkyDb+RTBfE/OWd2sbIww3F9nbhj6JQKYjwqSVihqfCv8+dity4WDy tSJMibPbwd+85Qi8re6L1yojqf6H6TU8/y7jasUEy7fEgPXznJ2anBgQdQKYdZUP3X/Z QXLQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:to:in-reply-to:references:message-id :content-transfer-encoding:mime-version:subject:date:from; bh=YP8x96D0aZhGcbyNyfENA907RBI0dQT1arxvxLqk01Y=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=vuTmd1HqnOAUdO79BQo7G4W6gHmX+nhtWJSDExHqaFqwAfF1w4Hc5AYxW6ieCp59nC wZpXu/QItT30/AdsQQM7E/J/QeXoczgyAeGbwBYeN962p7l7HG72i8ZCepBDn+VjIWPD WbII1Q8kiylndrBZUkm8Cj7lfDngt8ObfXYZUnTXTR9TH/s+A9kEp3TD57JZwtbjvA1L AyEXWqUDaxQ/wY7w8/tDS5Rtobl8lGbsaRNDln4otsneM5maCEBk7jl8LGLZAfsoNgjg EhOPf76cSG2SyjVRxe0klqwwIncnTSNaYMeZYjqpXFiMfa19uQE/qjGrslyN+kgw+A7D 0gSA== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:4 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from howler.vger.email (howler.vger.email. [2620:137:e000::3:4]) by mx.google.com with ESMTPS id cm15-20020a056a020a0f00b00578b9fb24f6si1525450pgb.616.2023.10.05.08.26.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 05 Oct 2023 08:26:49 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:4 as permitted sender) client-ip=2620:137:e000::3:4; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:4 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from out1.vger.email (depot.vger.email [IPv6:2620:137:e000::3:0]) by howler.vger.email (Postfix) with ESMTP id C9B6B80A932F; Thu, 5 Oct 2023 08:25:49 -0700 (PDT) X-Virus-Status: Clean X-Virus-Scanned: clamav-milter 0.103.10 at howler.vger.email Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232029AbjJEPZk (ORCPT + 19 others); Thu, 5 Oct 2023 11:25:40 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:47112 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232583AbjJEPZA (ORCPT ); Thu, 5 Oct 2023 11:25:00 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id DC34B1FEEF for ; Thu, 5 Oct 2023 07:45:41 -0700 (PDT) Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 592F01576; Thu, 5 Oct 2023 07:45:58 -0700 (PDT) Received: from e103737-lin.cambridge.arm.com (e103737-lin.cambridge.arm.com [10.1.197.49]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id A34533F641; Thu, 5 Oct 2023 07:45:18 -0700 (PDT) From: Sudeep Holla Date: Thu, 05 Oct 2023 15:45:02 +0100 Subject: [PATCH v4 09/17] firmware: arm_ffa: Add schedule receiver callback mechanism MIME-Version: 1.0 Message-Id: <20231005-ffa_v1-1_notif-v4-9-cddd3237809c@arm.com> References: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> In-Reply-To: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> To: linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Sudeep Holla , Marc Bonnici , Jens Wiklander , Coboy Chen , Lorenzo Pieralisi , Olivier Deprez X-Mailer: b4 0.12.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=6827; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=gJTWJRo2bKu1EdJbiC84iwBAD0RzFSDy4pUoU0x9hq8=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlHsvxGjQa+0sAlJhSFtCphaKPzxz2FRYB4zWti ArUgI9NfyCJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZR7L8QAKCRAAQbq8MX7i mIqHEACkL+R/tDisIKTNBsGivvSys5ySeP71mI8sLeNBNOSl8IXDls5/yWM4iOMamS7mEGF98Wn lkCU+R8ZXSFIg3J8QLHwCeHxM67MbS/eS+va18UvHwdjPpYDgSZzetVPzMD9t6MEaLlSfQtUrmm gtjTd8uFdnUtxCgGk207A0q+8o3P8TSK/r1bRbvC110s5MpxI+2bzlMYQg/QLGkHGI/1BVrd/ne vwX0dZ9pouIYLKlX7A8aHPQAnfseCQU+zKXFDdEhiCTTis5E3nrIbFDTQH9qRQodzwvFe05E2Ae u9g1/vIlCmJw+WPCUxgEII5pRILJSxT8H9U+rN0eiQ4bFq+lC8dQdqxjw9SHvZNdvDMOOsQRSpn H/vdKzn82opVDsNQROy4SkcwxsvseMAqQJkYak15cvcYcE0QsN2QqEijzI1U8DX1SDP3U2mM+Hb LpqUiefyou9gofFy/4b5ZTRtdwHiCfkd1UOfMM4jg47GTgINo0U7ZtAcPUAbdLXGrred0TIYmZ4 3f1LZBDGyvUxCSW0Vmlc1jMqexzGAAxDiJofkFVL3JuG22wrgvJyioh0DkXqqJ+YN39w6ihTI7/ iFHbu615GbRfcsksbVB7FaXFR72+4k8tPDxvs/nxTv/3k9tj8hY8/txYo28nPKPSE+OXfNi4Xzw tTjcK34TWsnJaYA== X-Developer-Key: i=sudeep.holla@arm.com; a=openpgp; fpr=7360A21742ADF5A11767C1C139CFD4755FE2D5B4 X-Spam-Status: No, score=-4.2 required=5.0 tests=BAYES_00,RCVD_IN_DNSWL_MED, SPF_HELO_NONE,SPF_NONE 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-Greylist: Sender passed SPF test, not delayed by milter-greylist-4.6.4 (howler.vger.email [0.0.0.0]); Thu, 05 Oct 2023 08:25:49 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778929746031108504 X-GMAIL-MSGID: 1778929746031108504 Enable client drivers to register a callback function that will be called when one or more notifications are pending for a target partition as part of schedule receiver interrupt handling. Signed-off-by: Sudeep Holla --- drivers/firmware/arm_ffa/driver.c | 103 ++++++++++++++++++++++++++++++++++++-- include/linux/arm_ffa.h | 8 +++ 2 files changed, 108 insertions(+), 3 deletions(-) diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c index f8d01840f5ec..04cdb49cc78b 100644 --- a/drivers/firmware/arm_ffa/driver.c +++ b/drivers/firmware/arm_ffa/driver.c @@ -37,6 +37,7 @@ #include #include #include +#include #include "common.h" @@ -99,6 +100,8 @@ struct ffa_drv_info { struct ffa_pcpu_irq __percpu *irq_pcpu; struct workqueue_struct *notif_pcpu_wq; struct work_struct irq_work; + struct xarray partition_info; + unsigned int partition_count; }; static struct ffa_drv_info *drv_info; @@ -694,9 +697,26 @@ static int ffa_notification_get(u32 flags, struct ffa_notify_bitmaps *notify) return 0; } -static void __do_sched_recv_cb(u16 partition_id, u16 vcpu, bool is_per_vcpu) +struct ffa_dev_part_info { + ffa_sched_recv_cb callback; + void *cb_data; + rwlock_t rw_lock; +}; + +static void __do_sched_recv_cb(u16 part_id, u16 vcpu, bool is_per_vcpu) { - pr_err("Callback for partition 0x%x failed.\n", partition_id); + struct ffa_dev_part_info *partition; + ffa_sched_recv_cb callback; + void *cb_data; + + partition = xa_load(&drv_info->partition_info, part_id); + read_lock(&partition->rw_lock); + callback = partition->callback; + cb_data = partition->cb_data; + read_unlock(&partition->rw_lock); + + if (callback) + callback(vcpu, is_per_vcpu, cb_data); } static void ffa_notification_info_get(void) @@ -845,6 +865,39 @@ static int ffa_memory_lend(struct ffa_mem_ops_args *args) return ffa_memory_ops(FFA_MEM_LEND, args); } +static int ffa_sched_recv_cb_update(u16 part_id, ffa_sched_recv_cb callback, + void *cb_data, bool is_registration) +{ + struct ffa_dev_part_info *partition; + bool cb_valid; + + partition = xa_load(&drv_info->partition_info, part_id); + write_lock(&partition->rw_lock); + + cb_valid = !!partition->callback; + if (!(is_registration ^ cb_valid)) { + write_unlock(&partition->rw_lock); + return -EINVAL; + } + + partition->callback = callback; + partition->cb_data = cb_data; + + write_unlock(&partition->rw_lock); + return 0; +} + +static int ffa_sched_recv_cb_register(struct ffa_device *dev, + ffa_sched_recv_cb cb, void *cb_data) +{ + return ffa_sched_recv_cb_update(dev->vm_id, cb, cb_data, true); +} + +static int ffa_sched_recv_cb_unregister(struct ffa_device *dev) +{ + return ffa_sched_recv_cb_update(dev->vm_id, NULL, NULL, false); +} + static const struct ffa_info_ops ffa_drv_info_ops = { .api_version_get = ffa_api_version_get, .partition_info_get = ffa_partition_info_get, @@ -865,11 +918,17 @@ static const struct ffa_cpu_ops ffa_drv_cpu_ops = { .run = ffa_run, }; +static const struct ffa_notifier_ops ffa_drv_notifier_ops = { + .sched_recv_cb_register = ffa_sched_recv_cb_register, + .sched_recv_cb_unregister = ffa_sched_recv_cb_unregister, +}; + static const struct ffa_ops ffa_drv_ops = { .info_ops = &ffa_drv_info_ops, .msg_ops = &ffa_drv_msg_ops, .mem_ops = &ffa_drv_mem_ops, .cpu_ops = &ffa_drv_cpu_ops, + .notifier_ops = &ffa_drv_notifier_ops, }; void ffa_device_match_uuid(struct ffa_device *ffa_dev, const uuid_t *uuid) @@ -900,6 +959,7 @@ static void ffa_setup_partitions(void) int count, idx; uuid_t uuid; struct ffa_device *ffa_dev; + struct ffa_dev_part_info *info; struct ffa_partition_info *pbuf, *tpbuf; count = ffa_partition_probe(&uuid_null, &pbuf); @@ -908,6 +968,7 @@ static void ffa_setup_partitions(void) return; } + xa_init(&drv_info->partition_info); for (idx = 0, tpbuf = pbuf; idx < count; idx++, tpbuf++) { import_uuid(&uuid, (u8 *)tpbuf->uuid); @@ -927,10 +988,42 @@ static void ffa_setup_partitions(void) if (drv_info->version > FFA_VERSION_1_0 && !(tpbuf->properties & FFA_PARTITION_AARCH64_EXEC)) ffa_mode_32bit_set(ffa_dev); + + info = kzalloc(sizeof(*info), GFP_KERNEL); + if (!info) { + ffa_device_unregister(ffa_dev); + continue; + } + xa_store(&drv_info->partition_info, tpbuf->id, info, GFP_KERNEL); } + drv_info->partition_count = count; + kfree(pbuf); } +static void ffa_partitions_cleanup(void) +{ + struct ffa_dev_part_info **info; + int idx, count = drv_info->partition_count; + + if (!count) + return; + + info = kcalloc(count, sizeof(**info), GFP_KERNEL); + if (!info) + return; + + xa_extract(&drv_info->partition_info, (void **)info, 0, VM_ID_MASK, + count, XA_PRESENT); + + for (idx = 0; idx < count; idx++) + kfree(info[idx]); + kfree(info); + + drv_info->partition_count = 0; + xa_destroy(&drv_info->partition_info); +} + /* FFA FEATURE IDs */ #define FFA_FEAT_NOTIFICATION_PENDING_INT (1) #define FFA_FEAT_SCHEDULE_RECEIVER_INT (2) @@ -1164,9 +1257,11 @@ static int __init ffa_init(void) ret = ffa_notifications_setup(); if (ret) - goto free_pages; + goto partitions_cleanup; return 0; +partitions_cleanup: + ffa_partitions_cleanup(); free_pages: if (drv_info->tx_buffer) free_pages_exact(drv_info->tx_buffer, RXTX_BUFFER_SIZE); @@ -1182,9 +1277,11 @@ subsys_initcall(ffa_init); static void __exit ffa_exit(void) { ffa_notifications_cleanup(); + ffa_partitions_cleanup(); ffa_rxtx_unmap(drv_info->vm_id); free_pages_exact(drv_info->tx_buffer, RXTX_BUFFER_SIZE); free_pages_exact(drv_info->rx_buffer, RXTX_BUFFER_SIZE); + xa_destroy(&drv_info->partition_info); kfree(drv_info); arm_ffa_bus_exit(); } diff --git a/include/linux/arm_ffa.h b/include/linux/arm_ffa.h index 12fd134bf670..f9cf6114ef82 100644 --- a/include/linux/arm_ffa.h +++ b/include/linux/arm_ffa.h @@ -391,11 +391,19 @@ struct ffa_cpu_ops { int (*run)(struct ffa_device *dev, u16 vcpu); }; +typedef void (*ffa_sched_recv_cb)(u16 vcpu, bool is_per_vcpu, void *cb_data); +struct ffa_notifier_ops { + int (*sched_recv_cb_register)(struct ffa_device *dev, + ffa_sched_recv_cb cb, void *cb_data); + int (*sched_recv_cb_unregister)(struct ffa_device *dev); +}; + struct ffa_ops { const struct ffa_info_ops *info_ops; const struct ffa_msg_ops *msg_ops; const struct ffa_mem_ops *mem_ops; const struct ffa_cpu_ops *cpu_ops; + const struct ffa_notifier_ops *notifier_ops; }; #endif /* _LINUX_ARM_FFA_H */ From patchwork Thu Oct 5 14:45:03 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 148888 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:612c:2016:b0:403:3b70:6f57 with SMTP id fe22csp414305vqb; Thu, 5 Oct 2023 09:22:51 -0700 (PDT) X-Google-Smtp-Source: AGHT+IEWm9wQAUOyhAV4TXYoMU/X8H65RlrWTj79ZpPn82YKAUtLV9xssrQ5d+oyvjQz16Qj0yb9 X-Received: by 2002:a05:6358:990e:b0:143:7949:fb31 with SMTP id w14-20020a056358990e00b001437949fb31mr6046912rwa.7.1696522970423; Thu, 05 Oct 2023 09:22:50 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696522970; cv=none; d=google.com; s=arc-20160816; b=qklriVqZqKw0PqR6M/RVJ7mdtbLXhg6JsmAsyhsVe6dNSq/hryP41Y4KTe431tE3fn e+xgAmT68wS8ehm+oHhM7he/AtP0n67uaJLaVvbKDCMLSGdSXNC4yOKyfZ+8W0+W3Qxh 6IGylncSb5eaV/QdpMzeevWuiiex0n94iVMs7E3/MH3ercQYLUWDf59vPWK/2HGRuKu3 kRcNwTAw4XpfX18rBjDvJuCDnQhwAYqtP8ppqVZ4Wh820/22E11fY5DQlNUBMCAbOmyZ 7xuwleZJdy2Dx1flidTEa8romBpdLfeeNuuE6IdxjvITct1SmahyunQso3XFOowwObOs qL5Q== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:to:in-reply-to:references:message-id :content-transfer-encoding:mime-version:subject:date:from; bh=J+Q8ai8Nzm2/DABj4gMvl6glR7clE9o+e6ZSc4s66c0=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=kHcENRk9Y7yrEYu9aFHbB3E4yKjeCFjIZWFTtrb4QKzwafbWibjsxjPTJ6h7yUmrV3 Yorkjq5grSKM2RZ6wPaD9I/pG+EIXsK3yoikw+UiQUiWWV2Dn5vUkwTRMWyBl9Ar9eUY Ni05DpqNHyFzpP3Ifw8s9nCxDdMw3wM0gg6IAYXOzuJIzFYMBlwaKykJJBpNV3qaW+6m 0Z3Q0MoxdBWNNAsPn2OqYxAti84our7gjf6eLRThsEexDpGjP5Y85pOfG/1Pt77eiL5p Ws0XhWfVbJHck4fJWNZo9gmv3929CPTzjNNf1cIAsmmAlQmo2MmqVVGFhy6WZcvMg0YQ F8zQ== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:7 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from snail.vger.email (snail.vger.email. [2620:137:e000::3:7]) by mx.google.com with ESMTPS id a21-20020a63e855000000b00557531eafb0si1663499pgk.559.2023.10.05.09.22.50 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 05 Oct 2023 09:22:50 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:7 as permitted sender) client-ip=2620:137:e000::3:7; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:7 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from out1.vger.email (depot.vger.email [IPv6:2620:137:e000::3:0]) by snail.vger.email (Postfix) with ESMTP id 9D2BE831DBC2; Thu, 5 Oct 2023 09:22:49 -0700 (PDT) X-Virus-Status: Clean X-Virus-Scanned: clamav-milter 0.103.10 at snail.vger.email Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S243029AbjJEQWU (ORCPT + 19 others); Thu, 5 Oct 2023 12:22:20 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:36426 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241449AbjJEQQJ (ORCPT ); Thu, 5 Oct 2023 12:16:09 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id E14C61FEF9 for ; Thu, 5 Oct 2023 07:45:41 -0700 (PDT) Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 8B57F1596; Thu, 5 Oct 2023 07:45:59 -0700 (PDT) Received: from e103737-lin.cambridge.arm.com (e103737-lin.cambridge.arm.com [10.1.197.49]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id D53253F641; Thu, 5 Oct 2023 07:45:19 -0700 (PDT) From: Sudeep Holla Date: Thu, 05 Oct 2023 15:45:03 +0100 Subject: [PATCH v4 10/17] firmware: arm_ffa: Add interfaces to request notification callbacks MIME-Version: 1.0 Message-Id: <20231005-ffa_v1-1_notif-v4-10-cddd3237809c@arm.com> References: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> In-Reply-To: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> To: linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Sudeep Holla , Marc Bonnici , Jens Wiklander , Coboy Chen , Lorenzo Pieralisi , Olivier Deprez X-Mailer: b4 0.12.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=6943; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=jS9ZlPVRWP8/Wp7yswbAzCodeaTe0yPLbi3t5Cfh9Ag=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlHsvxxToFsUAseBZwM6KJxyCdYs3fXrYhfoBev HCeQCsEg1mJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZR7L8QAKCRAAQbq8MX7i mNK6EACWTqIstipLTxGSmcoa6S6ckNRC7YGl/dzKaA1U1CN4NJlnY7c3ndXCz5pXlEa4dYM/qS0 jRxaMokUoAM+oTzQ7oHpHcsbwV+U94b7PZUf8LE43zwDehpCDOVZiUw+JG3P8TqWZHHvyJ1uKWi twxvwIdASgc+QLTKMBsFqccxnZaHifF4CefM40n+vllCJCxHNPJNdniQkgNdHQafj5059JAavWj //Rv28k+dZJFGRpOpjhleRQdTJzCKQljD15ayt5RgeLeiusqE3wFRak8Nlht2+DrgDzaLNQHX8o Rnf61LLiBqlGbwpa73pFUY1jbHWkhsX2KXCGUs+PvVw+Kkwun+mkzF0wmC/u4Pq1J9hxKnoR+/q rcu0UJ/bz961gkivXmEmB4rxsxgZRZHcdJvXxftpVOKft4eMWhZjmOcV7vx+//W7Q0yOHl3sMoI pex2Bh/FzNT9tHCikz7PHQEcLbNGpDmTy0O/w4HfcslvVVmORIrWb8oysRawD/Q0IOHeZJS2JQr qAYdTBJjDKZJhQ0uwJYOyF/URnhCcfE97aSQ4UhrSQ80ls54ZTnMYJR0nE3gDe5z9jB/xIJ56Oe eoNYe6U5TjkGeqs3WWmwsh3coiR2lAL3EQCD+TVYeafWSwnQk8y/2tTnnoE0nBXcd//xg/b0yCW cIMJ8icGIGdFEsg== X-Developer-Key: i=sudeep.holla@arm.com; a=openpgp; fpr=7360A21742ADF5A11767C1C139CFD4755FE2D5B4 X-Spam-Status: No, score=-4.2 required=5.0 tests=BAYES_00,RCVD_IN_DNSWL_MED, SPF_HELO_NONE,SPF_NONE 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-Greylist: Sender passed SPF test, not delayed by milter-greylist-4.6.4 (snail.vger.email [0.0.0.0]); Thu, 05 Oct 2023 09:22:49 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778933270199654361 X-GMAIL-MSGID: 1778933270199654361 Add interface to the FFA driver to allow for client drivers to request and relinquish a notification as well as provide a callback for the notification. Signed-off-by: Sudeep Holla --- drivers/firmware/arm_ffa/driver.c | 145 ++++++++++++++++++++++++++++++++++++++ include/linux/arm_ffa.h | 5 ++ 2 files changed, 150 insertions(+) diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c index 04cdb49cc78b..fc8b29648fb2 100644 --- a/drivers/firmware/arm_ffa/driver.c +++ b/drivers/firmware/arm_ffa/driver.c @@ -27,11 +27,13 @@ #include #include #include +#include #include #include #include #include #include +#include #include #include #include @@ -57,6 +59,8 @@ */ #define RXTX_BUFFER_SIZE SZ_4K +#define FFA_MAX_NOTIFICATIONS 64 + static ffa_fn *invoke_ffa_fn; static const int ffa_linux_errmap[] = { @@ -102,6 +106,8 @@ struct ffa_drv_info { struct work_struct irq_work; struct xarray partition_info; unsigned int partition_count; + DECLARE_HASHTABLE(notifier_hash, ilog2(FFA_MAX_NOTIFICATIONS)); + struct mutex notify_lock; /* lock to protect notifier hashtable */ }; static struct ffa_drv_info *drv_info; @@ -626,6 +632,8 @@ static int ffa_notification_bitmap_destroy(void) #define MAX_IDS_64 20 #define MAX_IDS_32 10 +#define PER_VCPU_NOTIFICATION_FLAG BIT(0) + static int ffa_notification_bind_common(u16 dst_id, u64 bitmap, u32 flags, bool is_bind) { @@ -865,6 +873,21 @@ static int ffa_memory_lend(struct ffa_mem_ops_args *args) return ffa_memory_ops(FFA_MEM_LEND, args); } +#define FFA_SECURE_PARTITION_ID_FLAG BIT(15) + +enum notify_type { + NON_SECURE_VM, + SECURE_PARTITION, + FRAMEWORK, +}; + +struct notifier_cb_info { + struct hlist_node hnode; + ffa_notifier_cb cb; + void *cb_data; + enum notify_type type; +}; + static int ffa_sched_recv_cb_update(u16 part_id, ffa_sched_recv_cb callback, void *cb_data, bool is_registration) { @@ -898,6 +921,123 @@ static int ffa_sched_recv_cb_unregister(struct ffa_device *dev) return ffa_sched_recv_cb_update(dev->vm_id, NULL, NULL, false); } +static int ffa_notification_bind(u16 dst_id, u64 bitmap, u32 flags) +{ + return ffa_notification_bind_common(dst_id, bitmap, flags, true); +} + +static int ffa_notification_unbind(u16 dst_id, u64 bitmap) +{ + return ffa_notification_bind_common(dst_id, bitmap, 0, false); +} + +/* Should be called while the notify_lock is taken */ +static struct notifier_cb_info * +notifier_hash_node_get(u16 notify_id, enum notify_type type) +{ + struct notifier_cb_info *node; + + hash_for_each_possible(drv_info->notifier_hash, node, hnode, notify_id) + if (type == node->type) + return node; + + return NULL; +} + +static int +update_notifier_cb(int notify_id, enum notify_type type, ffa_notifier_cb cb, + void *cb_data, bool is_registration) +{ + struct notifier_cb_info *cb_info = NULL; + bool cb_found; + + cb_info = notifier_hash_node_get(notify_id, type); + cb_found = !!cb_info; + + if (!(is_registration ^ cb_found)) + return -EINVAL; + + if (is_registration) { + cb_info = kzalloc(sizeof(*cb_info), GFP_KERNEL); + if (!cb_info) + return -ENOMEM; + + cb_info->type = type; + cb_info->cb = cb; + cb_info->cb_data = cb_data; + + hash_add(drv_info->notifier_hash, &cb_info->hnode, notify_id); + } else { + hash_del(&cb_info->hnode); + } + + return 0; +} + +static enum notify_type ffa_notify_type_get(u16 vm_id) +{ + if (vm_id & FFA_SECURE_PARTITION_ID_FLAG) + return SECURE_PARTITION; + else + return NON_SECURE_VM; +} + +static int ffa_notify_relinquish(struct ffa_device *dev, int notify_id) +{ + int rc; + enum notify_type type = ffa_notify_type_get(dev->vm_id); + + if (notify_id >= FFA_MAX_NOTIFICATIONS) + return -EINVAL; + + mutex_lock(&drv_info->notify_lock); + + rc = update_notifier_cb(notify_id, type, NULL, NULL, false); + if (rc) { + pr_err("Could not unregister notifcation callback\n"); + mutex_unlock(&drv_info->notify_lock); + return rc; + } + + rc = ffa_notification_unbind(dev->vm_id, BIT(notify_id)); + + mutex_unlock(&drv_info->notify_lock); + + return rc; +} + +static int ffa_notify_request(struct ffa_device *dev, bool is_per_vcpu, + ffa_notifier_cb cb, void *cb_data, int notify_id) +{ + int rc; + u32 flags = 0; + enum notify_type type = ffa_notify_type_get(dev->vm_id); + + if (notify_id >= FFA_MAX_NOTIFICATIONS) + return -EINVAL; + + mutex_lock(&drv_info->notify_lock); + + if (is_per_vcpu) + flags = PER_VCPU_NOTIFICATION_FLAG; + + rc = ffa_notification_bind(dev->vm_id, BIT(notify_id), flags); + if (rc) { + mutex_unlock(&drv_info->notify_lock); + return rc; + } + + rc = update_notifier_cb(notify_id, type, cb, cb_data, true); + if (rc) { + pr_err("Failed to register callback for %d - %d\n", + notify_id, rc); + ffa_notification_unbind(dev->vm_id, BIT(notify_id)); + } + mutex_unlock(&drv_info->notify_lock); + + return rc; +} + static const struct ffa_info_ops ffa_drv_info_ops = { .api_version_get = ffa_api_version_get, .partition_info_get = ffa_partition_info_get, @@ -921,6 +1061,8 @@ static const struct ffa_cpu_ops ffa_drv_cpu_ops = { static const struct ffa_notifier_ops ffa_drv_notifier_ops = { .sched_recv_cb_register = ffa_sched_recv_cb_register, .sched_recv_cb_unregister = ffa_sched_recv_cb_unregister, + .notify_request = ffa_notify_request, + .notify_relinquish = ffa_notify_relinquish, }; static const struct ffa_ops ffa_drv_ops = { @@ -1194,6 +1336,9 @@ static int ffa_notifications_setup(void) if (ret) goto cleanup; + hash_init(drv_info->notifier_hash); + mutex_init(&drv_info->notify_lock); + return 0; cleanup: ffa_notifications_cleanup(); diff --git a/include/linux/arm_ffa.h b/include/linux/arm_ffa.h index f9cf6114ef82..fb6f388a3737 100644 --- a/include/linux/arm_ffa.h +++ b/include/linux/arm_ffa.h @@ -392,10 +392,15 @@ struct ffa_cpu_ops { }; typedef void (*ffa_sched_recv_cb)(u16 vcpu, bool is_per_vcpu, void *cb_data); +typedef void (*ffa_notifier_cb)(int notify_id, void *cb_data); + struct ffa_notifier_ops { int (*sched_recv_cb_register)(struct ffa_device *dev, ffa_sched_recv_cb cb, void *cb_data); int (*sched_recv_cb_unregister)(struct ffa_device *dev); + int (*notify_request)(struct ffa_device *dev, bool per_vcpu, + ffa_notifier_cb cb, void *cb_data, int notify_id); + int (*notify_relinquish)(struct ffa_device *dev, int notify_id); }; struct ffa_ops { From patchwork Thu Oct 5 14:45:04 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 148810 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:612c:2016:b0:403:3b70:6f57 with SMTP id fe22csp376390vqb; Thu, 5 Oct 2023 08:26:58 -0700 (PDT) X-Google-Smtp-Source: AGHT+IEFdCPB/ZY8f+Jr7YgeCnk3Naa5eo8ZUrFqLM2wPSlU7RKBt6sLmbRi4xVeLdi9y1/21x7W X-Received: by 2002:a05:6e02:11a7:b0:34f:70ec:d4cf with SMTP id 7-20020a056e0211a700b0034f70ecd4cfmr4679512ilj.8.1696519618388; Thu, 05 Oct 2023 08:26:58 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696519618; cv=none; d=google.com; s=arc-20160816; b=jM/p51AqApYDcWnUXOlsetIhkZy8oM924JWc5wzX1Wt9DMCd5lmYcFzkSUBzyAyWdd oZkvhaKigoVTPMQkmAgmBMdpFelQwqX+EaJn1XYsnnvB6JAD/GaRSo5g/zCR1u8dzBjP 7hoFlP3/4CZl9n3m1U8X4jM13vF6+vL7JPKmiNq8YJJ5sNVyhC5vzzV6LbpAoK6525k0 jjytOlRnCSkt1DlGRM0nL2qKQLJ5OC5WH0/jvvDaUwlO2W3AV/DDA3LW8Mq0yz8Dsw5y pZiWs4dtvVngV2Q5znabnWcUWUYIbupXsa+CUs8OR3s1oHUBnL0+/WvXFoKiGgwoXYU4 Ydtw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:to:in-reply-to:references:message-id :content-transfer-encoding:mime-version:subject:date:from; bh=6My5bqecxNTueLzOj+6NvNqEGcEqOFaRnp0sFMR9AbU=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=MIwmCA8L4gsLONehT55BSTGyAnCcY4pm6qoJEiyG12bdivRdE/+xrgwKmvHxlpREZy Q0BXFwt4UC5wR+ajVikG0IlMKijmV0i4dUs88Jd3wHuUPixN37w7IIKpqf4Efl6i8kEU wZauqPnBtsLFEMPifMGlJsHVm42NWDlpb+aeg9MNnaaYYbJTP15+W2yCmwF4tzfaCVvg e+6dDTMKB55MrQAQxmPscNkPn/WBICk3qqZ+5mw8UHmPmiXKV8QZPRrgStNVnJFx91ud e+vcd19Yf2yZKrWuauAD6rk9AodjbkEneB5PWvfPS9ShzCL6KeR2odbrUQvALsxWUZEN IpeA== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:6 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from pete.vger.email (pete.vger.email. [2620:137:e000::3:6]) by mx.google.com with ESMTPS id z16-20020a656650000000b00565e01815f2si1611855pgv.732.2023.10.05.08.26.58 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 05 Oct 2023 08:26:58 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:6 as permitted sender) client-ip=2620:137:e000::3:6; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:6 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from out1.vger.email (depot.vger.email [IPv6:2620:137:e000::3:0]) by pete.vger.email (Postfix) with ESMTP id DD948801C237; Thu, 5 Oct 2023 08:26:55 -0700 (PDT) X-Virus-Status: Clean X-Virus-Scanned: clamav-milter 0.103.10 at pete.vger.email Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231586AbjJEPZh (ORCPT + 19 others); Thu, 5 Oct 2023 11:25:37 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:41286 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232562AbjJEPZA (ORCPT ); Thu, 5 Oct 2023 11:25:00 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id DC1773852 for ; Thu, 5 Oct 2023 07:45:41 -0700 (PDT) Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id BD3F515A1; Thu, 5 Oct 2023 07:46:00 -0700 (PDT) Received: from e103737-lin.cambridge.arm.com (e103737-lin.cambridge.arm.com [10.1.197.49]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 131023F641; Thu, 5 Oct 2023 07:45:20 -0700 (PDT) From: Sudeep Holla Date: Thu, 05 Oct 2023 15:45:04 +0100 Subject: [PATCH v4 11/17] firmware: arm_ffa: Add interface to send a notification to a given partition MIME-Version: 1.0 Message-Id: <20231005-ffa_v1-1_notif-v4-11-cddd3237809c@arm.com> References: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> In-Reply-To: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> To: linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Sudeep Holla , Marc Bonnici , Jens Wiklander , Coboy Chen , Lorenzo Pieralisi , Olivier Deprez X-Mailer: b4 0.12.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=2181; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=iR7xv4zWGKiCOfOTUrWKzr2y6gNM1XQTF7Jjqnppvvw=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlHsvyUa0kf0qaS0e9Fg2dVQkQFVfR5hK3IAhDQ 3s8+Y7UIlyJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZR7L8gAKCRAAQbq8MX7i mCgED/91RGR3wwqUHgbGtWvWw4cfovaRPFwuGja8Cj4hR3egB3+yLDr+TPgjf+wHVIK/ZEs5HFw 0R+5bItjUQwwU7Y80SQYiSM9FkybAD3kZB1FBRsTl6beRCGLrJ0CklF1pPVOdF5XsSnbRLWhKx0 jBnxfrKRfPVqjsfN5Yi5f6ULO440sAzg8cg7JtIJWr90zNlP73H+zJ6vXquz6TmeCyi77JF+FST yzN+4c8CE8gJf4IhWYCbkNp/nNnNCPjGngtU1+u5h7KLbgThhnTJ8FILeuE+4wIvQo5ZsJCgG63 bhvLgyIXKeDemXY8cE7Nyjkz2P+sx+1aE5WPUTY+mFTn/3ghi1A1bQj0Ve+k2H/QCzFFNHzxtya SLhDDj8FntmyY0B4LG3jPV2AXUXUduTzRZPXHGrylpLBphhEyfFDfzFZ+zvJNGsQdSOOPGEnZqH FaAjTBLfPr5z430rzOETAznr6tmCsDwG9i+19z9Tar98vh0XO4SwrMAxqy8VffZtydzvMIsVqPK 4gVugFVckzfTH7qK/TMMsOI3slkz/eVg/3pDovmx90tjBpkDd5E5nSHTQlD5oQ3GjGEcnDWYbCV W2Q6S68e32v6eQhNtRb7Ee5LN6Q4hANzyQg8lkVcWi+i0burck21d8HG7I7T+XIFwSDbCqD4QeZ EMS66X/ci5BMM5g== X-Developer-Key: i=sudeep.holla@arm.com; a=openpgp; fpr=7360A21742ADF5A11767C1C139CFD4755FE2D5B4 X-Spam-Status: No, score=-0.8 required=5.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS autolearn=unavailable autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on pete.vger.email Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-Greylist: Sender passed SPF test, not delayed by milter-greylist-4.6.4 (pete.vger.email [0.0.0.0]); Thu, 05 Oct 2023 08:26:55 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778929755254657056 X-GMAIL-MSGID: 1778929755254657056 The framework provides an interface to the sender endpoint to specify the notification to signal to the receiver endpoint. A sender signals a notification by requesting its partition manager to set the corresponding bit in the notifications bitmap of the receiver. Expose the ability to send a notification to another partition. Signed-off-by: Sudeep Holla --- drivers/firmware/arm_ffa/driver.c | 13 +++++++++++++ include/linux/arm_ffa.h | 2 ++ 2 files changed, 15 insertions(+) diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c index fc8b29648fb2..2a46052a280a 100644 --- a/drivers/firmware/arm_ffa/driver.c +++ b/drivers/firmware/arm_ffa/driver.c @@ -1038,6 +1038,18 @@ static int ffa_notify_request(struct ffa_device *dev, bool is_per_vcpu, return rc; } +static int ffa_notify_send(struct ffa_device *dev, int notify_id, + bool is_per_vcpu, u16 vcpu) +{ + u32 flags = 0; + + if (is_per_vcpu) + flags |= (PER_VCPU_NOTIFICATION_FLAG | vcpu << 16); + + return ffa_notification_set(dev->vm_id, drv_info->vm_id, flags, + BIT(notify_id)); +} + static const struct ffa_info_ops ffa_drv_info_ops = { .api_version_get = ffa_api_version_get, .partition_info_get = ffa_partition_info_get, @@ -1063,6 +1075,7 @@ static const struct ffa_notifier_ops ffa_drv_notifier_ops = { .sched_recv_cb_unregister = ffa_sched_recv_cb_unregister, .notify_request = ffa_notify_request, .notify_relinquish = ffa_notify_relinquish, + .notify_send = ffa_notify_send, }; static const struct ffa_ops ffa_drv_ops = { diff --git a/include/linux/arm_ffa.h b/include/linux/arm_ffa.h index fb6f388a3737..f6df81f14b6d 100644 --- a/include/linux/arm_ffa.h +++ b/include/linux/arm_ffa.h @@ -401,6 +401,8 @@ struct ffa_notifier_ops { int (*notify_request)(struct ffa_device *dev, bool per_vcpu, ffa_notifier_cb cb, void *cb_data, int notify_id); int (*notify_relinquish)(struct ffa_device *dev, int notify_id); + int (*notify_send)(struct ffa_device *dev, int notify_id, bool per_vcpu, + u16 vcpu); }; struct ffa_ops { From patchwork Thu Oct 5 14:45:05 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 148848 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:612c:2016:b0:403:3b70:6f57 with SMTP id fe22csp402898vqb; Thu, 5 Oct 2023 09:06:14 -0700 (PDT) X-Google-Smtp-Source: AGHT+IGeVJ00vmuamBXSXeTtVpF+oEONeIXnFcHhnHli9TCpno5GT7MGSEao7KV2kq3MrPgxGFz7 X-Received: by 2002:a05:6a20:1455:b0:10f:be0:4dce with SMTP id a21-20020a056a20145500b0010f0be04dcemr6812403pzi.8.1696521973764; Thu, 05 Oct 2023 09:06:13 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696521973; cv=none; d=google.com; s=arc-20160816; b=dyswgg2KB3lXKnnNQzdxpgPfUUSKg6grDY7Rw4JVxfctL3TdLj/kkg2IdXA1V0L191 e28CRuAV5+PN8NeEm5oOxeIcebx8n32ROlW6EWMmo5MeIFZwt1ASqkF7P80BI2OKfXyG vHJXs+sN6kSdewnOHm0j2mX3NLNRZVi8/Vew3UezUHBcG0Ad6L4Bgucp54cJTch5lM0H 856HVZ9tWBlDIXbbJABN56qJpmUCA0RidOMDO1lTPLUf3ZXuWDEJTkn7jeap1QH+nJaS b1J4dc6EHwJ7aVe82Ccxd5mFbm7CrwXv5ZMA2oecmauAqQZRXQGnnlnYWURi0USlMCPu VrCw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:to:in-reply-to:references:message-id :content-transfer-encoding:mime-version:subject:date:from; bh=1Tej/oSIM4q8imhxcbJ4qMQhc/238IuIJQNEoEZVMM0=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=0lwKLmMgjzu0mCPFHVB9sejxAoaiVPazPXfv8rklrSuSJv///7aR/3qwtUSBvpkdrJ vCZduaOn0SRy4+MFbSvrFG30OkYr5sZ7bE9Q5IK4VrCwZNJii8j7AL7O9Ze5Isap2CKs UhQ+vGaOPhv9xvDRMWR6f1om+GzvObQi3WZwmvc8b+ERNTEsh2WphdS0ppDA4zN4SEkH CA+VS/uS60GtThKUD6AbmoWZjMV7i7PL6Ls8UD8iEYt2XVbSR6WzNx98/3447INWNLP4 IksGMju2LAVAjaNr6q5qt+Jb45Teyi/RZfMsivMTvU2uXbtjRsjZDWOwWkQsymHvLeun ZwMg== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:7 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from snail.vger.email (snail.vger.email. [2620:137:e000::3:7]) by mx.google.com with ESMTPS id s7-20020a635e07000000b00577475ee5f6si1657418pgb.618.2023.10.05.09.06.13 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 05 Oct 2023 09:06:13 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:7 as permitted sender) client-ip=2620:137:e000::3:7; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:7 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from out1.vger.email (depot.vger.email [IPv6:2620:137:e000::3:0]) by snail.vger.email (Postfix) with ESMTP id BFED382E753A; Thu, 5 Oct 2023 09:05:30 -0700 (PDT) X-Virus-Status: Clean X-Virus-Scanned: clamav-milter 0.103.10 at snail.vger.email Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S239895AbjJEQFO (ORCPT + 19 others); Thu, 5 Oct 2023 12:05:14 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34026 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234700AbjJEQDY (ORCPT ); Thu, 5 Oct 2023 12:03:24 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id CC52618BBF for ; Thu, 5 Oct 2023 07:45:41 -0700 (PDT) Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 46ABB15BF; Thu, 5 Oct 2023 07:46:02 -0700 (PDT) Received: from e103737-lin.cambridge.arm.com (e103737-lin.cambridge.arm.com [10.1.197.49]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 44F8C3F641; Thu, 5 Oct 2023 07:45:22 -0700 (PDT) From: Sudeep Holla Date: Thu, 05 Oct 2023 15:45:05 +0100 Subject: [PATCH v4 12/17] firmware: arm_ffa: Add notification handling mechanism MIME-Version: 1.0 Message-Id: <20231005-ffa_v1-1_notif-v4-12-cddd3237809c@arm.com> References: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> In-Reply-To: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> To: linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Sudeep Holla , Marc Bonnici , Jens Wiklander , Coboy Chen , Lorenzo Pieralisi , Olivier Deprez X-Mailer: b4 0.12.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=4050; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=GHIh6ClSLWjbfe+dbK9XBffuB6q16AXPdqCkeJlcuXE=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlHsvypoEExryuzL9TlqjKcrV/X62vuDwcXQGTN A+YUdxhg4qJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZR7L8gAKCRAAQbq8MX7i mDeFD/901XcmtIPEPA/bjc45RGEcElECvD2xcHIFEzydP8tYoOD68Z5I43vLBDzveQ95360VKDl wUCNdHj3d7NQ9xgrv1G/kSlyMdkt4H4DiNzIq/Z/0K6lxJD1RirhRlOUqdJQ6/MYzF5GCC29FEl XfcURhAXY2q1T6yrH8yz7N5fOfi+18MO11iKs/twtwb+6nCqznoCue4sBefC4ewqrAu/8fdh3aQ NFvgRgh2Ih1GiLUzjDO9nWDycMdMcra78eosR46uOydc3d0oOi6sus0JZUlBkU/w80cOOo1bsNk iEmkw6kMBugHB+npBBNVZgRRJKEfRIxoKjfP3LzRS8voe0KyhJdYutOF28Addnf818VFjtugfuG O+vNfJ1rSZPCXpBDFFXvMn7YK9dW6ZP5pLcgQTaHZI/njc9Sv88KQpCn99vd1GpPQB3h29lDf+j 7q3I2Ow5Dr+6I95FjWndkgBbhAPXcqttaqi7jNauOCEFsX3L8SQi+7tcthh0ZjhcsNa2pt1+PpM bIQqnPe07SMzI0aSRRwTlhvb1cVgJIINcHQy7XYLmOQw9R3sDJIOAgiDc9nkHa4GLQwSTrFNsw2 Ziq0cuX0y74ADM8wE537ofiX7S3BpGkJVAUne4Az9iUU+92cHHRC1UIOYUote06csWz8r5DFVz7 kCWTo3GBnqxNAFg== X-Developer-Key: i=sudeep.holla@arm.com; a=openpgp; fpr=7360A21742ADF5A11767C1C139CFD4755FE2D5B4 X-Spam-Status: No, score=-4.2 required=5.0 tests=BAYES_00,RCVD_IN_DNSWL_MED, SPF_HELO_NONE,SPF_NONE 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-Greylist: Sender passed SPF test, not delayed by milter-greylist-4.6.4 (snail.vger.email [0.0.0.0]); Thu, 05 Oct 2023 09:05:30 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778932225145971627 X-GMAIL-MSGID: 1778932225145971627 With all the necessary plumbing in place, let us add handling the notifications as part of schedule receiver interrupt handler. In order to do so, we need to just register scheduling callback on behalf of the driver partition. Signed-off-by: Sudeep Holla --- drivers/firmware/arm_ffa/driver.c | 67 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 66 insertions(+), 1 deletion(-) diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c index 2a46052a280a..9dd5335001ee 100644 --- a/drivers/firmware/arm_ffa/driver.c +++ b/drivers/firmware/arm_ffa/driver.c @@ -103,6 +103,7 @@ struct ffa_drv_info { unsigned int cpuhp_state; struct ffa_pcpu_irq __percpu *irq_pcpu; struct workqueue_struct *notif_pcpu_wq; + struct work_struct notif_pcpu_work; struct work_struct irq_work; struct xarray partition_info; unsigned int partition_count; @@ -633,6 +634,10 @@ static int ffa_notification_bitmap_destroy(void) #define MAX_IDS_32 10 #define PER_VCPU_NOTIFICATION_FLAG BIT(0) +#define SECURE_PARTITION_BITMAP BIT(0) +#define NON_SECURE_VM_BITMAP BIT(1) +#define SPM_FRAMEWORK_BITMAP BIT(2) +#define NS_HYP_FRAMEWORK_BITMAP BIT(3) static int ffa_notification_bind_common(u16 dst_id, u64 bitmap, u32 flags, bool is_bind) @@ -1050,6 +1055,54 @@ static int ffa_notify_send(struct ffa_device *dev, int notify_id, BIT(notify_id)); } +static void handle_notif_callbacks(u64 bitmap, enum notify_type type) +{ + int notify_id; + struct notifier_cb_info *cb_info = NULL; + + for (notify_id = 0; notify_id <= FFA_MAX_NOTIFICATIONS && bitmap; + notify_id++, bitmap >>= 1) { + if (!(bitmap & 1)) + continue; + + mutex_lock(&drv_info->notify_lock); + cb_info = notifier_hash_node_get(notify_id, type); + mutex_unlock(&drv_info->notify_lock); + + if (cb_info && cb_info->cb) + cb_info->cb(notify_id, cb_info->cb_data); + } +} + +static void notif_pcpu_irq_work_fn(struct work_struct *work) +{ + int rc; + struct ffa_notify_bitmaps bitmaps; + + rc = ffa_notification_get(SECURE_PARTITION_BITMAP | + SPM_FRAMEWORK_BITMAP, &bitmaps); + if (rc) { + pr_err("Failed to retrieve notifications with %d!\n", rc); + return; + } + + handle_notif_callbacks(bitmaps.vm_map, NON_SECURE_VM); + handle_notif_callbacks(bitmaps.sp_map, SECURE_PARTITION); + handle_notif_callbacks(bitmaps.arch_map, FRAMEWORK); +} + +static void +ffa_self_notif_handle(u16 vcpu, bool is_per_vcpu, void *cb_data) +{ + struct ffa_drv_info *info = cb_data; + + if (!is_per_vcpu) + notif_pcpu_irq_work_fn(&info->notif_pcpu_work); + else + queue_work_on(vcpu, info->notif_pcpu_wq, + &info->notif_pcpu_work); +} + static const struct ffa_info_ops ffa_drv_info_ops = { .api_version_get = ffa_api_version_get, .partition_info_get = ffa_partition_info_get, @@ -1154,6 +1207,13 @@ static void ffa_setup_partitions(void) drv_info->partition_count = count; kfree(pbuf); + + /* Allocate for the host */ + info = kzalloc(sizeof(*info), GFP_KERNEL); + if (!info) + return; + xa_store(&drv_info->partition_info, drv_info->vm_id, info, GFP_KERNEL); + drv_info->partition_count++; } static void ffa_partitions_cleanup(void) @@ -1294,6 +1354,7 @@ static int ffa_init_pcpu_irq(unsigned int irq) } INIT_WORK(&drv_info->irq_work, ffa_sched_recv_irq_work_fn); + INIT_WORK(&drv_info->notif_pcpu_work, notif_pcpu_irq_work_fn); drv_info->notif_pcpu_wq = create_workqueue("ffa_pcpu_irq_notification"); if (!drv_info->notif_pcpu_wq) return -EINVAL; @@ -1352,7 +1413,11 @@ static int ffa_notifications_setup(void) hash_init(drv_info->notifier_hash); mutex_init(&drv_info->notify_lock); - return 0; + /* Register internal scheduling callback */ + ret = ffa_sched_recv_cb_update(drv_info->vm_id, ffa_self_notif_handle, + drv_info, true); + if (!ret) + return ret; cleanup: ffa_notifications_cleanup(); return ret; From patchwork Thu Oct 5 14:45:06 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 148805 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:612c:2016:b0:403:3b70:6f57 with SMTP id fe22csp374196vqb; Thu, 5 Oct 2023 08:23:35 -0700 (PDT) X-Google-Smtp-Source: AGHT+IG4nVFP9T9N8rgUJUMc2CKzZ5xW+nQ+Ep2RqsbWvDKD0IU+EjgbQRRFoHAsX4NZpoLdrWRT X-Received: by 2002:a05:6a21:789c:b0:15c:b7ba:e8e0 with SMTP id bf28-20020a056a21789c00b0015cb7bae8e0mr6254660pzc.51.1696519415638; Thu, 05 Oct 2023 08:23:35 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696519415; cv=none; d=google.com; s=arc-20160816; b=rYlgCDaIlrwrj5KWdti9o5X3N3BCwoFOMBl1+XTlSwdDQ8Qo/EcvtAn63OdbgIyURq cIb/Dn2qwUO12rdb+6L4DlVdew/vXxA955wtOHCPAtYjfHB1SqDBwWMNyH89O6AvseWc KIJhkVz0PzPrcHMMBSbOZXCM3Z/7vV91Jh8Fk7vVTTN1GONTKNIwjxO2MSsnhLTLUuFY sQUFVvjW2XXNluZlAerTbyjsRugts55J1eGP8ZyZHCn74xwHyjbJNwwaYTc5PDxS6Bfa F65+2vQ8V9/XKip1iZCZGwoOu/XL2NcMuQgHEixZLBGwBerbXophwJzGduXPtvCmCnM9 y1yg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:to:in-reply-to:references:message-id :content-transfer-encoding:mime-version:subject:date:from; bh=dggiQkkiE7oT7S/kWnOv92tsKaKhAJ7nP/SKyEkwZxs=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=f2SMJ0MvTY+v2qTKMc+5Ywf2qbKLdhH3MOuCat6YZr99tsO8djOybC1CGKmCAu1U/v vbzK4YSAp2GUddTBD6hzkd4rff/l5Noeep1D3xcRepmxDnDYtk6OrSOhi6sWyB68C/bh cIIWnDk0HB8smoVMbse8qvKMc5sEMd7jSh56S95Tzshb9/C5khca8/dvXIxPtybgilRy 3s/nKzWMS6pCwiICVKZ6qIiyWR71nVa6jvEqB3dgqOlnpY1viKeC9EPYk0i6LBoWu876 pJWfwcvVLH87kn5eJz/9wjxGu43W1spkiVfu3zaGbAe59KsOI6alxfR15mTI0tYRbfMX oEqQ== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.34 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from howler.vger.email (howler.vger.email. [23.128.96.34]) by mx.google.com with ESMTPS id u15-20020a170903124f00b001c60e273252si1725002plh.25.2023.10.05.08.23.35 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 05 Oct 2023 08:23:35 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.34 as permitted sender) client-ip=23.128.96.34; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.34 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from out1.vger.email (depot.vger.email [IPv6:2620:137:e000::3:0]) by howler.vger.email (Postfix) with ESMTP id 5F8CB80AEE14; Thu, 5 Oct 2023 08:22:13 -0700 (PDT) X-Virus-Status: Clean X-Virus-Scanned: clamav-milter 0.103.10 at howler.vger.email Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232538AbjJEPVz (ORCPT + 19 others); Thu, 5 Oct 2023 11:21:55 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42796 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233578AbjJEPVF (ORCPT ); Thu, 5 Oct 2023 11:21:05 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id 759FD21345 for ; Thu, 5 Oct 2023 07:45:44 -0700 (PDT) Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 2CB7015DB; Thu, 5 Oct 2023 07:46:03 -0700 (PDT) Received: from e103737-lin.cambridge.arm.com (e103737-lin.cambridge.arm.com [10.1.197.49]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 76BCC3F8A4; Thu, 5 Oct 2023 07:45:23 -0700 (PDT) From: Sudeep Holla Date: Thu, 05 Oct 2023 15:45:06 +0100 Subject: [PATCH v4 13/17] firmware: arm_ffa: Simplify the computation of transmit and fragment length MIME-Version: 1.0 Message-Id: <20231005-ffa_v1-1_notif-v4-13-cddd3237809c@arm.com> References: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> In-Reply-To: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> To: linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Sudeep Holla , Marc Bonnici , Jens Wiklander , Coboy Chen , Lorenzo Pieralisi , Olivier Deprez X-Mailer: b4 0.12.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=3428; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=Bk/KguDz+Pa9YD44dR4bVtd5OHjZzTqIACMhi/OAstc=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlHsvy54FhXD9M3/xGz2SYo5UUiWjBKhS/CrOYm DIteIRcWumJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZR7L8gAKCRAAQbq8MX7i mJxdD/9iwVr+502At7oyF6Lgr+0lSTlhDAKQPpxK5BQ3baVM+bFBNobUFInNlj4NHXerZu82j3u ErROcKLWnk9PtI4ZeGC7Lr6vWIHhPPlsQjXVc2RoZhtJh5pVTyixbZwLDNeshdpAlgs3f0Fd9EK uK4oJAsfkM6R7uqO1BqUVv1B2xPk257JdObrqFBe1mY7lBmw+IqM+0CmFsCFia6P2jdK8NeDxxo ETqyQEn//VvVBATcDvvneF6jQfgaTiwU6U81lmkLOJpB0n1k6aYRqbAnhWNdwOByUWKIY9uNJKU GmSjN3IAPeGmqLaOTvZlXeLP6lgTIss3G6PNJ1lJChuyaHGhGWBE5BGT2mWtKzSPpXajXWrYKEP Um/zAnMG1FByBEGqopm0WfTI0XzJk3+w9KmnKPwsJxERVNcZwBZVifBHo4xuZpY79zHo2IZuIPS 86omoq3ypaNfWSJepmqd5DDWM/jP6/eCRvwVkB2qx4iGjCYz6Do0+ERW/AtwYI3/Lj+nnc98wWy 2incga0kZXWdQad2zcil4HEd5OrT7t2CNfLc6SG+pK4baDf7hwgca3ZMUpKCcRp3MZKaT3DJw7H S8g6D1fojvvMJSQBIuYqs57qtiOrt9P90hVO4p6ARwna608lqxgqOHpB8Ls2foVseWQLDkVaypN A7hJTpnH2aldgpw== X-Developer-Key: i=sudeep.holla@arm.com; a=openpgp; fpr=7360A21742ADF5A11767C1C139CFD4755FE2D5B4 X-Spam-Status: No, score=-4.2 required=5.0 tests=BAYES_00,RCVD_IN_DNSWL_MED, SPF_HELO_NONE,SPF_NONE 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-Greylist: Sender passed SPF test, not delayed by milter-greylist-4.6.4 (howler.vger.email [0.0.0.0]); Thu, 05 Oct 2023 08:22:13 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778929542855981850 X-GMAIL-MSGID: 1778929542855981850 The computation of endpoint memory access descriptor's composite memory region descriptor offset is using COMPOSITE_CONSTITUENTS_OFFSET which is unnecessary complicated. Composite memory region descriptor always follow the endpoint memory access descriptor array and hence it is computed accordingly. COMPOSITE_CONSTITUENTS_OFFSET is useless and wrong for any input other than endpoint memory access descriptor count. Let us drop the usage of COMPOSITE_CONSTITUENTS_OFFSET to simplify the computation of total transmit and fragment length in the memory transactions. Signed-off-by: Sudeep Holla --- drivers/firmware/arm_ffa/driver.c | 14 ++++++++------ include/linux/arm_ffa.h | 2 -- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c index 9dd5335001ee..45ad704734a2 100644 --- a/drivers/firmware/arm_ffa/driver.c +++ b/drivers/firmware/arm_ffa/driver.c @@ -442,23 +442,25 @@ ffa_setup_and_transmit(u32 func_id, void *buffer, u32 max_fragsize, { int rc = 0; bool first = true; + u32 composite_offset; phys_addr_t addr = 0; + struct ffa_mem_region *mem_region = buffer; struct ffa_composite_mem_region *composite; struct ffa_mem_region_addr_range *constituents; struct ffa_mem_region_attributes *ep_mem_access; - struct ffa_mem_region *mem_region = buffer; u32 idx, frag_len, length, buf_sz = 0, num_entries = sg_nents(args->sg); mem_region->tag = args->tag; mem_region->flags = args->flags; mem_region->sender_id = drv_info->vm_id; mem_region->attributes = ffa_memory_attributes_get(func_id); - ep_mem_access = &mem_region->ep_mem_access[0]; + ep_mem_access = buffer + COMPOSITE_OFFSET(0); + composite_offset = COMPOSITE_OFFSET(args->nattrs); for (idx = 0; idx < args->nattrs; idx++, ep_mem_access++) { ep_mem_access->receiver = args->attrs[idx].receiver; ep_mem_access->attrs = args->attrs[idx].attrs; - ep_mem_access->composite_off = COMPOSITE_OFFSET(args->nattrs); + ep_mem_access->composite_off = composite_offset; ep_mem_access->flag = 0; ep_mem_access->reserved = 0; } @@ -467,13 +469,13 @@ ffa_setup_and_transmit(u32 func_id, void *buffer, u32 max_fragsize, mem_region->reserved_1 = 0; mem_region->ep_count = args->nattrs; - composite = buffer + COMPOSITE_OFFSET(args->nattrs); + composite = buffer + composite_offset; composite->total_pg_cnt = ffa_get_num_pages_sg(args->sg); composite->addr_range_cnt = num_entries; composite->reserved = 0; - length = COMPOSITE_CONSTITUENTS_OFFSET(args->nattrs, num_entries); - frag_len = COMPOSITE_CONSTITUENTS_OFFSET(args->nattrs, 0); + length = composite_offset + CONSTITUENTS_OFFSET(num_entries); + frag_len = composite_offset + CONSTITUENTS_OFFSET(0); if (frag_len > max_fragsize) return -ENXIO; diff --git a/include/linux/arm_ffa.h b/include/linux/arm_ffa.h index f6df81f14b6d..748d0a83a4bc 100644 --- a/include/linux/arm_ffa.h +++ b/include/linux/arm_ffa.h @@ -356,8 +356,6 @@ struct ffa_mem_region { (offsetof(struct ffa_mem_region, ep_mem_access[x])) #define CONSTITUENTS_OFFSET(x) \ (offsetof(struct ffa_composite_mem_region, constituents[x])) -#define COMPOSITE_CONSTITUENTS_OFFSET(x, y) \ - (COMPOSITE_OFFSET(x) + CONSTITUENTS_OFFSET(y)) struct ffa_mem_ops_args { bool use_txbuf; From patchwork Thu Oct 5 14:45:07 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 148806 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:612c:2016:b0:403:3b70:6f57 with SMTP id fe22csp374182vqb; Thu, 5 Oct 2023 08:23:35 -0700 (PDT) X-Google-Smtp-Source: AGHT+IEX5lNY+dLrdhe2kWySAX1h1E4wTpHcwzaOGtmIQeakfFF/UmJr9vrffwoBW2omK6GMTqaO X-Received: by 2002:a05:6808:91a:b0:3a9:11cb:d5a6 with SMTP id w26-20020a056808091a00b003a911cbd5a6mr5849246oih.32.1696519414860; Thu, 05 Oct 2023 08:23:34 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696519414; cv=none; d=google.com; s=arc-20160816; b=FdElMCkWBS5p0zzXD0h9hsNimoN5pQRm2pNOAcuJecG0Kj7SCr9B5H5urTEUhiZB+c F8rUwsRPoQIZzOvYZwBTgoY0pT/IFhWsXfC+J3lIAOloI7/PFLZ/bdqIHDs5WmfkNbJc korKZeJWhYtNEDVq/gWoVKlXkTqHbaVcdVOuQscRglOpLcKK78r4ocs38Xmwi/2g7nAN /pFMEvZ6z3evIJHHc/noOoye8u2PCP3qILyjfmL4Hm0+A9JGHXkVaLIH9rdw/WI6uPyu N3owQRKwlBLVXJs3bmx1F831YBW7Wph3k25KAQM1/JFNphRLScsF26C1dxfrLI2tfP+u NLzQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:cc:to:in-reply-to:references:message-id :content-transfer-encoding:mime-version:subject:date:from; bh=8/EJURBtgep5wweahOXlRWmeVdKSPIsXDFvuIXkBxH4=; fh=6OYY6fD5PfTLF1F737Vl+bRsEmFHuj4gbYLrOs5QYVs=; b=UievLo+Ij6laktZsNHlcvSrp4k7iFMsBQlo8Yf2PCXbdEZKf7mKR5DLPA8IqekCNDT LlY9EGauqOfWtpPA9H2xxfDn8tAPAQaXPLTLUWJG/+QuHvf6UUqPBFrGxb5A8o/C1f10 n8KNUz8RTGmCV3QiN0oOWeznc2O9ykVitfZzdS4e2oREIsD+rVgX1xaiVKMzNEVJfjRA 2vrmrKEif5FHC+Xp7OdpgeZ18dIPHpnujaO5BAjaqEFIUhO5L4wrBgRXGhzHc5kxdwsV aOYc2j6ozAWNrBi85yJ+soK+U5J24YqZX3hICKcwdRQ2TXIbwb4+M4wVtT6OZlCBP+DP efDQ== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.34 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from howler.vger.email (howler.vger.email. [23.128.96.34]) by mx.google.com with ESMTPS id k8-20020a633d08000000b00565e87d8707si1732358pga.496.2023.10.05.08.23.34 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 05 Oct 2023 08:23:34 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.34 as permitted sender) client-ip=23.128.96.34; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.34 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from out1.vger.email (depot.vger.email [IPv6:2620:137:e000::3:0]) by howler.vger.email (Postfix) with ESMTP id 64F7780AEE27; Thu, 5 Oct 2023 08:21:59 -0700 (PDT) X-Virus-Status: Clean X-Virus-Scanned: clamav-milter 0.103.10 at howler.vger.email Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231597AbjJEPVw (ORCPT + 19 others); Thu, 5 Oct 2023 11:21:52 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42784 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233390AbjJEPVF (ORCPT ); Thu, 5 Oct 2023 11:21:05 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id 52F8C21342 for ; Thu, 5 Oct 2023 07:45:44 -0700 (PDT) Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id C90EC1650; Thu, 5 Oct 2023 07:46:04 -0700 (PDT) Received: from e103737-lin.cambridge.arm.com (e103737-lin.cambridge.arm.com [10.1.197.49]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id A87D53F641; Thu, 5 Oct 2023 07:45:24 -0700 (PDT) From: Sudeep Holla Date: Thu, 05 Oct 2023 15:45:07 +0100 Subject: [PATCH v4 14/17] KVM: arm64: FFA: Remove access of endpoint memory access descriptor array MIME-Version: 1.0 Message-Id: <20231005-ffa_v1-1_notif-v4-14-cddd3237809c@arm.com> References: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> In-Reply-To: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> To: linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Sudeep Holla , Marc Bonnici , Jens Wiklander , Coboy Chen , Lorenzo Pieralisi , Olivier Deprez Cc: Marc Zyngier , Oliver Upton , Will Deacon , Quentin Perret X-Mailer: b4 0.12.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=3232; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=SS6JRBjjCJQqFwvnNz13s81gsvYnAl3iEKszag6Pbtw=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlHsvydd/+94+47JnCF7cTSk3FzmX9PSPrdF9Ly GN4PBA5oLqJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZR7L8gAKCRAAQbq8MX7i mLjxEADBX6incMiMnSXjh5fzCkWAWrvI9bfk0iqevZkcvD1/rbY6wqo3eJMbTL8rhsCA9DphjKX wscGHUig6QHtuR6KFqbQVId6lgMAPFL8yCfALoAp1RbZtNe0FKoFN6YoPtGM42ckpNthk+9XA7j ohxfcrgBkmGYRAChnxFguIvAk8FXHWS81BY6XGhacN1OnSfUNhmhZvs/MAqdeDh5TO3mEQ2ckA/ nYWRc1JBvLGg6tpYzyZiAh5tV3gDSqUehDjjTqZMn9bMQrsFaxYg+psry4m3jdNoDf+Wkg+D4Pm qA11X7O6BdsBI8mD+Hg7l3u/vkzJ3026jUUPUVtTaMWxxMX3VlrWtqcWSENBoPIPwopVECspfQ0 yBGGZhhA3fOL5gZQ23newDuhWt+cuJlXtwGzFdRGtC2idSBQd0Cnm2BPbBX9uc7u2kkyOIAkkdt NQuIpW5Ib8xcMhJcStZ8lj73YiQsWf1BoXROHcljTWTFyEJrV5AJBC9e1gPPMReQMLlRPMyQ/gD eJlreACercAiLNVQk8uCf3RfGBNoB6bIBmbh/C5T6iDWi7EU8mpzPJkpHOZildEw450NjWCqzpS I9o4IfUm5LWPwOfuh4H+Na+Xiz2z4v2Jbw8o4K+3carzaVhIRM91dw/oAjgK2o4TScC8WIfi7ot x1XvkKUx7I2W/kw== X-Developer-Key: i=sudeep.holla@arm.com; a=openpgp; fpr=7360A21742ADF5A11767C1C139CFD4755FE2D5B4 X-Spam-Status: No, score=-4.2 required=5.0 tests=BAYES_00,RCVD_IN_DNSWL_MED, SPF_HELO_NONE,SPF_NONE 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-Greylist: Sender passed SPF test, not delayed by milter-greylist-4.6.4 (howler.vger.email [0.0.0.0]); Thu, 05 Oct 2023 08:21:59 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778929542138533755 X-GMAIL-MSGID: 1778929542138533755 FF-A v1.1 removes the fixed location of endpoint memory access descriptor array within the memory transaction descriptor structure. In preparation to remove the ep_mem_access member from the ffa_mem_region structure, provide the accessor to fetch the offset and use the same in FF-A proxy implementation. The accessor take the FF-A version as the argument from which the memory access descriptor format can be determined. v1.0 uses the old format while v1.1 onwards use the new format specified in the v1.1 specification. Cc: Marc Zyngier Cc: Oliver Upton Cc: Will Deacon Cc: Quentin Perret Signed-off-by: Sudeep Holla Acked-by: Marc Zyngier --- arch/arm64/kvm/hyp/nvhe/ffa.c | 10 ++++++++-- include/linux/arm_ffa.h | 6 ++++++ 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/arch/arm64/kvm/hyp/nvhe/ffa.c b/arch/arm64/kvm/hyp/nvhe/ffa.c index 6e4dba9eadef..320f2eaa14a9 100644 --- a/arch/arm64/kvm/hyp/nvhe/ffa.c +++ b/arch/arm64/kvm/hyp/nvhe/ffa.c @@ -423,6 +423,7 @@ static __always_inline void do_ffa_mem_xfer(const u64 func_id, DECLARE_REG(u32, fraglen, ctxt, 2); DECLARE_REG(u64, addr_mbz, ctxt, 3); DECLARE_REG(u32, npages_mbz, ctxt, 4); + struct ffa_mem_region_attributes *ep_mem_access; struct ffa_composite_mem_region *reg; struct ffa_mem_region *buf; u32 offset, nr_ranges; @@ -452,7 +453,9 @@ static __always_inline void do_ffa_mem_xfer(const u64 func_id, buf = hyp_buffers.tx; memcpy(buf, host_buffers.tx, fraglen); - offset = buf->ep_mem_access[0].composite_off; + ep_mem_access = (void *)buf + + ffa_mem_desc_offset(buf, 0, FFA_VERSION_1_0); + offset = ep_mem_access->composite_off; if (!offset || buf->ep_count != 1 || buf->sender_id != HOST_FFA_ID) { ret = FFA_RET_INVALID_PARAMETERS; goto out_unlock; @@ -504,6 +507,7 @@ static void do_ffa_mem_reclaim(struct arm_smccc_res *res, DECLARE_REG(u32, handle_lo, ctxt, 1); DECLARE_REG(u32, handle_hi, ctxt, 2); DECLARE_REG(u32, flags, ctxt, 3); + struct ffa_mem_region_attributes *ep_mem_access; struct ffa_composite_mem_region *reg; u32 offset, len, fraglen, fragoff; struct ffa_mem_region *buf; @@ -528,7 +532,9 @@ static void do_ffa_mem_reclaim(struct arm_smccc_res *res, len = res->a1; fraglen = res->a2; - offset = buf->ep_mem_access[0].composite_off; + ep_mem_access = (void *)buf + + ffa_mem_desc_offset(buf, 0, FFA_VERSION_1_0); + offset = ep_mem_access->composite_off; /* * We can trust the SPMD to get this right, but let's at least * check that we end up with something that doesn't look _completely_ diff --git a/include/linux/arm_ffa.h b/include/linux/arm_ffa.h index 748d0a83a4bc..2444d596b703 100644 --- a/include/linux/arm_ffa.h +++ b/include/linux/arm_ffa.h @@ -357,6 +357,12 @@ struct ffa_mem_region { #define CONSTITUENTS_OFFSET(x) \ (offsetof(struct ffa_composite_mem_region, constituents[x])) +static inline u32 +ffa_mem_desc_offset(struct ffa_mem_region *buf, int count, u32 ffa_version) +{ + return COMPOSITE_OFFSET(0); +} + struct ffa_mem_ops_args { bool use_txbuf; u32 nattrs; From patchwork Thu Oct 5 14:45:08 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 148855 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:612c:2016:b0:403:3b70:6f57 with SMTP id fe22csp404618vqb; Thu, 5 Oct 2023 09:08:21 -0700 (PDT) X-Google-Smtp-Source: AGHT+IGNM+qz+jX0VPtQOYY+eyjwu0nPCVMdC12j04QNtAYdS6/vI1GD3ZJuUBpFtSRbFf+H2kPk X-Received: by 2002:a05:6358:988d:b0:135:b4c:a490 with SMTP id q13-20020a056358988d00b001350b4ca490mr5056918rwa.10.1696522101595; Thu, 05 Oct 2023 09:08:21 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696522101; cv=none; d=google.com; s=arc-20160816; b=BW6mcR4FGLjCq8aEtiq0YYEg5gcfQLnGDKZjZg7g2rfcxsLP+rx1Gnb7ztK52vtvja iMJTSOLhRm7V8sLCHj6BclJNqUvYFbsiPQvcVopMpf+m+aFIZCERbE+vEJh7xCCXMK9I tlIob5GR68dR9gqHB4GFYBDPj0Y+jVXOeyXBawIC+0xJYL62V0JqGTE7IQs4gZ8Lhx0p LJWOmLGaJeUsJyeW06N8cMXtIAEdP7T4X8ZQNgvX/R3+c0+95BAKuHrSvl3kiViIgtD1 boLOo6kSwHOCoTtsjneCxsw9vh8iSRstC9yZ1V6vO+L1KYGDHOt3NA4RR5YsLxLDWMI5 F3+Q== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:to:in-reply-to:references:message-id :content-transfer-encoding:mime-version:subject:date:from; bh=zvStKXJS3oNBObli2Nkwr92msYaicUUncl/aRBkQ0iY=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=h8WnW8ZkELHsvG+MDChtPJoKV635x69x/SY5HbaOISjIz72jlj08iqHstGuKe+qT+I Dr7JgBgndfMRPnW5NO9gUs3TA6P/oeSC1OHKoJ50huhjppb/mQOqm5AXLumdVGt3W4yt jHMZzBWS4OCpAmdn3vG257hFffKvnX+QDUMaeWFxwxzQEEdqr6LVI9k3pj1RYWGX+joZ bfcIFa0OKj94+GR/CnMFnUQopeTx/L9HEBcytoMY3Pt32Y3tjezFvqqouP0Zm2uBLavK Stk9AF0gVuSkabz9/s1aCybIe2bVxJj99WW3Mt2hAcazSRsVwDWfbua9xAGPa7PbKur0 OUNg== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.32 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from agentk.vger.email (agentk.vger.email. [23.128.96.32]) by mx.google.com with ESMTPS id x14-20020a634a0e000000b00588fa0def2asi1639597pga.778.2023.10.05.09.08.21 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 05 Oct 2023 09:08:21 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.32 as permitted sender) client-ip=23.128.96.32; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.32 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from out1.vger.email (depot.vger.email [IPv6:2620:137:e000::3:0]) by agentk.vger.email (Postfix) with ESMTP id 3DECC8073DDF; Thu, 5 Oct 2023 09:07:58 -0700 (PDT) X-Virus-Status: Clean X-Virus-Scanned: clamav-milter 0.103.10 at agentk.vger.email Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S238953AbjJEQGH (ORCPT + 19 others); Thu, 5 Oct 2023 12:06:07 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38748 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S237608AbjJEQEI (ORCPT ); Thu, 5 Oct 2023 12:04:08 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id 2265BD4B6 for ; Thu, 5 Oct 2023 07:45:58 -0700 (PDT) Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 08C691655; Thu, 5 Oct 2023 07:46:06 -0700 (PDT) Received: from e103737-lin.cambridge.arm.com (e103737-lin.cambridge.arm.com [10.1.197.49]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 50A843F641; Thu, 5 Oct 2023 07:45:26 -0700 (PDT) From: Sudeep Holla Date: Thu, 05 Oct 2023 15:45:08 +0100 Subject: [PATCH v4 15/17] firmware: arm_ffa: Switch to using ffa_mem_desc_offset() accessor MIME-Version: 1.0 Message-Id: <20231005-ffa_v1-1_notif-v4-15-cddd3237809c@arm.com> References: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> In-Reply-To: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> To: linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Sudeep Holla , Marc Bonnici , Jens Wiklander , Coboy Chen , Lorenzo Pieralisi , Olivier Deprez X-Mailer: b4 0.12.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=1380; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=dftsGeY1DJoCwWfBKEb8lal/PjiIATpRlO3OUrofRCc=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlHsvyU+xRMy3zAAPz5EmrKB/zbOi8MBAJRtWAu gSJrAtP0TqJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZR7L8gAKCRAAQbq8MX7i mMzlEADC7lH5pUpEzXnZb9aFQtnhTnJ0WRHy3P6aG27izufZJSrmsAlykpGuUcdyhfN6mWSDcTK I/CeMK17mZBbJw2pnGfJp2WHYOfcbY3nPP5xcoi1Arem8t8y7YfgceVxaATJpaiBF7mOfZHuOPL bvonNJg5hali/lX5uyKbGTqmO12QjHHCtmCFtS/+79nTqpILkF9QcnLbEU7tUukbplE7YH4o4KS UxllLl9c3KNRsENtPP3cNt1swBdF2CLRwNmgHVW+fBEJ6mvmoIYJhSJEWx0zQHKULWYIavUqaNT Inh4L3sY/6YmhRaIrY7goieuI1zdz4ZYsDxTI0r076/fWqb6Lj+sB/SVr1ia/+wsYpg/PtHTzXh tOaBu0oyRh6BqHXFM49GlQKozWKV/advFhy25KTuryCQcbSR2skEJe/b/EhuxHx8/LJGCtLOeFX PQ05NvrMMXQLkApitInDB1kKifye9pwk2XkfsyLkZMsKIY45qD8Lkmy/17JWvgx2+VeAwD+eR2V WL6+M8fUOUJe0mXNmR2KibP46sIizy/1a9luMSMC1s1IdPZpWjSTk2e0WBthrco8Uw5JIqZRroC 7fTMxSBJ4YwKDAB5wTK2dv1jJ1MN5Z7hdpHVranN7qMUpaAWVBDUaok7CFxyEfqKv87OsKNttSt l2IZL/v5JzMvXpg== X-Developer-Key: i=sudeep.holla@arm.com; a=openpgp; fpr=7360A21742ADF5A11767C1C139CFD4755FE2D5B4 X-Spam-Status: No, score=-0.8 required=5.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS autolearn=unavailable autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on agentk.vger.email Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-Greylist: Sender passed SPF test, not delayed by milter-greylist-4.6.4 (agentk.vger.email [0.0.0.0]); Thu, 05 Oct 2023 09:07:58 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778932358970791185 X-GMAIL-MSGID: 1778932358970791185 In preparation to add support to the new memory transaction descriptor, the ep_mem_access member needs to be removed and hence even the macro COMPOSITE_OFFSET(). Let us switch to using the new ffa_mem_desc_offset() accessor in ffa_setup_and_transmit(). This will enable adding the support for new format transparently without any changes here again. Signed-off-by: Sudeep Holla --- drivers/firmware/arm_ffa/driver.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c index 45ad704734a2..4de08ffce599 100644 --- a/drivers/firmware/arm_ffa/driver.c +++ b/drivers/firmware/arm_ffa/driver.c @@ -454,8 +454,10 @@ ffa_setup_and_transmit(u32 func_id, void *buffer, u32 max_fragsize, mem_region->flags = args->flags; mem_region->sender_id = drv_info->vm_id; mem_region->attributes = ffa_memory_attributes_get(func_id); - ep_mem_access = buffer + COMPOSITE_OFFSET(0); - composite_offset = COMPOSITE_OFFSET(args->nattrs); + ep_mem_access = buffer + + ffa_mem_desc_offset(buffer, 0, drv_info->version); + composite_offset = ffa_mem_desc_offset(buffer, args->nattrs, + drv_info->version); for (idx = 0; idx < args->nattrs; idx++, ep_mem_access++) { ep_mem_access->receiver = args->attrs[idx].receiver; From patchwork Thu Oct 5 14:45:09 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 148804 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:612c:2016:b0:403:3b70:6f57 with SMTP id fe22csp373709vqb; Thu, 5 Oct 2023 08:22:47 -0700 (PDT) X-Google-Smtp-Source: AGHT+IFwzw1j0UzjszBpWh0Po0HovyZMizdfH12GmbuewvbeK8XOcCoAnPcWiUY6XXeKTwSfXo44 X-Received: by 2002:a05:6a21:3399:b0:138:68b9:138e with SMTP id yy25-20020a056a21339900b0013868b9138emr2338801pzb.8.1696519367243; Thu, 05 Oct 2023 08:22:47 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696519367; cv=none; d=google.com; s=arc-20160816; b=RAQW1njxV7tenH+M9U+MllM/1NsyHdnjIIsUMx50E4GPdIMKhjWbIJ7Sg3Ua+9ucTv e1gDXynrlfPWX44IVZGXiiDrSRKl29EFFwvA89nfJUjBYVyOBYFFhWSvGo9EdzuS25lx 7DKLZDcOAQ2EGMExx26ovONGNF0MHb8RNHX1jMGxU3QdriB0rqIBnagzX2bCka3sbRGG 2wsUrr5z1ga+lGcoko+JHOK6rIN+lZ4R7X/emDqB7HaKeZ95XsJ7QH7kQaHH3QHd20p8 mkocap1+fK8rsb2H3RsdsVmTPMJJEZ9Tu7Hxhx0t2tGGwISNsLfAeilJEwz9SeTIpHRI Ye8Q== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:to:in-reply-to:references:message-id :content-transfer-encoding:mime-version:subject:date:from; bh=Z/LAZ6iTlCsD+NPzhFudfSemlaRZKb3vOTjiZrFtvzE=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=ciQw6E1TQrkK9bY3WI8aewbyUCBWpDsmrcd2XWwKGTa8YkjyuUTukVZp2eLllanAz9 DaJqmI7tWSVnC9YgUh7gWHcQzIHqNqUFbDoLPl3pvyjPbzZysoz7+j+4C8aM60tHF+I4 o5VexCQYxLXnblIGlXgugmWvjSxsvCctl46zVdOaBQk+4D53NBRaxyOUk9z40oaaGNWu Z+sBacBnJ1XRto35E+UoQZgQpHSLdpp+1zhD5tn84f6Fr1as47xjZMLeMZRzGDApc8gl FxE15EZwewi7uQDOUN+FeGw3L4MccaHXWU5NMICcjCHB1WR+4EWd6btEzbMsfqzJYAON nS4w== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:5 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from groat.vger.email (groat.vger.email. [2620:137:e000::3:5]) by mx.google.com with ESMTPS id bx6-20020a056a02050600b005893c5bd119si1886879pgb.425.2023.10.05.08.22.46 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 05 Oct 2023 08:22:47 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:5 as permitted sender) client-ip=2620:137:e000::3:5; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:5 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from out1.vger.email (depot.vger.email [IPv6:2620:137:e000::3:0]) by groat.vger.email (Postfix) with ESMTP id 9548C8374DB0; Thu, 5 Oct 2023 08:22:44 -0700 (PDT) X-Virus-Status: Clean X-Virus-Scanned: clamav-milter 0.103.10 at groat.vger.email Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232447AbjJEPWX (ORCPT + 19 others); Thu, 5 Oct 2023 11:22:23 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58170 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232388AbjJEPVV (ORCPT ); Thu, 5 Oct 2023 11:21:21 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id 8D12A2639A for ; Thu, 5 Oct 2023 07:45:59 -0700 (PDT) Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 386CA1682; Thu, 5 Oct 2023 07:46:07 -0700 (PDT) Received: from e103737-lin.cambridge.arm.com (e103737-lin.cambridge.arm.com [10.1.197.49]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 826DF3F641; Thu, 5 Oct 2023 07:45:27 -0700 (PDT) From: Sudeep Holla Date: Thu, 05 Oct 2023 15:45:09 +0100 Subject: [PATCH v4 16/17] firmware: arm_ffa: Update memory descriptor to support v1.1 format MIME-Version: 1.0 Message-Id: <20231005-ffa_v1-1_notif-v4-16-cddd3237809c@arm.com> References: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> In-Reply-To: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> To: linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Sudeep Holla , Marc Bonnici , Jens Wiklander , Coboy Chen , Lorenzo Pieralisi , Olivier Deprez X-Mailer: b4 0.12.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=4145; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=AsgrCLkaUu1zLbCge8pt4uxFm41JF9MxE5C3AnabUNY=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlHsvyF1KWLkS6mBQdJcATQCVZa74qTBlObPPJb RknDLHuEUqJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZR7L8gAKCRAAQbq8MX7i mIGTD/0ZOjx3MsHUpdw/U0qsG9hf76rA/Ja1Eax44lG4iDhpRJUPpBs8fMD+mqupQpKmB4YgHlk XwTP6t08kC0l6+zrg7gxxKUK1X4xEpLRTpjtCoQU7kTrtXNfLXop3zz/XksZQHrcdb1Z3YLsIkX YPlFklYloF/otyQfDlm0/CLyTbM4Td5igLAvLvHqsYob2ucq54i/IBlIe1bHpD6u0gdHuf+1icX NTDMhPmTWo8+kblRzR0bcDHub8St1Op0pKvJGXOdV+ZkiOE9xKc3F8y9n9lHVAbIw565HcSasOx ObaEXkiYXAhyz1+pzczao49bl0bCmTS7RYDB/3rNgH1M7rabqqrnmn0/Vtq0giGykAKFFZtpNb1 WJgur9MivEN2wjIJSkY/ISh6fWMuTJJUoTM++6+0tX1KG/mROO7iXvvVMRF911H0BOWeUhNxuD7 YqKaciz8soevmr7tn1okIpyXdBm+lDWHj+xy1pf0DmWX9vpKRDrX23Rz1PibW5G2Su5WylumCm+ BoGse61vKBGKBvu3tc6EhKqb8wap70gooIAQk8oam0Yp5dAauQHAQinNbPJIQoYuXhOHG8Pvxur t70nVoJCHYCoeNpQjXc0onTV2sC8gqSaXcDshJUS/fe7SA3tE3PwTGIdWD7gkDhHLsS7mhaxTra tlyc6hpKD//gnNw== X-Developer-Key: i=sudeep.holla@arm.com; a=openpgp; fpr=7360A21742ADF5A11767C1C139CFD4755FE2D5B4 X-Spam-Status: No, score=-0.8 required=5.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS autolearn=unavailable autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on groat.vger.email Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-Greylist: Sender passed SPF test, not delayed by milter-greylist-4.6.4 (groat.vger.email [0.0.0.0]); Thu, 05 Oct 2023 08:22:44 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778929492071667528 X-GMAIL-MSGID: 1778929492071667528 Update memory transaction descriptor structure to accommodate couple of new entries in v1.1 which were previously marked reserved and MBZ(must be zero). It also removes the flexible array member ep_mem_access in the memory transaction descriptor structure as it need not be at fixed offset. Also update ffa_mem_desc_offset() accessor to handle both old and new formats of memory transaction descriptors. The updated ffa_mem_region structure aligns with new format in v1.1 and hence the driver/user must take care not to use members beyond and including ep_mem_offset when using the old format. Signed-off-by: Sudeep Holla --- drivers/firmware/arm_ffa/driver.c | 11 ++++++++--- include/linux/arm_ffa.h | 32 +++++++++++++++++++++----------- 2 files changed, 29 insertions(+), 14 deletions(-) diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c index 4de08ffce599..7b3db675454c 100644 --- a/drivers/firmware/arm_ffa/driver.c +++ b/drivers/firmware/arm_ffa/driver.c @@ -423,7 +423,7 @@ static u32 ffa_get_num_pages_sg(struct scatterlist *sg) return num_pages; } -static u8 ffa_memory_attributes_get(u32 func_id) +static u16 ffa_memory_attributes_get(u32 func_id) { /* * For the memory lend or donate operation, if the receiver is a PE or @@ -467,9 +467,14 @@ ffa_setup_and_transmit(u32 func_id, void *buffer, u32 max_fragsize, ep_mem_access->reserved = 0; } mem_region->handle = 0; - mem_region->reserved_0 = 0; - mem_region->reserved_1 = 0; mem_region->ep_count = args->nattrs; + if (drv_info->version <= FFA_VERSION_1_0) { + mem_region->ep_mem_size = 0; + } else { + mem_region->ep_mem_size = sizeof(*ep_mem_access); + mem_region->ep_mem_offset = sizeof(*mem_region); + memset(mem_region->reserved, 0, 12); + } composite = buffer + composite_offset; composite->total_pg_cnt = ffa_get_num_pages_sg(args->sg); diff --git a/include/linux/arm_ffa.h b/include/linux/arm_ffa.h index 2444d596b703..510fe78bff71 100644 --- a/include/linux/arm_ffa.h +++ b/include/linux/arm_ffa.h @@ -298,8 +298,8 @@ struct ffa_mem_region { #define FFA_MEM_NON_SHAREABLE (0) #define FFA_MEM_OUTER_SHAREABLE (2) #define FFA_MEM_INNER_SHAREABLE (3) - u8 attributes; - u8 reserved_0; + /* Memory region attributes, upper byte MBZ pre v1.1 */ + u16 attributes; /* * Clear memory region contents after unmapping it from the sender and * before mapping it for any receiver. @@ -337,30 +337,40 @@ struct ffa_mem_region { * memory region. */ u64 tag; - u32 reserved_1; + /* Size of each endpoint memory access descriptor, MBZ pre v1.1 */ + u32 ep_mem_size; /* * The number of `ffa_mem_region_attributes` entries included in this * transaction. */ u32 ep_count; /* - * An array of endpoint memory access descriptors. - * Each one specifies a memory region offset, an endpoint and the - * attributes with which this memory region should be mapped in that - * endpoint's page table. + * 16-byte aligned offset from the base address of this descriptor + * to the first element of the endpoint memory access descriptor array + * Valid only from v1.1 */ - struct ffa_mem_region_attributes ep_mem_access[]; + u32 ep_mem_offset; + /* MBZ, valid only from v1.1 */ + u32 reserved[3]; }; -#define COMPOSITE_OFFSET(x) \ - (offsetof(struct ffa_mem_region, ep_mem_access[x])) #define CONSTITUENTS_OFFSET(x) \ (offsetof(struct ffa_composite_mem_region, constituents[x])) static inline u32 ffa_mem_desc_offset(struct ffa_mem_region *buf, int count, u32 ffa_version) { - return COMPOSITE_OFFSET(0); + u32 offset = count * sizeof(struct ffa_mem_region_attributes); + /* + * Earlier to v1.1, the endpoint memory descriptor array started at + * offset 32(i.e. offset of ep_mem_offset in the current structure) + */ + if (ffa_version <= FFA_VERSION_1_0) + offset += offsetof(struct ffa_mem_region, ep_mem_offset); + else + offset += sizeof(struct ffa_mem_region); + + return offset; } struct ffa_mem_ops_args { From patchwork Thu Oct 5 14:45:10 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 148808 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:612c:2016:b0:403:3b70:6f57 with SMTP id fe22csp374502vqb; Thu, 5 Oct 2023 08:24:05 -0700 (PDT) X-Google-Smtp-Source: AGHT+IFrCVBB6xnz997g2k2WeywmLOstaV5nOfl9/Sze2d+K8sOrKLXsX+pGl4KV3MpE7lk+84an X-Received: by 2002:a17:902:d511:b0:1c7:1eb7:82cd with SMTP id b17-20020a170902d51100b001c71eb782cdmr6628644plg.60.1696519444745; Thu, 05 Oct 2023 08:24:04 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696519444; cv=none; d=google.com; s=arc-20160816; b=lEuEUuNqaPEMSxvdtDCYZz8YLkO1dYhICuFAD82pZSxSgxIc9GqgZLMrDlPj5ovu6b Wzt+TvlAx1KiN3LPi1u3PMNl5nlcERNifuODlSjh2lFX1hpNsz8fUTC/kjz8BHQROdYc 1bmrXraumGaHd+doyF1LKyarrjoIFsBCreFqDeVAnF9Gx7UZRenv4QDFvDkWLn3ALMvb +UCjNoe1qcyWIazYdvy0DFf1I50NuGJfa/WR4UXWJWyY3UuuFohD/AIPBKE87+7cXoA4 p5sZUi+/1GqoJBo3vXlet9HCscEdose3TurGi18UrEQ3hJDD3twROCnQnKn4vJJXbv6h jJTg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:to:in-reply-to:references:message-id :content-transfer-encoding:mime-version:subject:date:from; bh=KbVrDng0wqxR/OwJt2PeHlS19qjGXQw+kpwltv5c978=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=tGVV5wjGrGC86nZmOOKDkovKLw/CZJ6nIWDA7Jez6P2yYqay5Ium+5Pzofz/Uuwi2Y nFb+FxjcsX01cig1Fj+pMArXqGvgRGHn9Zc09LYb77ZgPU8lztYfpTp0Q5OG+yU9EjgC nFtYlwqg6wZazMHZQWYyhusm30aMAFY8xKCAYVFCYZaUm+IGNaUW6MM//g/rC9HMVzSv DgIlN5suH/+ef8SmyFOCZ2sl8qDhSw9MbUfqGHov3tpi2G7wqFl/6P6JeTlVo7MmytrR myf/DPCu4QSj9+E5XjSJOXooFB01H5WP/gnZauAre7T2TyXAXvqM7ukO99akEA0WML4k e8OA== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:5 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from groat.vger.email (groat.vger.email. [2620:137:e000::3:5]) by mx.google.com with ESMTPS id n13-20020a170902e54d00b001c6139bf838si1759246plf.544.2023.10.05.08.24.04 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 05 Oct 2023 08:24:04 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:5 as permitted sender) client-ip=2620:137:e000::3:5; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:5 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=arm.com Received: from out1.vger.email (depot.vger.email [IPv6:2620:137:e000::3:0]) by groat.vger.email (Postfix) with ESMTP id A1F718375C84; Thu, 5 Oct 2023 08:24:02 -0700 (PDT) X-Virus-Status: Clean X-Virus-Scanned: clamav-milter 0.103.10 at groat.vger.email Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233233AbjJEPXp (ORCPT + 19 others); Thu, 5 Oct 2023 11:23:45 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40524 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232787AbjJEPXI (ORCPT ); Thu, 5 Oct 2023 11:23:08 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id 1783F93FE for ; Thu, 5 Oct 2023 07:45:58 -0700 (PDT) Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 69AD6165C; Thu, 5 Oct 2023 07:46:08 -0700 (PDT) Received: from e103737-lin.cambridge.arm.com (e103737-lin.cambridge.arm.com [10.1.197.49]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id B40EF3F641; Thu, 5 Oct 2023 07:45:28 -0700 (PDT) From: Sudeep Holla Date: Thu, 05 Oct 2023 15:45:10 +0100 Subject: [PATCH v4 17/17] firmware: arm_ffa: Upgrade the driver version to v1.1 MIME-Version: 1.0 Message-Id: <20231005-ffa_v1-1_notif-v4-17-cddd3237809c@arm.com> References: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> In-Reply-To: <20231005-ffa_v1-1_notif-v4-0-cddd3237809c@arm.com> To: linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Sudeep Holla , Marc Bonnici , Jens Wiklander , Coboy Chen , Lorenzo Pieralisi , Olivier Deprez X-Mailer: b4 0.12.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=687; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=8SIeTzl6vfeVnSukOY6SLPu6xQWTGCA8RlmB08AfRzE=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlHsvztoI4de2Cc5nOvWVIziqQtyYMiDZMOD3tc WBouUU3Wx6JAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZR7L8wAKCRAAQbq8MX7i mFhDD/4jQiafvyRrcC2b2LaGjuEUPeCodEI/rRe0nBjODHCAqzlejdqSphbj+vL6tH8E/yNs0yI 0bNJi1s4p9YxYGBoCSecB0t/OIrstLVWiJE3Kx5sMb9Qm0/h5UG9ZXjy+TlT+zwYxb0HmfxBxtA G+wRUxur9rOh0IZECNkx6p0MYNCSHKg0PEOXbBVpxFsfgtqVS/38AqUyoH0eDHZpQAsaTJqBzaJ p1kJbcPknG6P4uRvrvkvTTNS9O3rBIadKkNDQJ6IAgFqNoNCAIPktl9rldt9mXZEKDe+Nw3uhwn vcF/9PcceCIjNhlWas42vsC1HA7HoWiLQSrnRvDV90Q+iDp2mjdTrQBEYxinT8sLrEZ7IAFLOnm aJ0Y/AhrvlbWXPnyVcdewKn+u7+d0+cgLPYX1qKyZmZHTGJweggDqTwwhIkV+BVxZQ8hWQ62dEN j02d9aFkqeFvNk5dQT2BT6+Hsye6c69eP7ZqLGgUzTmiOVPh4zkq/BIP2SThzMf/AHFfIO8Xkes vXirXf1P2uk6XilG4P8hEAljGjdFnxzTf9I2y1Ql/BuBXTpYm+WLKmwEQpB3tOKWT2NKd6UhswJ ulieKWOpF7ll6xkWPR2VNLcDJvygLs8K8AhLWdeWhkkVLMsOQHlv4yAg2L1ARvtN/h5Qh2q+R/P Qj9KybnRjVCtntA== X-Developer-Key: i=sudeep.holla@arm.com; a=openpgp; fpr=7360A21742ADF5A11767C1C139CFD4755FE2D5B4 X-Spam-Status: No, score=-0.8 required=5.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS autolearn=unavailable autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on groat.vger.email Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-Greylist: Sender passed SPF test, not delayed by milter-greylist-4.6.4 (groat.vger.email [0.0.0.0]); Thu, 05 Oct 2023 08:24:02 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778929573519638979 X-GMAIL-MSGID: 1778929573519638979 With quite a few v1.1 features supported, we can bump the driver version to v1.1 now. Signed-off-by: Sudeep Holla --- drivers/firmware/arm_ffa/driver.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c index 7b3db675454c..7b6fa6a2781d 100644 --- a/drivers/firmware/arm_ffa/driver.c +++ b/drivers/firmware/arm_ffa/driver.c @@ -43,7 +43,7 @@ #include "common.h" -#define FFA_DRIVER_VERSION FFA_VERSION_1_0 +#define FFA_DRIVER_VERSION FFA_VERSION_1_1 #define FFA_MIN_VERSION FFA_VERSION_1_0 #define SENDER_ID_MASK GENMASK(31, 16)