From patchwork Fri Sep 29 15:02:50 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 146631 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:cae8:0:b0:403:3b70:6f57 with SMTP id r8csp4117533vqu; Fri, 29 Sep 2023 08:28:13 -0700 (PDT) X-Google-Smtp-Source: AGHT+IGm04HMyanhKTGiUKJ70yc0UoF3NDx2URNGZAjFPWmV4BU23st5qFI+f1zt2udWdMWcp0na X-Received: by 2002:a05:6a20:5485:b0:15d:6fd3:8e8c with SMTP id i5-20020a056a20548500b0015d6fd38e8cmr5466069pzk.14.1696001293022; Fri, 29 Sep 2023 08:28:13 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696001293; cv=none; d=google.com; s=arc-20160816; b=zR9qK915mXliFF/rgKDJYhkK1OoYycBl+MWGkYokbjMDZD9BicXRovxi6JbNRCiXIK pdSEjgNLTSChgW36GHgev245nakZwvR310v3t8q16aWjnoxV/Y2gubjNQdFfOnmtrcE6 LS3jG16+EpUTHs9pwORzuwWF8kjsWc03UGIKolKAzd5p1LEjXecIu2Z07AWPpg1WVyQV iEm7OPd9CCi4JNmBx6YsUKUie1mPA2pqJYDSc9V9O7NuAbP9shoxFTXfDxyOHnHc3L7h qOQ+CxdKsmy9CrASnq90LW2lmhj9T28/MGJY5mBFO1/iWkBmMU7op/oSpwYW/kZsHEyZ s+nA== 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=Wbr60CJEq/mXJlUt5CHEULM3N5+EvMS8LEL3y3Am41I=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=BrFznfsilyIltlLXd51X99wU+usglKQoycZLmjvefJtFVwZZIul2vl1/+j9dSs46LM VCPRXsyLoTJAsAYYLvIwOxIlhWAgfy1WcUspWYa9fAMUO6mA2qXTkHw+4m79ouJaIiL0 gElA7pXxUwmuy3wcHe84tHuiQmMHcK+YHni9797uiwS5MAOUtIGzosD/z/Trav5/txQi fmWaAlYvPoOCsI14eNLRens+j5v4l+ewOmlQRGTKx08BMtrPlEjLpJinC1VaRENMBAJE id9Lou+4EBefMfKgLWuYaIKaLuUvO81HJ5tUkgDxdPRjhcNhC8tZrihBv38BSEsRCGia Da2Q== 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 q12-20020a056a00150c00b00693394f5d92si8027912pfu.316.2023.09.29.08.28.12 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 29 Sep 2023 08:28:13 -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 B20068183277; Fri, 29 Sep 2023 08:03:42 -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 S233357AbjI2PDV (ORCPT + 20 others); Fri, 29 Sep 2023 11:03:21 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44806 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229826AbjI2PDT (ORCPT ); Fri, 29 Sep 2023 11:03:19 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id 289B71A7 for ; Fri, 29 Sep 2023 08:03:16 -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 4C5CCDA7; Fri, 29 Sep 2023 08:03: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 E98F73F5A1; Fri, 29 Sep 2023 08:03:14 -0700 (PDT) From: Sudeep Holla Date: Fri, 29 Sep 2023 16:02:50 +0100 Subject: [PATCH v3 01/17] firmware: arm_ffa: Update the FF-A command list with v1.1 additions MIME-Version: 1.0 Message-Id: <20230929-ffa_v1-1_notif-v3-1-c8e4f15190c8@arm.com> References: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@arm.com> In-Reply-To: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@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=3496; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=iM0M4h4uY9LcS7jhU1Ni5Kw/SdOd9wlQU64B4wmmDx0=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlFucupa6nu79ubQS1rGE5x6xDF2tzzi8ymkczB +9PQ0u0UjSJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZRbnLgAKCRAAQbq8MX7i mLjEEACOITJFey81YFZaZ4P1XZfaKQl3vuVT1PteZN8+r24U0QvVP6mibtqsrCl4IdmaN7ZeoOr xxRNx4r5EnDIuJuLiHKXEl4jOmQ/Nal4jRKeXZpWy+dDikzbxmi+heZT+Mkp9PPhVpIj5XRYUf3 ToQCVjUw8W65uU8pfa+btq9MRmhiNj5Umv8tq4QqoTXmm6YSrdws7xDcWpm2V7Q0VjgWYouKGin GgAnZWoqx6Xw3rNqqtEjiPbgT1mwJykkw7aqvrJ00Bn4zMdH8iCVlIQj6jVppgcL3a5brKuMCyQ Bs5xmJE3dirLFz9V/YDPKMgQHKCdEJ6zEbO8xc+R7g6MIDAYGpUZIRz0xCQFqWpGeKLP3oZO0g7 +V3CuTyV8w9CbkylNAA4U9JRUejXay1ozQaXFx3+sAlWNKLXWaKKx1YChwuyMAFmP3yXd+J9kxH Bj75RFUQpOObva2z1SqAebRDPchCO5G+O1SK/llnjNYBTxlEsoQZGQJSiZpJWxLz0a2ALsiYyQV XhTyOCHWoOC1oMLCmCU+y3GQBbEsQn5z46OkEj4pkuZlpz1KccE+hCxvNc4mFIzqX/Q4p3kgwKA he1B8mEgOID8KJ5607k6eyvN3pV2ZWPiRSwiaNzG1G9VhZ1/XvSto3MF7DqcdeXUOt8alvTZh+r pLzgvyV8EwSxujw== 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]); Fri, 29 Sep 2023 08:03:42 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778386252073373617 X-GMAIL-MSGID: 1778386252073373617 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 | 3 ++- include/linux/arm_ffa.h | 20 ++++++++++++++++++++ 2 files changed, 22 insertions(+), 1 deletion(-) diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c index 121f4fc903cd..2b24cda2a185 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) @@ -336,7 +337,7 @@ static int ffa_mem_first_frag(u32 func_id, phys_addr_t buf, u32 buf_sz, if (ret.a0 == FFA_ERROR) return ffa_to_linux_errno((int)ret.a2); - if (ret.a0 == FFA_SUCCESS) { + if (ret.a0 == FFA_SUCCESS || ret.a0 == FFA_FN64_SUCCESS) { if (handle) *handle = PACK_HANDLE(ret.a2, ret.a3); } else if (ret.a0 == FFA_MEM_FRAG_RX) { 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 Fri Sep 29 15:02:51 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 146610 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:cae8:0:b0:403:3b70:6f57 with SMTP id r8csp4107791vqu; Fri, 29 Sep 2023 08:13:45 -0700 (PDT) X-Google-Smtp-Source: AGHT+IEWJDJygAuM7NYUxVZUI/ufYlbHIVbro0aY9cnvR43zgc+Vv6D6doA/pozwoYHX99tBXK6/ X-Received: by 2002:a17:90a:ca90:b0:26d:355a:47e3 with SMTP id y16-20020a17090aca9000b0026d355a47e3mr4219972pjt.38.1696000424700; Fri, 29 Sep 2023 08:13:44 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696000424; cv=none; d=google.com; s=arc-20160816; b=Za8UfX7F+d4sk8c3FVfI1H6UIXXhzASc3qsX2HFpu+MwRiafp5JkMSPyG8BE98ccWl awrkXavUfgXgk5Q8/Nr9F3l/YTaEnZFf/J8TJqDUIIQmmL/oqAKKQ5oPrMgqthL06Dhc t98mcL5TA1rbbYi94zqejjPnK4Vk8RKTbXxQlZeLSVYYv4dgVhdHTcyoSyZLH8oVFEEI 0Ad8DJRncLhPEyTMLpi2zncrbWNyCjblK4KI/WXNQpy5fNhpbt2eUxtOujj6hpqEGo9z 7DbexWllVK8PN5KiYEXBgXwvs5AshhL5ZKq6JlenFxt89+WhwFCivw/K+MAaYgKg0RlE LwTA== 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=T/yrEm74su1ROMa3HaVtVGOXUqzdZ9XodrQGVof3j9I=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=Hgr1kfzGSrl/cN3aJrIMXYiRjtRm2S/YSU5FT+q/siRbQW8JMlpUUzfZ+HapVfsahd 7I600iZWtsUCXNip3amBcuVm3VChcn7hhJvfofKubpvDqya5349OBbB6U5GaR6WT+mfl am3IfCvK6oMEs413Tl8tmC7pZB45SacjIL+CKDrDbPPlc3pZSWi0yZU7VXkbBf3nks45 lelQegq1qNBnR2fZYCrXfFCvIJi9Yt3tGG2A/JqlWtPIeBLZxZh0rfvao/3PLvJn/7so /aYdG4gU7qX5gPEBwpLRcgD2//klSvWU1ZJI3fSADwCzJFEyFj2dngO/jYAFCYIoSpGN DAZQ== 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:1 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 morse.vger.email (morse.vger.email. [2620:137:e000::3:1]) by mx.google.com with ESMTPS id lw2-20020a17090b180200b002792c288cc2si1861952pjb.170.2023.09.29.08.13.44 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 29 Sep 2023 08:13:44 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:1 as permitted sender) client-ip=2620:137:e000::3:1; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::3:1 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 morse.vger.email (Postfix) with ESMTP id AECD780C5A3D; Fri, 29 Sep 2023 08:03:40 -0700 (PDT) X-Virus-Status: Clean X-Virus-Scanned: clamav-milter 0.103.10 at morse.vger.email Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233443AbjI2PD3 (ORCPT + 20 others); Fri, 29 Sep 2023 11:03:29 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44822 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233315AbjI2PDU (ORCPT ); Fri, 29 Sep 2023 11:03:20 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id BAE55F7 for ; Fri, 29 Sep 2023 08:03:17 -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 794261007; Fri, 29 Sep 2023 08:03: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 226643F5A1; Fri, 29 Sep 2023 08:03:16 -0700 (PDT) From: Sudeep Holla Date: Fri, 29 Sep 2023 16:02:51 +0100 Subject: [PATCH v3 02/17] firmware: arm_ffa: Implement notification bitmap create and destroy interfaces MIME-Version: 1.0 Message-Id: <20230929-ffa_v1-1_notif-v3-2-c8e4f15190c8@arm.com> References: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@arm.com> In-Reply-To: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@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=3398; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=E8dkL+QG2QXGEwg80l0faZM6cA032hi2OPI14UW5ukU=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlFucuvBBiLwRwI+A6SBHoF7BhodlY60hl2wjwZ SYQKjnfHqqJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZRbnLgAKCRAAQbq8MX7i mFOQEAC1qH09c9WVdsH6CsUdBdw3pCM0Gbn2kvv/5BJyJEKhaSlahsvCohQGLVkTiinsRzlQN/G AcbwPbb9tZ6+AvWDnxeUa+YLz+hjT8PgQuLziXUmrqyngPU8IivU3ENKLnHIjjyI68E+q1hEddD Svfmo57KwmzLDn6fbf4BlyL2rF2KDR+VamNUuLOUp2dCgn9nMoQ/1bchDcxwLK2OiYyAiTqI+Fs tSCdY/pzUJXye/nnv5FK+H++Y9Xv2Ji4lmCTPDKTunmMpVRu2xlG5JClEVE5XfLjLwCsvkGiEF5 me4K9Kg3IIoENEpbOV18LLSJN7BcY/LU6DKfhqvH5jhRHx0rbm7lkhikTDwFCR1Gwdy8IJ6VgHn o40WyqaKv6EorKh4e+DFuAGDp6d/XpyS5OTVGE7HDWlucYNIAl61NZrm3KEmrjFekJhyhgRIeo8 q9cX4JCiLvfKxuMCzChS7AuDsBBqxqKxl01wFXBzKAV+xFIySKgSlLRmnLbelzFtlE6b//SigsB jaXxpvQwwDP9iNWBomOpWr6CDOJfb3VfumDdG7+ZWp25wXMhkgNy/gTVs4KlvT6o/EWJIexGdNy 5CeJ3/a3wfsW/0u+goWAFd7k+lebdnG7HsvrJLbCXR3eyzJLSTHfT3QwXPqQRyKuLB4pns2+euD 4XFwj2kKBd17Y+w== 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 morse.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 (morse.vger.email [0.0.0.0]); Fri, 29 Sep 2023 08:03:40 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778385341374713481 X-GMAIL-MSGID: 1778385341374713481 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 | 60 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 59 insertions(+), 1 deletion(-) diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c index 2b24cda2a185..efa4e7fb15e3 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) || @@ -712,6 +744,31 @@ 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) { + 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; @@ -767,7 +824,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); @@ -782,6 +839,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 Fri Sep 29 15:02:52 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 146611 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:cae8:0:b0:403:3b70:6f57 with SMTP id r8csp4107855vqu; Fri, 29 Sep 2023 08:13:50 -0700 (PDT) X-Google-Smtp-Source: AGHT+IG6fcZk9J97fGXUQdD1GMA5/LcATZCtc3oB/zCJVCBwKQtTp9Iuc5jaCp9tynbagzeu72li X-Received: by 2002:a05:6808:2a53:b0:3ac:aae1:6d63 with SMTP id fa19-20020a0568082a5300b003acaae16d63mr4220584oib.44.1696000430123; Fri, 29 Sep 2023 08:13:50 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696000430; cv=none; d=google.com; s=arc-20160816; b=JU0POJpi2cDUqXvqyDT5NDYpCH4r6/mviyRD8aWmrr8faKQuhksb20pHirq3N9nwvk p2XHdyemiwJBTpTW+bGDNMHtEe3tNdmn0HXVX2dfZ2DYhfrf5I+fM0RJQBaU7kfw6j0i +JmL/0nO2no/FVhRyDSTfIHl4oJb2kRoIxl1vPfbtBYBB3b7HjXfQuQPJqTa+LStf6F2 YMT9waLPW98m4u9lU51+RybaUDUvBukKdTKepd0X+jDwfjwLN+pYi/N7c1brUaAuIDBm rTHOyOo7fOamLaPduBfzyeBpco4YvC9CqRMNsWLL/ea3gAPCT/4Q577u+djJC/ac8S6f DfyA== 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=0yZ4wrNJz76zvQMSwHuL+TPHt8OimfsLsvQd5jqAZkQ=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=hgh5cIapEU+qUsLcQmGga3dDaZ0KuEM6azhJJ9sUNLkQ5/vEFvmv5gADUWUfNHlv0d /UZ555e/xzOuDqaBlfv/9YTVqgf8bj6KYMDA0sqKNfgctm2jKaBJ1ttUvZwJ/C3Pa+Yo W82V9ZXC9xED4osMiBRBOv6RyO2LHlALOXdj4Kp843MGNK782MAGIJz7E535+HemCqQE E83mYTVJF9jynlUe/wzCuGgDYBHBuCtI8E8JOfFP6jYgTVlGQpHF0PosBe3OptdYWNxU /f41KQ6te1MKdApaFl6Bi45SvJ32Zztlnzgz8NULdSZeuHZbwkVjXD9vALOAO+mFnrOJ ZYiA== 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 j71-20020a638b4a000000b00573fa8f2829si21676648pge.383.2023.09.29.08.13.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 29 Sep 2023 08:13:50 -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 31D368101C5A; Fri, 29 Sep 2023 08:03:54 -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 S233394AbjI2PD0 (ORCPT + 20 others); Fri, 29 Sep 2023 11:03:26 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44816 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233314AbjI2PDU (ORCPT ); Fri, 29 Sep 2023 11:03:20 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id 8AB141AE for ; Fri, 29 Sep 2023 08:03:18 -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 A80311063; Fri, 29 Sep 2023 08:03:56 -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 4F9973F5A1; Fri, 29 Sep 2023 08:03:17 -0700 (PDT) From: Sudeep Holla Date: Fri, 29 Sep 2023 16:02:52 +0100 Subject: [PATCH v3 03/17] firmware: arm_ffa: Implement the notification bind and unbind interface MIME-Version: 1.0 Message-Id: <20230929-ffa_v1-1_notif-v3-3-c8e4f15190c8@arm.com> References: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@arm.com> In-Reply-To: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@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=6dM7t7UcezChOGHUwYllL2LxWCmWJi8qtz0lRrVzNQ8=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlFucuri2NvMBd2IjxYNO/D03XgYBmvOLA9YjLc idNzqIiTE+JAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZRbnLgAKCRAAQbq8MX7i mNOuD/4+jcPMdjdx5iTpJDFKJIU+T08pss3uCcdy0GEF9cddo335kSH2rAbXlNk4XHH150kw9K6 NInTCOWpnCVvD+Wk6I7pKYDd/tzKh1KVjCDpRtRLx7g1B8ihjnxthRTCrPfW59G3VnS/QSV9KJG GlGLfx9VBDIazIYaHrHEkvvKEla+rLU/MkLR8tsFSFssXmpA/GflTEHkhO0oqLgst4InUYFW7Rw aTBrbwjOWCFmuqr7xV8IaoLNaNAzZV6bh1pFziLwX+yLxZCUBQV/zo/ptQGaVLTj110JE6GCv/h +QUPZrnjOClVOffWhXtHa1mwQ7a0Pt+sMymCaSszK4xddfnOuHwm0/DavXf2qMHMiovdQYf5yro K7NqxivFAX+2WLsp4vLXyqXhIlq71OuQrVlxv5NVzrw3tgAGJQPxmKV4i1pqrq3QII8mDYYHLj3 a/nDOfABp7AhYVGZBAUQq5njecxdmJl+k3V2W1jAS5+TahyPrgEQG+U/aJVQf2h6YXnFaEig7Ar zFLcB4iIldYmZT6ZY4bLawjD5CKPEsbKa7ya9kYh8EM/4oU9WsCMawjgAgO9EL4i6j7pRRj5aAR NXnyPYf3dTdYpQTGzZxstOj6dAf/08kehdTyFTkQM80QG4peBrh9Azl8ldq6hTjmO4joZS7G0Ig qiCKLrfOcFW9VFQ== 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]); Fri, 29 Sep 2023 08:03:54 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778385347431914150 X-GMAIL-MSGID: 1778385347431914150 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 efa4e7fb15e3..26bf9c4e3b5f 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 Fri Sep 29 15:02:53 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 146654 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:cae8:0:b0:403:3b70:6f57 with SMTP id r8csp4132653vqu; Fri, 29 Sep 2023 08:52:14 -0700 (PDT) X-Google-Smtp-Source: AGHT+IFNzbXSXQOUBlYS5aAvlBHNQowQFOgBHMSsZJc1ieG/UEH1hFHlK0Fgxskh1MHgIRVz26Xx X-Received: by 2002:a54:4e07:0:b0:3ab:5e9e:51f8 with SMTP id a7-20020a544e07000000b003ab5e9e51f8mr4333351oiy.9.1696002734395; Fri, 29 Sep 2023 08:52:14 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696002734; cv=none; d=google.com; s=arc-20160816; b=RpvyqckN/6Lv041DNrahGbkX/SAkzeegRxinyAobyarOh0gPozhoeauBwedgzx9qok FRePUsgTdBNVBLZHrdYfhC5PQNGiuIrAcCCX0Nc+n602KdE8ZCTZWWBND90DEYD+wPB+ +Go5RUgtY7s4cFKlJ1VbQUCeTOCVaZmZuMamtXui8i1RTJmy1jhOZbKv8J8t4kruamBV zu+SQra9/weiKHOivHW2yvkQywrg5vgPub8Yy87cPYYSzTdpTpU3slg3dkb6Z2KtwBP4 oUUe/PdqZVS7L0OBpCiiTSk7cxdkuuB4SspKzjU8N7YLrkXdUSAcvO1tIalTqHbszF/E EAFw== 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=zZLLptIHy07YsBmb/GEo+E/998gLkUpfNaxLx2IIDN8=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=leqEGRkbESZnbc+umu4ELgp99CkCaDV4M7Kgk4XAInsn2JM3h9JeEewFHCqIxSaEL+ Uzb3hkY/CVUnMn32+red2SL0W+7pLh9LwnnmA1nUPWnHcGTLFvWwYuUhTquDLlpO83XA 7LxAeEoIvJhOkhbAySdsAKMnNft8QI3c9jtfnGnfZj6rZi1XZSwwiK6wlNS6Ed8VI8S1 nLxSa+Hhi65HELJVtQhyRHU2pPD9f+6b+sGL5eL5u9aPUNV7KuZK68b2e2nqcMx73USh LhyEHWiHS2DScVezGB1jym4J/c7aqOhxIewIqYupAXPiltZ6/L+qPqoxydXJlyvR+VFv So4g== 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 g185-20020a636bc2000000b00565eb0b2e66si20652958pgc.864.2023.09.29.08.52.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 29 Sep 2023 08:52:14 -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 090158542260; Fri, 29 Sep 2023 08:03:40 -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 S233495AbjI2PDd (ORCPT + 20 others); Fri, 29 Sep 2023 11:03:33 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44864 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233363AbjI2PDZ (ORCPT ); Fri, 29 Sep 2023 11:03:25 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id B36C71A7 for ; Fri, 29 Sep 2023 08:03:19 -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 D3831106F; Fri, 29 Sep 2023 08:03: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 7CBCE3F5A1; Fri, 29 Sep 2023 08:03:18 -0700 (PDT) From: Sudeep Holla Date: Fri, 29 Sep 2023 16:02:53 +0100 Subject: [PATCH v3 04/17] firmware: arm_ffa: Implement the FFA_RUN interface MIME-Version: 1.0 Message-Id: <20230929-ffa_v1-1_notif-v3-4-c8e4f15190c8@arm.com> References: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@arm.com> In-Reply-To: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@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=3/hdIfSwI04CJ8YoVOAM5D8uyI/IOxahGfihf3h43bU=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlFucuyb+IhwHkIr8NkHq2LIo7vVzNfZRZsmBWR 4z6tmAq9BKJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZRbnLgAKCRAAQbq8MX7i mG9sD/908ogrCGeAYlAX2T65/u61ZJ7us0nLl5Uheh/+02XbBaRhe5MTBlWCuxDsgwR+evhSYU3 NwZ+qXzILP+4auBk2iAlAxfSh9tGliHl2UOOCsb8ovJaLgagrw0zXJyYJkwz5OPshhY5EkfMnt3 ffwMTulCVOv6iLyGnghUQsyxGZOff5IMuGouns2vqnmEW4CmLqDkBo1X/vnXefbZlt2Lz9eSAjO RuVdrdEZoB90GM2q/FCns3FFtmg/pb59uh4paZ8+kaoyQ+sB5GoZXg+Q17bbTlar9Ypm9Sp5Rui R8wcjmq7I58eIXNWwCbz6jVY1nw3X46H5JOEPXZElh57O7PajQLrJLV4pQwgXQH6PMaNwmd4d3l iJf+UbzPbDEo7JkBz+43MWhMEXGZwsQDAmOUXF0n/TQUBsqpLHHGZqbr42FJqoXo6qrjXO5fnNV m5rk4WRCOgmCzRZnE1ewRI1Oxdg+3QoUplO43iTFP3tZjUADnTQl8mQ8mpP0byodrXWaRIRSI0A P0Zl2+qvKUG9qZjgnrBGdRVJ7HoFU821Z2ZQ+KqxQNbHF3Xe5Y4yHN9gYn3sNukQx0PWQ8tSQuI BukTyIlcNQBrrUg3Loqo+XFukGt5Nlcco2QOziTsxJfSh8kWllWq4qle1u1bIHS2p6Gxbeg38LN W/D92epURHxVZ2g== X-Developer-Key: i=sudeep.holla@arm.com; a=openpgp; fpr=7360A21742ADF5A11767C1C139CFD4755FE2D5B4 X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_BLOCKED,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]); Fri, 29 Sep 2023 08:03:40 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778387762961718852 X-GMAIL-MSGID: 1778387762961718852 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 26bf9c4e3b5f..b265063e76ea 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) || @@ -708,10 +725,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 Fri Sep 29 15:02: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: 146612 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:cae8:0:b0:403:3b70:6f57 with SMTP id r8csp4107862vqu; Fri, 29 Sep 2023 08:13:50 -0700 (PDT) X-Google-Smtp-Source: AGHT+IHMQxkXgaswHx3k9ShjjlYcn30Z+4TfhJqS9oJU+m5I3ouxE5b3BnC4bakzGEMoMExrWwAR X-Received: by 2002:a05:6e02:1561:b0:351:4f0c:b968 with SMTP id k1-20020a056e02156100b003514f0cb968mr5306283ilu.19.1696000430348; Fri, 29 Sep 2023 08:13:50 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696000430; cv=none; d=google.com; s=arc-20160816; b=xhEgqk6E3ymPP+cEmjQ4B7kB4T0WENRSDT7o4pfFuccWgSBNcu3EqlL6L12qlVJweI 6Laxf0B3jyOrv3vFEdV+86nzFKpvNCLamKEnpGsFnb6Rs/x9rkgWju2HYfRQWMGwgB+7 cFkC+9WhKY9rdwmZCIdvLoeL+ZngKDSngDNz+IWOJD3v5BPukB+ll5syXVzM2E+SyOK8 l3eZFBPfibC1tTDGz9+T2UaRAmPsW01GU2n7tFJoBd4rJ2PBKI56Cw0l4f177qVZj9IJ nWg8rhCFivSD7EFFmIoGoBRoFFMA6HBortzOj1WaMEZgC+P0YRDlNhald4QYrwKLsmAf FTdg== 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=sNK/P7KB8KqTQkKt3VBpWTcjiTjAbC/j7fZFMOOxSgw=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=vOJyza3Uccyh+EuFtyo3n46Qnbjtp9cV6/bjdE4BRm8rvv7IgykiWQUzXVJNeGPp9H qkH37bDqbiznNHNwDn3ystuJ8S2dW6KnuwSECIjJu3LCYGpUNY+FLFT2A/kqEsPWS2Cn zBv14lQji8s2beI3+vEUL5+RibfL4vaofRP5jTjNzw4heB9X7p/IBlXBGakHe/HkoPQf OoQU2KRoNJWg81F/Gt2mKdHUD2A+GUBnXCBNStpNHmY1klJdKtkko4xg2SfS+vzRdBQZ P/hHuGvyyt65osdFpa+4dz3Jk7rEiPQk0yR0oPipxgpUAgpTzteg9U+qI//8Vlcxceqb Rg/g== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.36 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. [23.128.96.36]) by mx.google.com with ESMTPS id v3-20020a655c43000000b00565e5916ab6si21194811pgr.598.2023.09.29.08.13.50 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 29 Sep 2023 08:13:50 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.36 as permitted sender) client-ip=23.128.96.36; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.36 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 A95FE8122824; Fri, 29 Sep 2023 08:04:01 -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 S233510AbjI2PDg (ORCPT + 20 others); Fri, 29 Sep 2023 11:03:36 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44892 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233409AbjI2PDZ (ORCPT ); Fri, 29 Sep 2023 11:03:25 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id D77C71B3 for ; Fri, 29 Sep 2023 08:03:20 -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 0CAAD1FB; Fri, 29 Sep 2023 08:03: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 A9E713F5A1; Fri, 29 Sep 2023 08:03:19 -0700 (PDT) From: Sudeep Holla Date: Fri, 29 Sep 2023 16:02:54 +0100 Subject: [PATCH v3 05/17] firmware: arm_ffa: Implement the FFA_NOTIFICATION_SET interface MIME-Version: 1.0 Message-Id: <20230929-ffa_v1-1_notif-v3-5-c8e4f15190c8@arm.com> References: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@arm.com> In-Reply-To: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@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=NVitlqlRV6z20CY5oo4iFS9EKuyldYrTV9XNc0cCWyc=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlFucvy4pQu2saUIRdI36LiwoHG6ULgL6RfFRQi fMkLTenBjiJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZRbnLwAKCRAAQbq8MX7i mITrEACmc38jc6FrQ9DZH7qAj0dD8/GukHrMcd5qq5SLIcbmUX61YipNeM7Kd2ppRcbWZ/xGm2Q AulqjS6eYgOY2h27Rp5bcyYpVlxp23XO9No+SELhluA0oG9uwlJXihjfG2/RbtQxbV5d0gQ59d8 Ttd797Cq5/SSIQzAl98HZfRFnTBPv/gGN7yyIA92eJis8mpuW1jJcj4vPlooG9cqkE4Eb2aoraM agoNF6JPVw+qDCNyJKNq6igaw0zHlQzrT2Hv0OFuX88eHjZb9dtGaTRJ0saCtj/GC3G4LcD89qG ekKeFQL8jxcZQHCbSbcZ4CSUsFBe+NRTiNi7bvObHMlQgjPiF7Ucy9rX36ReR7iLh5suRXBd59g iMzZK2zKs3EKXnM5W31d2iT4pKgVgvSBhkF/diAH01uAXX9x4/cVVQ8n2Ji4tPajh/R9eNOSPIy c3NAvTm09R7x6E6YYE8b1gthZ9fiCiueKuyk7Dk8NhPHzyGVJn3ECcGVgO94aiH4rQmkZhrSORs vEsxUZiHHw+rYa1UOp0hmp12I2QBFv6nfY6nDdyWKnOmR0dAPVffO2OjvAPk0Z+xTRkZtK931JS gfZwD0xyCQPB6XHe9G52fWY6Dqr5puzKz5qDATddMmVtAx1Q6kM3/10UMRYla3G6kO623MzgD3r I/j4tJUpRtZIDAg== 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]); Fri, 29 Sep 2023 08:04:01 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778385346995950099 X-GMAIL-MSGID: 1778385346995950099 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 b265063e76ea..b0d1ddfe0230 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 Fri Sep 29 15:02:55 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 146649 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:cae8:0:b0:403:3b70:6f57 with SMTP id r8csp4132462vqu; Fri, 29 Sep 2023 08:51:56 -0700 (PDT) X-Google-Smtp-Source: AGHT+IH97yJovlwkjh/CXKVBi1vY/6QV+F+xY79fD50RQgADUS8SONk8mKDynfzvoOHflAgAV17d X-Received: by 2002:a05:6a00:21d4:b0:686:6e90:a99b with SMTP id t20-20020a056a0021d400b006866e90a99bmr4356810pfj.25.1696002716361; Fri, 29 Sep 2023 08:51:56 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696002716; cv=none; d=google.com; s=arc-20160816; b=vaHjAx+xLXPIZB3v8YqCE4veErGqBxYQs6j86JQ+DkXVictJa2bPN24fXuLgLxys/8 eixlL1b/Cz1XlYD5b1TJXEIY1lKOsucOzRzV6yXuCG6B7gx2RQqJXv4XVcB4iBP/vu2n 55nGAhnsbKlrFoDOw7svOvWZrcZOM/ntl03QWKskzr491Onk1c8upcvuRG5h/AqMOHZL YMd0am/Vs2BsOC23RQsoq57c85y42Ija2bRAHA+56oOxJ22DyojoJnXNW3u3IBViIR3U 8nu8wmCFQBGq9aAV/1W72HVIJMxS2bKgG6vKv44OGgdGUl4jjgEeMXvABP8Aw22ihgis U93w== 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=uR1v/cNMQj9N/l/kFTTmWGHerDcyD8FAsqwwZGMCTeE=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=oKuDtYwt8j9h29UTvPYsaOPTfLjEVm5Yxro3bPF4X81IJmlBcGAmZyCEFjya11yQef NdKDf4F3ZPaF6vI2yFg/qsT+rGEgJ4/G2VA5we40jYSgUZWts9jvBwB1+ZozooJF2LFR H29sLeHbKTlCPE5sy5NeXUTh4bxpY7q/nkDI+O68iD2lRUWGvSuqy6heQ9HnZN84OkkX Sav9/sAo2TckkyG1f5jrv7C9noC8o/oP7AuahoeeNqGOGuDy+CCDRWmo4QiP6LfRcNM0 K2q5H5zbzzE7YnfLJzHyGZ1epETgkGzjyWxnV4DBiWJJ2MzAigTzC2pftfIQv+3uABLl ZZFg== 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 f19-20020a056a001ad300b0068a54e524d9si22303208pfv.150.2023.09.29.08.51.56 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 29 Sep 2023 08:51:56 -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 57F5785632BB; Fri, 29 Sep 2023 08:03:53 -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 S233436AbjI2PDj (ORCPT + 20 others); Fri, 29 Sep 2023 11:03:39 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44922 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233442AbjI2PDZ (ORCPT ); Fri, 29 Sep 2023 11:03:25 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id 475A41BB for ; Fri, 29 Sep 2023 08:03:22 -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 3996CDA7; Fri, 29 Sep 2023 08:04: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 D75F33F5A1; Fri, 29 Sep 2023 08:03:20 -0700 (PDT) From: Sudeep Holla Date: Fri, 29 Sep 2023 16:02:55 +0100 Subject: [PATCH v3 06/17] firmware: arm_ffa: Implement the FFA_NOTIFICATION_GET interface MIME-Version: 1.0 Message-Id: <20230929-ffa_v1-1_notif-v3-6-c8e4f15190c8@arm.com> References: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@arm.com> In-Reply-To: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@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=WcMcF7+EWspNtIEKv7vhK+PdYzYtK3Hl6T1/APp/RSo=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlFucv9DdfP5qDeC0S7ZKdLh/2EacPtt+fAel+o gzGvF/3OYaJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZRbnLwAKCRAAQbq8MX7i mGymD/9pOqUOteL/bKSdzoY3NQCakLGj4XiCROjEievu5tUdHy0Zb3ttZk2FNhwO0U4GTs+zN7q JMY1pBn0Whe/TMy9uoR6QMHY6DydUrmxF8i/Xbg7acJwrYzP/EKGbHrD6nHsIzaw0fbVrZTqC5W LrCV8D0042hPxLhPqFuOrSa8Wi2xtDsE9HI0rV41qzg28H6SKgJnGLwavnGvlpsiAb9hjeNrrBC eO2ZS/vJ+VoZ10DcHBJrmOCXPVkzVM1KSd9nkazpTsP4Gg4NxFIQLNiCA24RT29pJm1F6Mz+1cZ qxPRFroeIabsRziknlj+JG2p/ezP4ZysriTfCWnUeZUIQAqxn5d1Xop+gz2dWqS5sg8ZkdHy9wa Waq9Ys3Mn/bEwq+JCFTqrN0bDJsdtsddVA/rahCLcpDrl0WoLDP1zmJlhf0JfD+JVEia/yhQ8Rn 9mWF/AJvGd8/xdy+e/iL76A+H34ZXxNZ5rP2/QmxJC3Ph2encmrjrISyXwXhuAzNwk9084Fa9ES 2rgkFA6HujhRSgn1MhgUDkGDnUJmLF57TS0LBZvuWspwiK7WEqM2G/sl2VN6ihtJIvaKqDfVSf5 dZm5IZsQJyr2LqWGDrPh+MiyyQMfHZ5qsHsD1tF2uccVe9AukepEBy0x29Bi6VSTfwjyt1PkpTd 9T/z+j/ZK2XvPBQ== X-Developer-Key: i=sudeep.holla@arm.com; a=openpgp; fpr=7360A21742ADF5A11767C1C139CFD4755FE2D5B4 X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_BLOCKED,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]); Fri, 29 Sep 2023 08:03:53 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778387744493536681 X-GMAIL-MSGID: 1778387744493536681 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 b0d1ddfe0230..02eedb7bc171 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 Fri Sep 29 15:02:56 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 146614 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:cae8:0:b0:403:3b70:6f57 with SMTP id r8csp4108275vqu; Fri, 29 Sep 2023 08:14:27 -0700 (PDT) X-Google-Smtp-Source: AGHT+IGXf3XFiJJm0laIFPts90Ve65nIUkVPkapcxyhGKc5iU3dlJqr65HLawfBGjHjRRyG/eTMC X-Received: by 2002:a92:cac7:0:b0:351:526a:49f with SMTP id m7-20020a92cac7000000b00351526a049fmr4705783ilq.16.1696000467439; Fri, 29 Sep 2023 08:14:27 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696000467; cv=none; d=google.com; s=arc-20160816; b=Tblty6lSaBv6FXuSywoTW3qh7h9AviIuFlVn+Jw8769uxRbpWETToIsFDk4RABvC8m E5hQzfcY1VZG62WsG2n6jO+IqqWlUJL4sZr0jV74I5uu/liM3EA3dL514epV/ZBC+Yz3 z1CF3ruwFFhGTbITXT32giNoudWkX3JCB90vMwjt+FDSn0Ncst77jNzNybC6qIlXQIHP tsK3mdIgJxs1lG27is/Pi5ANq3maK5qRWrSTl8oqNHU2QfeDHFFJXTHgbDD8i4CtTa40 xIsd4m0U+4/qS0NIGr4Bij96BijX+7PDWSXkVZfMlg5SYaXcif2uhkXdhxrj/KYM+e0O BiIA== 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=gSrBEK3fSkLZjrlXXPvOxyrY3ggFUpTu5+BdiRuI60s=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=FCQKi0oVBKNiCYVmLThncIudgzmt7TbsDUo+c4zrqOpHt9n8mHeGvytuuq45GlXDGa KBI+sb/Z46XZkw1Zww+0xeFTPS4tqVcvFIZAW9pYJ6bei8okJ48TIuUoNjlacXsbjyt9 kysN6zmiyYJ7On4m23tktOMu5oP6Pv6AAPiK4AJu+RvWNX37YW1umPZa+7mgT669gKSi db81IpXhk2Vhr2yPkNWdk89muXuGxXgJmNpHh/eM/l4kh4a8O6hFFlQqL1Ih9K6cC571 /23dOLYOfN0zunL3AU07iqJBfXMc2Md2I8R6FBDueDvherxsB3wAyZ9sqi/359ysWnjq PMrQ== 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 g24-20020a633758000000b00574057d7c19si22185138pgn.220.2023.09.29.08.14.26 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 29 Sep 2023 08:14:27 -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 4EBE7801B82C; Fri, 29 Sep 2023 08:04:01 -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 S233527AbjI2PDm (ORCPT + 20 others); Fri, 29 Sep 2023 11:03:42 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44880 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233461AbjI2PD0 (ORCPT ); Fri, 29 Sep 2023 11:03:26 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id 4F509CC4 for ; Fri, 29 Sep 2023 08:03:23 -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 66FB11FB; Fri, 29 Sep 2023 08:04:01 -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 103C33F5A1; Fri, 29 Sep 2023 08:03:21 -0700 (PDT) From: Sudeep Holla Date: Fri, 29 Sep 2023 16:02:56 +0100 Subject: [PATCH v3 07/17] firmware: arm_ffa: Implement the NOTIFICATION_INFO_GET interface MIME-Version: 1.0 Message-Id: <20230929-ffa_v1-1_notif-v3-7-c8e4f15190c8@arm.com> References: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@arm.com> In-Reply-To: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@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=3494; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=dQUQF6aKVXxeLM41f9K20i0Yq+P0jCynjIfIlm9Bp8g=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlFucve2qtLbbccIMHbNg0cUf8hiyVYCCGIRU/s AUdAu0DaQyJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZRbnLwAKCRAAQbq8MX7i mL5mEACznJSiwoQJn1cxlk6mI1vNela97vgqL1j821bBPau8I9q9uEkahsMEkK8ZMejEntkD1c2 JgdvOhL3f13iNoysjiebYplIRPJF36hgRQ9fdwsv+bVL95NtRcoliH8dNvPY1ftgpuk7m/cfZbT /Yb1wzb4hklyhzCb4XW144DqTaElVUsaeTRoIIKZCWPnwXNuWgVmB2/xHfBm91m0SDz9o6w3ZD6 8IHsknrXCp5Y1ETDm9EvfTVzHgx3N8MWbBx4ijgUrIHhpLpMtpw+ooJa4Jnl2/Dnq01WUODNcVS ZjTLOkkE1gEBGjZAlrgXm8woWgAMdyjlXMlYaOl2LUmHmSGx6xKigCLvtdQoJ8cVobgY5PzlyTo VXaoLW5r6mIzMe1mOcbcJIddUTm0+a+GFyASb1ob+fCnjemXUlmMx+re2lIzi0La+Z1WLSQlgTj fpXAdk74k0xCEjY7oVPlB4Kbn4hgRatx7Fr6QGuif6dNdZq9B91nK4dJxjwQUXP6ylWlPJ35/6Y W+FopXFpC9zYyOPxlCPPTWu3bTrAad4gbFUFWjg5i7LZqcQeRUmMZYDY/CAATfRwHwfy9ncUvPP wjAcBOYAbLC4+vNjcV08PNxX9UH8ExHo6oYxxvsppBx5xWaVUfiCl8FZ1cHfiZ94R8/zX9pnI9b oqr4LayRyO3Zs6g== 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]); Fri, 29 Sep 2023 08:04:01 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778385385875798191 X-GMAIL-MSGID: 1778385385875798191 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 | 70 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 70 insertions(+) diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c index 02eedb7bc171..dfeeb751bebe 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,69 @@ 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(bool is_64b) +{ + int idx, list, max_ids, lists_cnt, ids_processed, ids_count[MAX_IDS_64]; + 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)) { + if (ret.a2 != FFA_RET_NO_DATA) + pr_err("Notification Info fetch failed: 0x%lx (0x%lx)", + ret.a0, ret.a2); + return; + } + + ids_processed = 0; + lists_cnt = FIELD_GET(NOTIFICATION_INFO_GET_ID_COUNT, ret.a2); + if (is_64b) { + 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 Fri Sep 29 15:02:57 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 146651 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:cae8:0:b0:403:3b70:6f57 with SMTP id r8csp4132484vqu; Fri, 29 Sep 2023 08:51:58 -0700 (PDT) X-Google-Smtp-Source: AGHT+IExvLuoKH9Oczex1xvN+1LZreMiWB3VB0yONgrRd4YFt8OeF/w43baWJeMLTDtX3VYLaQ4m X-Received: by 2002:a05:6a21:3282:b0:161:4459:c62c with SMTP id yt2-20020a056a21328200b001614459c62cmr7257211pzb.18.1696002718279; Fri, 29 Sep 2023 08:51:58 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696002718; cv=none; d=google.com; s=arc-20160816; b=LzHZOyi6eM7n3BcFBxjwZEgWRHMDlNqA/A6Vgudu+erU8XoHv4Zh8/IeLUS3TEW8ii sNOPmg8qSumHC5NW/oo85T6zjJ1AFoCC1r9qcaoS+pn/5Q8fp6FMCbzIJCpRIW2uZBYC pSXWLn2M1yRxG7VENMv0DvTVXUCR05EQp2QEzw5ikVaJ7mwf+1t9lDrsr9c9kKlJwFg1 IW0GRqYZ6un++zH8TjhEe2onBDgu/kz+9wfzt6PLZJTCf0WsnlHucB/kueYRQsZjvgoZ xyJjfOBW0wr/CZudwOlRBZ8y6YVDOBGshpvAYJ/83JAdncsFMiKDmdDKC63kQoxWTh/Q 771g== 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=LOnIzxy8EdGLjjBTEWpr2mIfpHs6+3d+IhYaSe/+QMY=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=qHAqrj1IlImKs8rBbrtgsKsuiF2a+58ZLMW7dCm9/8S+lP2TPWpd/lrxiShcRfW8kx CRlpHSsaxW5fJ6u1BY0ehPRflQ54kK5wHiqr++oGtmRpW2mT5MMzgQmu0Wnd2nmYLLfB tahHY4Y0k34emvFVLvdnNXYK7zuf28zWu9sG6qyD3I2cL+ena8RN3Xm6VoCKVqUeeYHA wgMvJgJWDvI1hONZV6oSn+C2vBI52Q4uR3DIf3MIpdCiEsnLl5siqbzHo72/63unpqKg DmYfM+lyFk/yklHKMZg1607x/Lr2cjzTF1LNvDH+K2qSys+BRknWHy2AECiAA7JflR0a 3bFA== 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 a35-20020a631a63000000b00573feb1e7c6si21260777pgm.888.2023.09.29.08.51.57 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 29 Sep 2023 08:51:58 -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 CD1F585632BC; Fri, 29 Sep 2023 08:03:51 -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 S233473AbjI2PDp (ORCPT + 20 others); Fri, 29 Sep 2023 11:03:45 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44906 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233367AbjI2PD0 (ORCPT ); Fri, 29 Sep 2023 11:03:26 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id 6D19FCC7 for ; Fri, 29 Sep 2023 08:03:24 -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 948B91007; Fri, 29 Sep 2023 08:04: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 3DA393F5A1; Fri, 29 Sep 2023 08:03:23 -0700 (PDT) From: Sudeep Holla Date: Fri, 29 Sep 2023 16:02:57 +0100 Subject: [PATCH v3 08/17] firmware: arm_ffa: Initial support for scheduler receiver interrupt MIME-Version: 1.0 Message-Id: <20230929-ffa_v1-1_notif-v3-8-c8e4f15190c8@arm.com> References: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@arm.com> In-Reply-To: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@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=7567; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=cEqV4YVf1LWm1xYaB7cZIwUpKEDLEWd8Uc3+Kj3BYQI=; b=owEBbAKT/ZANAwAIAQBBurwxfuKYAcsmYgBlFucvCcxjPXx8TBj4nbCzrmy1KuOnDdP4lGixl 6UZ6ZzDsruJAjIEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZRbnLwAKCRAAQbq8MX7i mJWaD/ifHyJbruDUC9theNrtvo0jGb1ru5UA3xiOU0FdjmfkTlfhzrKsEIf3vD/VNiWrVIrLpeh iQD7oj49Afj2+HakhGwbMo1ML25XWx8ZA2TFScS1VISOorUwxXS0+s8Ve8krpWjQRaztztHRiQP JDjtuBIa5u9fw04zDIsPPyJE4WpAPaAv+8vjG5dzjO6caEmnJ+HJNsn2aKFeuJ4csOXa5yATwGk 8gvOk7wbJ9/PIKlU1/+UcXPWpyA3ZpBpVbaMho7X7D/142ZKGvp2L8F3YWo2Z1okmafVUbrwyNq a6hgu8//Ux/MjxiQZVHww2tpc44zqr+TeWZwCa8NVGO7bA8U6XLx9eyaZ16PigxKMXnFnCeyBzc EK451CBMexA+OmxNNLSgDsHgSzxROs0SuSo75sPoEIjg2KZ1yS9eGNVOkLBbdGUhQQHvR8FeOhf sw6NaJdPLAPqjv6dcfuM/bm155YP9GbJsl97CkXjHZuHcVGTTCkTL2pYVMsxIimUd5gWKnXOEhe BP4gcnAlQSLEe6aKPsAGEtiphMBcfQo0EO8wquHZqE45eOF7QZjVYTsZmQp4XhSYsvYfQ2zwktP syZVXcfXmPIeVpY7tsvAj62CY+Nho0TP0PJCEK0S+atI+XGQWbUTBeoBJPFJxvAqTLNOACitipc DA8CCM3Y9PMV4 X-Developer-Key: i=sudeep.holla@arm.com; a=openpgp; fpr=7360A21742ADF5A11767C1C139CFD4755FE2D5B4 X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_BLOCKED,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]); Fri, 29 Sep 2023 08:03:52 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778387746477420223 X-GMAIL-MSGID: 1778387746477420223 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 | 192 ++++++++++++++++++++++++++++++++++++-- 1 file changed, 182 insertions(+), 10 deletions(-) diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c index dfeeb751bebe..a0c80eff04c4 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,12 @@ 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; + bool info_get_64b; }; static struct ffa_drv_info *drv_info; @@ -922,9 +937,153 @@ static void ffa_setup_partitions(void) kfree(pbuf); } +/* 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) +{ + struct ffa_pcpu_irq *pcpu = irq_data; + struct ffa_drv_info *info = pcpu->info; + + queue_work(info->notif_pcpu_wq, &info->irq_work); + + return IRQ_HANDLED; +} + +static void ffa_sched_recv_irq_work_fn(struct work_struct *work) +{ + struct ffa_drv_info *info = container_of(work, struct ffa_drv_info, + irq_work); + + ffa_notification_info_get(info->info_get_64b); +} + +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; + } + + 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("Error registering notification IRQ %d: %d\n", irq, ret); + return ret; + } + + 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; + int ret, irq; ret = ffa_features(FFA_NOTIFICATION_BITMAP_CREATE, 0, NULL, NULL); if (!ret) { @@ -936,15 +1095,24 @@ static int ffa_notifications_setup(void) } drv_info->bitmap_created = true; - return 0; -} + irq = ffa_sched_recv_irq_map(); + if (irq <= 0) + goto cleanup; -static void ffa_notifications_cleanup(void) -{ - if (drv_info->bitmap_created) { - ffa_notification_bitmap_destroy(); - drv_info->bitmap_created = false; - } + if (FFA_FN_NATIVE(NOTIFICATION_INFO_GET) == + FFA_FN64_NOTIFICATION_INFO_GET) + drv_info->info_get_64b = true; + + 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) @@ -1002,7 +1170,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 Fri Sep 29 15:02: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: 146640 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:cae8:0:b0:403:3b70:6f57 with SMTP id r8csp4126652vqu; Fri, 29 Sep 2023 08:42:15 -0700 (PDT) X-Google-Smtp-Source: AGHT+IHGA3JAUWEJVi/pMWQpOtXdBDFW4FYY2DtIjVWYOLIMBY4SRkAhi2akjV4QttqjECZLwT8+ X-Received: by 2002:a17:90a:cb8f:b0:273:f584:40ca with SMTP id a15-20020a17090acb8f00b00273f58440camr4336327pju.16.1696002135450; Fri, 29 Sep 2023 08:42:15 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696002135; cv=none; d=google.com; s=arc-20160816; b=WubG545bctgAxW+vvusRLpxaV5CaNkLQcQogxTfcnQiFkfsZavgPY4e5IodaT9TGfA VJVKqqjYT1Faf6QgU3zZ2tBwFZ44z++RZlyBI98b5JrLXgJ1HZhg7u1mioi/DJ1QyVst 4qVGGIsQQvwMXXTLvH59CJIbw+mKtvFGozXMacMtD/KJU/GdeF6Z6qpn7unkXwXKKmAC X+NmBUTb468ddXO8PRouZDIcRVVL98WyVL81oKq/VCqMOOXoGwpXVVWDWWdmptuPaCl3 QTLiFGOWOlcTAoTNitS+Awy3qai7hryXrugbmssPkmk8nN2fxjMVZsG78IV7UIyu++qE HMRg== 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=3BKBLBzJNyW2sxOMwC9DqkeiXSEw6AfO9XEAb9wLims=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=f+UCNp2nogFoWSaf6lfP2FlDEtbCBpf1HwDDqiGBchGeaG8iVig7nddr+yHuFWPRDZ 0qp8Wf0W1QrXlbZqPE8GzcX9Q9Bv+3oFKKD1uYt9i4AeoAqcL27j9XRVKbPHybuY/XyU 3UXMzqd41X4aNberNb9SRT42F2vOQhz67scRJeejt8UHFj9r7lNuQmdpNH9a89XnpgY5 WNrBPmIUeppyLhU2yvtSvefOv1wJFzG5r+sFFQuWorIknLwKmRksxNh8I55Wj8q2gc3Z dKBoMqv1TK/RxuczfGqUu4nETNy9HeyMPdygTQSFU4wYbchUksbw+nGIFKIUd65WRhFG a6ZA== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.33 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 lipwig.vger.email (lipwig.vger.email. [23.128.96.33]) by mx.google.com with ESMTPS id na18-20020a17090b4c1200b002774ecb2ecdsi1954006pjb.19.2023.09.29.08.42.15 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 29 Sep 2023 08:42:15 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.33 as permitted sender) client-ip=23.128.96.33; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.33 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 lipwig.vger.email (Postfix) with ESMTP id CDBF782A049B; Fri, 29 Sep 2023 08:04:08 -0700 (PDT) X-Virus-Status: Clean X-Virus-Scanned: clamav-milter 0.103.10 at lipwig.vger.email Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233553AbjI2PDr (ORCPT + 20 others); Fri, 29 Sep 2023 11:03:47 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44918 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233424AbjI2PD1 (ORCPT ); Fri, 29 Sep 2023 11:03:27 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id 80EE0F9 for ; Fri, 29 Sep 2023 08:03:25 -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 C1D761063; Fri, 29 Sep 2023 08:04: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 6B2203F5A1; Fri, 29 Sep 2023 08:03:24 -0700 (PDT) From: Sudeep Holla Date: Fri, 29 Sep 2023 16:02:58 +0100 Subject: [PATCH v3 09/17] firmware: arm_ffa: Add schedule receiver callback mechanism MIME-Version: 1.0 Message-Id: <20230929-ffa_v1-1_notif-v3-9-c8e4f15190c8@arm.com> References: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@arm.com> In-Reply-To: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@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=6815; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=QTjl2nGOgYZchW93FMLg30GznbSP+X31xJeCsksgTOY=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlFucvtP8Igd7LIpZ/OnLROdVloX0hZBMHnKWgp +rQrd+fzceJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZRbnLwAKCRAAQbq8MX7i mLzaD/47I2TU57DiWYGfG4LsOVQum65Qk6vaX+/RJ2Mqjwe8fHP5nynmS/L+E6ijv+ks4Y1ZwtZ jICzHYSINpp7L2ANkE8p84gMopNfwKVR23euvEGUBBHlCQDwRAHA4BGmasVm2n+AvsGWMEFKnrT TaeqNmMNa676IMmu1IltZSHw5h6C7GTiX/9UJx2zIgWNkRP+6a29P8P8NCgeyOEmAYXlLfO1AmI +PQDUvQ0cZWWTdvbtxTeGmQrbgqFy+7QuZ0RtxqOKrAWRyK4at3qofTsd970nWgHAtbxGDQgepR RBH2ACcCX/NCApIVZWI8ujAj2D1Z8K9BEfCbPf4g3PtrM1gL7ovpdIFL9mKRFQ6R2H95HJbcfx8 ip9SA+DSyolWGdZoaPzuUMW22D4pob06jjcl/YNWIzKlMIn4jI88j4XE5wZTDzv0h7V+NKPERNm l9wpP/PoLi6AAa+ry4Zie7zlDhoobTpd97pECTuHBJ6AOhh8ECR/MIRF0K24UwKtlCWT7bBIVXo wGjOSmBt8EIEkqNCjvrwIlKp+v6UvqfFg/57hI7fVonOo7Z3+0rBKOmfZRK7SxEZXfyoRoEmdLB chdcC8bIbl4uvGvu9bkd++M+xFHrC7IF56+vVb98+hGA//Qudznlksq8VkxmhNIan8OQFRLjDCS gYbDXIUu1891Xnw== 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 lipwig.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 (lipwig.vger.email [0.0.0.0]); Fri, 29 Sep 2023 08:04:08 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778387135112023236 X-GMAIL-MSGID: 1778387135112023236 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 a0c80eff04c4..64f9c9e713d1 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" @@ -100,6 +101,8 @@ struct ffa_drv_info { struct workqueue_struct *notif_pcpu_wq; struct work_struct irq_work; bool info_get_64b; + struct xarray partition_info; + unsigned int partition_count; }; static struct ffa_drv_info *drv_info; @@ -695,9 +698,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(bool is_64b) @@ -851,6 +871,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, @@ -871,11 +924,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) @@ -906,6 +965,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); @@ -914,6 +974,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); @@ -933,10 +994,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) @@ -1172,9 +1265,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); @@ -1190,9 +1285,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 Fri Sep 29 15:02: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: 146627 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:cae8:0:b0:403:3b70:6f57 with SMTP id r8csp4115921vqu; Fri, 29 Sep 2023 08:25:33 -0700 (PDT) X-Google-Smtp-Source: AGHT+IHv9hamaH2FSOSnU9KjIUOQ70SiLZ6aNwTjuGZbb4ospmiJDKPdUYCou6CYpF3pft2goAHM X-Received: by 2002:a17:90b:fce:b0:26d:17da:5e9f with SMTP id gd14-20020a17090b0fce00b0026d17da5e9fmr4215283pjb.1.1696001133476; Fri, 29 Sep 2023 08:25:33 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696001133; cv=none; d=google.com; s=arc-20160816; b=yD09hxThJC8LzmAvtpDHHXhOVofBRPCiEXmFt7Fd9ROe5YHt4bQrT2x1ymJCycjg6b 3ljz8/Ca8xyGl9LY7koSQPPhZ996y7nu+LE5WfffjJPmyn+lev825G1+QAWS5bCbgpme zZjnoybQEYpM8Jlrq9yu8GDB6T9xe8/u5blyTZ+XhpFYTnOoBxCSSN5c4jgzPwPOwyC3 058dQBzVucik6/8nVaTP1XZh1zxU4txPVIRZZ6KRu1P08Fg531Q+XBhvXVv/zPrjXf6S 7pu25GEf6/EZZqeQ63vEBTlczXmvESgrl4SRINCKo0x/WdHvV75VfHG6/ZP98nDaRVdE ceAw== 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=QPStR62JHxVdUWT2p4o+0wowkJgiZXSUPBVJr2dNC0Y=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=dcS9TSzxCXRQEOBk+5LbBSjH9Ds7dD7sNqZLdW6nOLUB3Z5UheVJ/h2IHRo8V4pQ/9 b8GFEwTWxhyGnRwPpBGJyakc4zdwCbu5grZ5ujD2Rdol1EFBg6XLsE07RcRwAjjMlJWH cC9GVvw4vuzfcPGOJwpDHSQ9rLp58dD8LtaAbjdr2Nw641QWvO0y8SfM8tJ1gKzSAXAr qmEQqKILr/sXen82nF7v4dMiXYwWRnbGOqLzcW9bf073rAeM+YX+wwUy2XBirxrMmr08 vOQy90HEHuTrxktzxRT0tIbYyoFckqIvnWNE+iOHqHqLV+sbkfaSUlT7putCiQxiFFwy k1fQ== 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 lk8-20020a17090b33c800b0025bb4a1c12esi1945860pjb.148.2023.09.29.08.25.33 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 29 Sep 2023 08:25:33 -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 568BD8373211; Fri, 29 Sep 2023 08:05:19 -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 S233518AbjI2PDv (ORCPT + 20 others); Fri, 29 Sep 2023 11:03:51 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44854 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233434AbjI2PD2 (ORCPT ); Fri, 29 Sep 2023 11:03:28 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id ACDB11B0 for ; Fri, 29 Sep 2023 08:03:26 -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 EF1DE139F; Fri, 29 Sep 2023 08:04: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 985543F5A1; Fri, 29 Sep 2023 08:03:25 -0700 (PDT) From: Sudeep Holla Date: Fri, 29 Sep 2023 16:02:59 +0100 Subject: [PATCH v3 10/17] firmware: arm_ffa: Add interfaces to request notification callbacks MIME-Version: 1.0 Message-Id: <20230929-ffa_v1-1_notif-v3-10-c8e4f15190c8@arm.com> References: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@arm.com> In-Reply-To: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@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=6933; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=OABTEeQ3MAALLW9HhMJwEV1Db8srfXnLIyC117qcUAI=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlFucv3MQlmS7vh34so5Kxq1Y87woU7Ne8OlI2E z3hoj7GugeJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZRbnLwAKCRAAQbq8MX7i mL76D/sFwlsLqNbOXji9IdAZdx4tXI1SvlkNcbBghOJYaA7HUI7wJ5Fpn8C+QZh7vt/L7sljIEp OV6ib4vIO0kZGBlDKzbiyz4vKux+gwE4rwetIg7w4V+ToBwdPID2ztbSPhzKu35lVlU7HUstRXK QifmXswQvY+3JygYPm81dzH0zeGKCP4YRORQpB+bnwZmwJjPhMt85g4yFAPNtLJraKfOOpAvdDj Gd/mlToVfodxMgWXPXh3wvvMDFBcaDNugTSDmzsUoJF2DAqTbjJRk8fHRctT9c/EGUBrNo+MI4+ mZxWhMcUJrcuShuDW58os/wk8++8AwNkdeXOVZRSvwBlPzhI5kkDPWY7ZEAW0+DszRQ5ZPS6Cdh tybWZUB2uZtaDMBggNhFxVdVTjsmSj9CaDy2y/Q6pR0ijO8nunCDWJg1n8dbLcw1YtB3waKu9x5 aDNH1w0/gRxlW3IcYxA5UEIbSYA9UEI1vQro/dZW+mealB3VRQgpk1l2wMq8gTcXO4zmEFas1vE 2gDRX5eZOXTB8zKt8K3fH5fzUr2wV1nA2GQ2rELBEoV2SO5RYKaxBPaVoIy9/PFt2Uq/mY5ybss 6+el2Kfa1htu6Mlpw2H5XM8ooQvIZozPjx+3va0E6gwO5bNnGUSom+cDc28x74kj0+C5O6G+j2c gHYazd5wKTyt1RQ== 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]); Fri, 29 Sep 2023 08:05:19 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778386084495864350 X-GMAIL-MSGID: 1778386084495864350 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 64f9c9e713d1..55707a5d333d 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[] = { @@ -103,6 +107,8 @@ struct ffa_drv_info { bool info_get_64b; 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; @@ -627,6 +633,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) { @@ -871,6 +879,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) { @@ -904,6 +927,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, @@ -927,6 +1067,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 = { @@ -1202,6 +1344,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 Fri Sep 29 15:03:00 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 146653 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:cae8:0:b0:403:3b70:6f57 with SMTP id r8csp4132604vqu; Fri, 29 Sep 2023 08:52:08 -0700 (PDT) X-Google-Smtp-Source: AGHT+IHBD2YNGjEiwb3qNTYnRMTEZUMgptzf9nAS6UaVA0xCf48KcK6VZBuOegrMN5X7ENEyaJCz X-Received: by 2002:a05:6808:10c8:b0:3af:66e5:5d3c with SMTP id s8-20020a05680810c800b003af66e55d3cmr6222500ois.26.1696002728672; Fri, 29 Sep 2023 08:52:08 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696002728; cv=none; d=google.com; s=arc-20160816; b=UKa6eKwx5xHJRdweJAjLsYh6XnFMlgSBD0bWnZ10CrIRFkaeRQ22lceAnsh67jHugO PR1Nc83CKfj8i76+bvhSaWc/2L7H+OIY9wLAcN0+o+309FeW7N4ItBdvEVv6fo+OCDut P4z85EFDAIoBPdoJEMFLor3KugmbRfypynDGxd8UojHWYIbloTltY7Gqebsi8CsjtuUW lr6pavkfPjelPTgNnlGYUsJYpM4Z2GALY5ZGuK+t4PJV96f22+C3JuleE6N4oEXekmNl aA9RzGnyJqRQHaptTWpVOwrca0yOtup3CZvJ6KYSr4Xpj21tFCTNr1zFqM511qjyl9sL vMAw== 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=CMdn9+9dr3HxLhOw1HJDN5FBxqkHe/3XhNGo6VSBmKo=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=Igg05uz0yaelCKZRloFvBq09fI/2w6tnL4MlI1mIFq1aVfRM9cbR6SgGnjO5hjks+c 8BAhKXo215XXtLScHHRgANFMvwzv7EneHQsVOPcK15pu4lyoFxgd75h4ZkR1hXstN66e FCeqNfV0SXoicYRlDLiFUPOvqyw1O6JLBDJ+oyHVkHMf3JseUinBZitTkC/Dme8wM3M6 r9x6yYsjoN+y88jtJTK0AWxNRJaGqyMPpkpFe6ZwGZ87p/L164r6+L/qQ99RlyKctEFF jk6avkMFGz+cowfq7BmkCvjLIDiGZPoCR2fLkgoHatul6rmaFEQ5GTaZ+VUDpMU79EIB YNkA== 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 v190-20020a6389c7000000b0054fd947f66dsi21673945pgd.210.2023.09.29.08.52.08 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 29 Sep 2023 08:52:08 -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 40FFB856B109; Fri, 29 Sep 2023 08:04:00 -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 S233618AbjI2PDz (ORCPT + 20 others); Fri, 29 Sep 2023 11:03:55 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:55542 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233418AbjI2PD3 (ORCPT ); Fri, 29 Sep 2023 11:03:29 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id E41911B4 for ; Fri, 29 Sep 2023 08:03:27 -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 2845E1FB; Fri, 29 Sep 2023 08:04: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 C59123F5A1; Fri, 29 Sep 2023 08:03:26 -0700 (PDT) From: Sudeep Holla Date: Fri, 29 Sep 2023 16:03:00 +0100 Subject: [PATCH v3 11/17] firmware: arm_ffa: Add interface to send a notification to a given partition MIME-Version: 1.0 Message-Id: <20230929-ffa_v1-1_notif-v3-11-c8e4f15190c8@arm.com> References: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@arm.com> In-Reply-To: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@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=f4Gw9qi5dW5Ef+rKySqOZWY9UgWqEziJ+T29fyYYAJQ=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlFucw0qDNmU79mdBC/Sm4VFjwdP3A5KYk8XFDF lr0YD4RIgaJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZRbnMAAKCRAAQbq8MX7i mEk5EADEAWUv/82JqDbfhVrIMI84gpGtF67+Q77nDFptg0Czw+joaWzzI78ZRTQFg3lkwfn6d82 N49R/38j+mg8mpP96clRyYmcnDs+jkCmMXEZPyrfs31rlMBMdFzILvcUZFOsHhke69LQJJHLFEb w/eqzS4FYuXiHmxsfopzHI8o9HSd7dUCrREGSegHBSd+Qub4UbjN29sQfUyUHUJOrcKkqvzCxnp 7O+D21eP//W2KUVkN7nvTf34yAl7VBVMRAf7S4W2TYn6XmFAeMnzV0T6xZcyy8p29zYqqtCUTef iLGunKeDB2sYEyUQTAuzg5TbH9faXqUd+o60UrjQPqjNE9yEfutyMlbY3IbIwVwbBgCgAtkFEDx ZGw4XTLAWKtoh3MisocU+yEFeGLAS9Luv1ANBivu5CjOzpCbbsIlIh0rG/kL0jWSwATPJ/OzIRD 7wQWzblYr6tT9f+EiswyTjVI5LbxDcuVOCWlKfo6jyMJ6pXDH89GkbPDXwfceI6sp8TJmXCV1DL dx7Hs9cLKXYKoOqNUr8nnklk/Le/GCfs+rv6QDGcHVGpSjBKosswxyMSb67+iAbGhEj0y0Ezzq+ a00K1Bvn1zDjWzRm/jrBLCki+vESjEOGUPlGsNZLJhoHAsG6oJqtK+JAkVZiSDYqmk/nJivdBTj VULpEsARIEChWwA== X-Developer-Key: i=sudeep.holla@arm.com; a=openpgp; fpr=7360A21742ADF5A11767C1C139CFD4755FE2D5B4 X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_BLOCKED,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]); Fri, 29 Sep 2023 08:04:00 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778387757068021532 X-GMAIL-MSGID: 1778387757068021532 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 55707a5d333d..94e39ee83278 100644 --- a/drivers/firmware/arm_ffa/driver.c +++ b/drivers/firmware/arm_ffa/driver.c @@ -1044,6 +1044,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, @@ -1069,6 +1081,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 Fri Sep 29 15:03:01 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sudeep Holla X-Patchwork-Id: 146615 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:cae8:0:b0:403:3b70:6f57 with SMTP id r8csp4108302vqu; Fri, 29 Sep 2023 08:14:29 -0700 (PDT) X-Google-Smtp-Source: AGHT+IFVnxoyH3+APWSn/S+8X8vzWqR2GYvUBDis00EK3bkb71Cb3hmCwP50CXMroIEvZ4gJHL98 X-Received: by 2002:a17:903:41d2:b0:1bb:b226:52b1 with SMTP id u18-20020a17090341d200b001bbb22652b1mr4733733ple.17.1696000469677; Fri, 29 Sep 2023 08:14:29 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696000469; cv=none; d=google.com; s=arc-20160816; b=sRmhOkCPbIOrs4zRkV+j3GNK5pxG5+cpT68D+TyRHtMWJerd0xIyWJIwS6lqHdFnMy hkhM1wKgmCgFXOcri+TY2vmK78vx65KreSkSj8woBZrRSxTn0Bp5BBiK9KKp8Br1lifc Ptdbm3SxF/JPcZc7x0rUQJHowfY3+o9oOYLIyoXQGmLTHUGrKmIVfwYxHPedcCEsw/gn KLi75VS7Nu/bHvBiTPJKDO49HKrgwofmbRb6vH6hZD/4T9F/4Ra+8EAOm5WLO/k8AH8S 8iJGaSUB4yiHuIo3JfG9xgNGb4OXWlrII/aBtjgLtQhguJFdc7WvSo8ONg0FdA9/DT2h y4Wg== 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=ne6GPupkp+d5OsPILfDUBCgXeTm7nnbHvlUSC46/pFk=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=CEF01id15Iv1SA69AKPa8lUnBWcE6V10ovZCWD6AYXc4ij4px+kVCIDGOlkZlcBhwf xlH2QqbfEpzqK+sATf088pLpynMzwDrof0MsdcJgSWQflSfMGDBpSq2kLeOkDogw6TQe ru0lLbzMhtoPN85tbExp/cf4o2VcY5r2RWOf6+t/DfMQvnag7l9upMLRZiAgY1JTRLQV GPGmIkMrroh7nncDTjn27MnAHfFGk/WKfrqWFAWdu1P34O8GGA2PfWGxWQuARXSNha6A YjAcscyCuQijfHWl3q71/meLkcxPsLQfZX6lU1MvMhz0lmbX4+d1oKhZHuR1x1QMitpL 5UWQ== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.35 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. [23.128.96.35]) by mx.google.com with ESMTPS id x1-20020a170902a38100b001bf20c80685si19778417pla.125.2023.09.29.08.14.29 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 29 Sep 2023 08:14:29 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.35 as permitted sender) client-ip=23.128.96.35; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.35 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 D9FD880E0A13; Fri, 29 Sep 2023 08:04:33 -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 S233418AbjI2PEA (ORCPT + 20 others); Fri, 29 Sep 2023 11:04:00 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:55594 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233477AbjI2PDb (ORCPT ); Fri, 29 Sep 2023 11:03:31 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id 141AF1BF for ; Fri, 29 Sep 2023 08:03:29 -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 55718DA7; Fri, 29 Sep 2023 08:04: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 F2DDE3F5A1; Fri, 29 Sep 2023 08:03:27 -0700 (PDT) From: Sudeep Holla Date: Fri, 29 Sep 2023 16:03:01 +0100 Subject: [PATCH v3 12/17] firmware: arm_ffa: Add notification handling mechanism MIME-Version: 1.0 Message-Id: <20230929-ffa_v1-1_notif-v3-12-c8e4f15190c8@arm.com> References: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@arm.com> In-Reply-To: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@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=4004; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=P0A5RMcFNkidNv2DNz6gtpSgVPPefciFbLXlHTbsR/M=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlFucwYmIkcIk2FrlNkANdeNEyh1b6LuU9cIg6j jetsf0+Ho6JAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZRbnMAAKCRAAQbq8MX7i mJwoEACek+U4yIiIyf+5+1Vh7WX8nlg+7YdLyiDPGJYHdqU881l2wYDmoBWzUK19uCCgbFPgGXv ZUVO/jtWZHzOEC1wjgPqt5GTcWcnOt0m5H4NMoSR4AfzZ1eKTFxGRiW9tJVxFVl0NkRgxGGaP9j Q2Emlt3TD140Qd+A3VSJCzq9fj73LIaN3iDy0kk9QFxHPiU1TK8Mp1deUeJFC8l7iAFn+xWo7m5 d1yqm5NcMcxCQVF6J4gS3wiGTPHrhDPnPNHTefpTFHGK5YrNlGaq8A6S33T3PlYN5BKR+JqW7SF CADpA27cPbfNbUznDeM6Fq19FwLCrNmYIC8ZaCUMoHfDCTp4t6gL6Z55kRx+TCikMvyxgk4P6sO 1lK4Q0K8nlx42ck/2b+Y8ZFsotH7zRlRZanCTU4uIvEtyuZQcfhtXhEK3jG7Eub63YfqntyOLCv 1jgzman0nENiAQ+jfiOSIYmOM1YYzFclo9DgEOYMYSWwBCPvV9u4G/AFHmg0wk67EfGlS4+jdYU JDdM95MHp9GRpO9C9vPfq9Mn8zCPG43/ew1PrFb+8+XoRYNBgxzsOftfJ+I9UDRMdjh0d+LQxUF NdngDiMl16m67dHvft3/T6GRck9IDJPmsnk0wKMosXReNgB+CgQ6BxmfT+k6Tf+OOo7DSaX6FO1 aox1d4DkRrF8gSg== 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]); Fri, 29 Sep 2023 08:04:33 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778385388697754843 X-GMAIL-MSGID: 1778385388697754843 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 | 65 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 64 insertions(+), 1 deletion(-) diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c index 94e39ee83278..28bf345862d9 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; bool info_get_64b; struct xarray partition_info; @@ -634,6 +635,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) @@ -1056,6 +1061,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, @@ -1160,6 +1213,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) @@ -1303,6 +1363,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; @@ -1360,7 +1421,9 @@ static int ffa_notifications_setup(void) hash_init(drv_info->notifier_hash); mutex_init(&drv_info->notify_lock); - return 0; + /* Register internal scheduling callback */ + return ffa_sched_recv_cb_update(drv_info->vm_id, + ffa_self_notif_handle, drv_info, true); cleanup: ffa_notifications_cleanup(); return ret; From patchwork Fri Sep 29 15:03: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: 146613 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:cae8:0:b0:403:3b70:6f57 with SMTP id r8csp4107937vqu; Fri, 29 Sep 2023 08:13:56 -0700 (PDT) X-Google-Smtp-Source: AGHT+IGsu+N4RogchqEbiVenDBkREhWclkvrOOfpiZTNybuHb6D/LIen8v9dLguEhrczEt02hfUi X-Received: by 2002:a05:6870:d153:b0:1d5:b442:5df7 with SMTP id f19-20020a056870d15300b001d5b4425df7mr4815995oac.35.1696000436154; Fri, 29 Sep 2023 08:13:56 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696000436; cv=none; d=google.com; s=arc-20160816; b=J2gzlu+lbNzDHvIjUrnP2ha+pg6SOrXFHz2bLsOH8PHbDqw4zj1CLkvvKdypqO0ts5 2RHpsCyWe7WU4uf/k5KLCEBmlkHhHA9QZdo9IUub7sh+wmZo4wCAq4XIq+mw4BlzSuxG voaPu4Bc2FlTDhhsQt2EMifcpFlQfouOBujk69EhLLi69Wlw5pVfWE4Upl6DJ7LUc3Mi SZMmbzYelcxM8dCWdDIeZ8ArqfKqkSgnmY0Bw1UoP7T0bPQpjrf2IK2ucWfUPV3EhnfH cEXXHEYF1s0OvF5XmZlnuRSoIoXbSXvzWTBURNf68Vhs/QLxKb/wt7cu5T5NEe+XCiko XFpg== 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=PToENyqfWLJn4YNhQnPzWZuy7Xyr9LEZIfJ9vDgKx9o=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=nAN4pnhTesccs0ExkqzSEwdJFpga2rWdxlaep/970uW13XqV4wJFHD+GP4JHpHtdZT NPAdBtGooKJeJsnyTwZVI4Ir3bdV5IvpJdBhXwahI0pkhVD1iqXxVb2UrwcyEHkMDarW 5XaoPr/2RPeS6flF/ttTReSwRqRu0L4IQkhW63CpM9JrtAfmLseYxC3AhIjrfkcZixfi CAyeA6NHYUncBMnAOa9gamWj1k5D0gX/nFSRX02vG9lRdij2nY7uRfLlqCLTeiwmR3ov iCuHrtS7sYUX2EokAuO9LXF0Nm6hwq5e7VvJcjs2fhaLh1v/enOHVfpQZnqu6kRxzr+3 u9tQ== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.31 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 morse.vger.email (morse.vger.email. [23.128.96.31]) by mx.google.com with ESMTPS id i30-20020a63585e000000b00565eccbc52fsi1573349pgm.303.2023.09.29.08.13.55 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 29 Sep 2023 08:13:56 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.31 as permitted sender) client-ip=23.128.96.31; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.31 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 morse.vger.email (Postfix) with ESMTP id CBC888363CB2; Fri, 29 Sep 2023 08:04:16 -0700 (PDT) X-Virus-Status: Clean X-Virus-Scanned: clamav-milter 0.103.10 at morse.vger.email Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233645AbjI2PEE (ORCPT + 20 others); Fri, 29 Sep 2023 11:04:04 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44906 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233325AbjI2PDc (ORCPT ); Fri, 29 Sep 2023 11:03:32 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id 40FA1CC6 for ; Fri, 29 Sep 2023 08:03:30 -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 830451063; Fri, 29 Sep 2023 08:04: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 2C19E3F5A1; Fri, 29 Sep 2023 08:03:29 -0700 (PDT) From: Sudeep Holla Date: Fri, 29 Sep 2023 16:03:02 +0100 Subject: [PATCH v3 13/17] firmware: arm_ffa: Simplify the computation of transmit and fragment length MIME-Version: 1.0 Message-Id: <20230929-ffa_v1-1_notif-v3-13-c8e4f15190c8@arm.com> References: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@arm.com> In-Reply-To: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@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=Rg2XKzRPf8SFjG3ZX7rctW9KFXN9uruVnGqowukr10g=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlFucwynFFqxvHjHWr3fQpCjnPEZhI6MOOZvWa3 Vu9DXT+PxuJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZRbnMAAKCRAAQbq8MX7i mH0vD/9TOnvx/MRuf4JrzUDS0qYwarst+XtR3YA98cDVMU8SMMO++DDxeULkEmoW+QL2OvtpWCZ 8d3lTmNKbLFKIYuhEzURoXfKBUF35MeyPXSz76xnHUEQeFVMkZIAESgR36OsOMQLTzrzc7nN9d7 tcgtQD9modOPd0+6UzVfiVtrSykcD40pt5WHe2T6VHzFTK55owf95LIU7KvC/RC2X5cEW2rmzJn oY6Ja/kPJwEG95nzOKNGthIvx1TVkUeAE8Ddmvg8OQhCxVia1W155fGXV5awZjMQsI57RhafAWt 9ddvScF4rANyVsDwrNNgs5riRWtRr0puMtoSie1jLyYKrFkCdGDnLgITtlqseAFogwpb0qgy1uD 6CmbM8mZwNS9WRr++ufKCa6Ynmvott+IWrhJ3T9HCzV//d9dTlrngYy1lyM22EBDtc84xGEVtAi Cmao8jTeECdfRKgwaQjU2Bi7+iWI46p0qKrgfJahOtmn28QGaaFq2reFTUuHqpZL6e3hrZfzuSq mB+5RROSIdq8xfLzNtuBb2VuSIIseDUEPPgsI/Vba+/SaRcmjv0VNrnzwIcXQ60nRyMDTfHF9Mh g24xJTfJaxOVji9fNnczaH9U54X4vGsenurTg3yzOhRgawrk0kpbxeTbgUGv3uRwi3J+3YMU3Pu g0MMyU22hszKPMw== 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 morse.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 (morse.vger.email [0.0.0.0]); Fri, 29 Sep 2023 08:04:22 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778385352943510123 X-GMAIL-MSGID: 1778385352943510123 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 28bf345862d9..d9ff3ec4f1eb 100644 --- a/drivers/firmware/arm_ffa/driver.c +++ b/drivers/firmware/arm_ffa/driver.c @@ -443,23 +443,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; } @@ -468,13 +470,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 Fri Sep 29 15:03: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: 146616 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:cae8:0:b0:403:3b70:6f57 with SMTP id r8csp4110251vqu; Fri, 29 Sep 2023 08:17:10 -0700 (PDT) X-Google-Smtp-Source: AGHT+IGYxXehpFtkXS24QSiyhUsxeM+bP669EUAvU6EqDkLSisonnXcePbJV6UPiPkAPgsb+rS0v X-Received: by 2002:a05:6e02:1a8a:b0:34a:be3f:9ee6 with SMTP id k10-20020a056e021a8a00b0034abe3f9ee6mr5609757ilv.12.1696000630593; Fri, 29 Sep 2023 08:17:10 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696000630; cv=none; d=google.com; s=arc-20160816; b=KiOzQU7ZoTyeTH/0q7iFW2GD6pEm8x/o9cIgtAcDLwHqRd+uLY2Jid+46fd+FApmoh HfNOxGOVi6OJZOFRxCAMx3eJZB5c4sKiTsSSzVF5nJTo6bjvTu2qRtcfjS3WLbHxNiMH +btpIEtPG+DguH+vY2w4cA7KLHptc5idh6FzFgihrA3gJNaGAQk5LXk/Q3Ybo/4cCVEp TcC3daikeDmDhk3wEqarKY4LYAbnK22aA9VDgbPbVUJkkUwfqS4lgaJFO5aIi8foiyMz 8HPDH0HMwS0GDzt8Fw925xoPSI8cnsWANDRRw0rSzOVSypObPTz2Hx/EZqoR5PZ0Ou6K ZSKA== 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=Ju4fqjlT3DBD5ACfkVorrGonIjvIBjwJlaOY5mZExnE=; fh=6OYY6fD5PfTLF1F737Vl+bRsEmFHuj4gbYLrOs5QYVs=; b=fdO+lmA8ikuim4WUyVVA6TI+HmX2hKnxd7YwCLDA0Tr2HxAAbfjGbw9CFrlCvTtg8/ 6sqoSqWC8wBobBrIGS5jj7E4LpT6meyRc1mX7TNPDTFxly2Iy7g9VGTxihaWYCg4yPco IPOqUFSinrDvDdfvv+OEMOsCHbSD4E/VX/8BKizFUdDzHYmXlM5Dm1SLuRvSNBYH/Lta jB15Rru9NtKjKG3vLCxB6W5dYzJa6S8Cy5C4E4H6bIYir1r3afBeSywDPjE/kKRed45G BEet/w7yeSzqVwJXGkxN17n5hb82EA904aJ00ro0K33MAjVGTrhopUi25TX2RqGZNvvt +v6Q== 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 m124-20020a633f82000000b005774635c69dsi21180745pga.66.2023.09.29.08.17.10 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 29 Sep 2023 08:17:10 -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 0D3C38582FD5; Fri, 29 Sep 2023 08:04: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 S233591AbjI2PEH (ORCPT + 20 others); Fri, 29 Sep 2023 11:04:07 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:55552 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233507AbjI2PDg (ORCPT ); Fri, 29 Sep 2023 11:03:36 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id 184C1CD4 for ; Fri, 29 Sep 2023 08:03:31 -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 24D60106F; Fri, 29 Sep 2023 08:04:10 -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 5953C3F5A1; Fri, 29 Sep 2023 08:03:30 -0700 (PDT) From: Sudeep Holla Date: Fri, 29 Sep 2023 16:03:03 +0100 Subject: [PATCH v3 14/17] KVM: arm64: FFA: Remove access of endpoint memory access descriptor array MIME-Version: 1.0 Message-Id: <20230929-ffa_v1-1_notif-v3-14-c8e4f15190c8@arm.com> References: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@arm.com> In-Reply-To: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@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=3159; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=64pcj+hQs1mQBRXTHk+OD4ILrYtlsf+Zd4SaIeIRqXs=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlFucwKh/Fe3GJay3phEMH0ENESU2rWfHbdYJMI ySGRC8yREeJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZRbnMAAKCRAAQbq8MX7i mJJyD/9Q2noyk3D968ikUkQGfX8OZNm4vkic6pbl9zlMTAVy6rlNgkCcBRp20EGRHv7e8QJqHI7 mQCnJ/Jmj4EKCWzzKsb00YYxkLuPnJh6LlfuAdOpli7YBaL6yaUWT4hVXK+dbJsBzFvFu0mCPl4 pLT6oSO+0DRQbA28btZF7bH8xaUCajsqQ2wr3tiK4yQyY5kDxIWGVqDoN52w+nvki+F4JLLgR4w KA0d8ojDpffbyZD5eES1TxyLuBZL8H7GijFgco+G5C2URDJ5BRS9LtI/8tfEz6LF3TZ34hN1D0z UwzbVp+ZH3EUF/4cpcf2dniVBq2p1mdQPYmV8X18K8GCNNIFd3W2aIMNsOXAGChWnMbl6X2UTKr vCFnvY1Y3wlc3x2+c/SjEUvQqXwWBT+pVJv47/6pwg4DFSyMQ4ZOWqM+6pohVKsSxGJdJD2zVPG fs1eNYIqENGi4hLyYuZ8hzEJbetFPVrr4La9LaRtjQgGJKMDAqgYTMpob95l7sX1yTeXiwNZyV6 ihXZDcLQo3nZ5OAP22EuM5ljfJGwIDkEGvHGBtt5VMZwQpMLfD0pLJeOV7jhpUKgyCqltf6wuLV zP+TB4ndSP/J7MyWfvnp1232pQRvR9pQiDts8CnilJtB3luJrNxf800Jq6gMESJYGCgrnYqNewD GK1rKGoRX/DWBhg== X-Developer-Key: i=sudeep.holla@arm.com; a=openpgp; fpr=7360A21742ADF5A11767C1C139CFD4755FE2D5B4 X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_BLOCKED,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]); Fri, 29 Sep 2023 08:04:13 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778385557206322687 X-GMAIL-MSGID: 1778385557206322687 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 boolean argument that indicates if the memory access descriptor versions is v1(old format) or not. Currently it is set true as FF-A proxy supports only v1.0 Cc: Marc Zyngier Cc: Oliver Upton Cc: Will Deacon Cc: Quentin Perret Signed-off-by: Sudeep Holla --- arch/arm64/kvm/hyp/nvhe/ffa.c | 8 ++++++-- include/linux/arm_ffa.h | 6 ++++++ 2 files changed, 12 insertions(+), 2 deletions(-) diff --git a/arch/arm64/kvm/hyp/nvhe/ffa.c b/arch/arm64/kvm/hyp/nvhe/ffa.c index 6e4dba9eadef..5f956f53e6bf 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,8 @@ 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, true); + 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 +506,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 +531,8 @@ 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, true); + 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..7be240e37f36 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, bool mem_desc_v1) +{ + return COMPOSITE_OFFSET(0); +} + struct ffa_mem_ops_args { bool use_txbuf; u32 nattrs; From patchwork Fri Sep 29 15:03: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: 146621 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:cae8:0:b0:403:3b70:6f57 with SMTP id r8csp4113091vqu; Fri, 29 Sep 2023 08:21:08 -0700 (PDT) X-Google-Smtp-Source: AGHT+IFsaKB5s39zOlsTTPiZztR9pSUFSs07QclgVvrXRmU2QwI1ETHN9qd9olSAMoliX6sCBarL X-Received: by 2002:a05:6358:713:b0:135:499a:382b with SMTP id e19-20020a056358071300b00135499a382bmr4622814rwj.7.1696000867951; Fri, 29 Sep 2023 08:21:07 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696000867; cv=none; d=google.com; s=arc-20160816; b=e4aWbgEoIC3AKx1zcI9dzT7ABp7ekxcv+x4d1IXHO2TBJVsIl26ngjXEIFt30RLKPs KAy9Oht5hruvde/H6/GNkZBeDlWlDSjHdgQnLbsXS2LmQG71Owcp4E2NQl8S9PWetQKL iJTnF2n7gEG6sscIKFmaE510iIM4+qlCQL6NtmVOsxghi9lleMu5ZmLHDck53OOBQ+RK q7i366qiXhUUGukWWj4iyZOvf8bFOP8uTVw0adCbXoBz5nS2ftXMYhMCPpWNtPIBriMa UJTcmafKZD58W+oOLhp3lDdsLQn2Aojy6B+mKQvGBUm9IvSsuwRl91AyVMJS+i5eF/mG 2mWg== 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=Ji/e58xgeAvmB3ZNah+WsnTmrCvQMtTR8TbNhXDKI1Y=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=bc0HNdD7LgWkpPRryEf6oC/wfmuPMnMxMTsVDRjaLdtqnUn7TQNLA9IuoJDHdRgNL+ JJwIaye/RiV1kAVEDE8WfUMp/LtgpOaMvATvjTl4yUfnFRai3TGUnjjPv6jp8Rz+LsSU PcaPrwl1Gy9WIBycl+ISk4A15ku6sx4POdx72uY/4LO2BR+uFTsMbgp6BWhT/1slGsup O8dUh1GQfTP2xtrX7hZfDPdRoWX0pzSfAgNc0ylxvjLEh7Wr8cOC2gW3PIHhX2jDBoMn kDJAFvdP2LQrJXfvFYWsrbkrKasi/0cUEsCS7TOXVHsteH3+pHqV8wdj330c4oPk0HLN gTLg== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.37 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. [23.128.96.37]) by mx.google.com with ESMTPS id t5-20020a628105000000b00690d25b198dsi20934182pfd.103.2023.09.29.08.21.07 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 29 Sep 2023 08:21:07 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.37 as permitted sender) client-ip=23.128.96.37; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.37 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 494D88271759; Fri, 29 Sep 2023 08:04:18 -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 S233597AbjI2PEJ (ORCPT + 20 others); Fri, 29 Sep 2023 11:04:09 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:55584 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233550AbjI2PDp (ORCPT ); Fri, 29 Sep 2023 11:03:45 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id 56A1CCDF for ; Fri, 29 Sep 2023 08:03:33 -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 521B612FC; Fri, 29 Sep 2023 08:04:11 -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 EF78B3F5A1; Fri, 29 Sep 2023 08:03:31 -0700 (PDT) From: Sudeep Holla Date: Fri, 29 Sep 2023 16:03:04 +0100 Subject: [PATCH v3 15/17] firmware: arm_ffa: Switch to using ffa_mem_desc_offset() accessor MIME-Version: 1.0 Message-Id: <20230929-ffa_v1-1_notif-v3-15-c8e4f15190c8@arm.com> References: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@arm.com> In-Reply-To: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@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=1661; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=WKIYZxRqRXASwTfRhZK26/hbt/X8NbiSbXFTeLJ2R0A=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlFucwmwQnsz2nnr94GhK0TUe/Jk8JcvkQITM0z Ety5uzdjVuJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZRbnMAAKCRAAQbq8MX7i mPPID/9yCTj2U/sG/SGPGXZX1PRqK0TYhMUirlq7o4A+AUsh/+lnTThpYGVyeFIPhEbfEuwJ3r4 xJZKlx/dAhwN/F5D9Yx9D11CaqffpLne3jbRUm/swWw9ZiwTxZy4vYdp3gavKxqmWZchb/+IZY5 GvLHTwwmZs3tTmS8AO4vs6s9wAsr53vz044AqXOxcGBArDFSRVoDMq8GevIwwosL+KwolPqBD34 NQ6PzM0VNF3JEsLAIB6aP14BTMuyg0b3SLIZuFof8jNXGV8t7v9joYR2KU4bIVpI6ovEe+3ZY9b x2jbLM3K99PaCKNOTWc/LzSIs8tjrRpGAtes85HZpZ9iRJb5q+kBVI68xH1UuM7C3ULi9bYKPQU XFfp2FqKzMU9mKNI2JyYDE1rX6OVQKn7bnQ1+ha8ZL0eOQB+Bj/XJ8plh+DsfgownGTs7oNyjIF knjtTxRZq0msn/kVdG5ohwumM3OAMhRRJsi48kLZLHLMEyv/HGHY8v8MeGn337swMn2MRUv4Epk s+cmPCIEkscIGZdteeJoEns6miKAcJjytJRUMJoTb9h3d7664+OwYhG4WBw1EnnuTyK757xV3DY 7BBZnkc+2xVdd0QNPQy3Wk5+1a4qeQPDwsd9G6zVKUb04gYVHGDWeBvd97wmvklKWSIdBD6Ud4/ QSorGiA03tjiZWA== X-Developer-Key: i=sudeep.holla@arm.com; a=openpgp; fpr=7360A21742ADF5A11767C1C139CFD4755FE2D5B4 X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_BLOCKED,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]); Fri, 29 Sep 2023 08:04:18 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778385806342565928 X-GMAIL-MSGID: 1778385806342565928 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 | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/drivers/firmware/arm_ffa/driver.c b/drivers/firmware/arm_ffa/driver.c index d9ff3ec4f1eb..ef7011c86d60 100644 --- a/drivers/firmware/arm_ffa/driver.c +++ b/drivers/firmware/arm_ffa/driver.c @@ -449,14 +449,15 @@ ffa_setup_and_transmit(u32 func_id, void *buffer, u32 max_fragsize, struct ffa_composite_mem_region *composite; struct ffa_mem_region_addr_range *constituents; struct ffa_mem_region_attributes *ep_mem_access; + bool mdesc_v1 = drv_info->version <= FFA_VERSION_1_0; 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 = buffer + COMPOSITE_OFFSET(0); - composite_offset = COMPOSITE_OFFSET(args->nattrs); + ep_mem_access = buffer + ffa_mem_desc_offset(buffer, 0, mdesc_v1); + composite_offset = ffa_mem_desc_offset(buffer, args->nattrs, mdesc_v1); for (idx = 0; idx < args->nattrs; idx++, ep_mem_access++) { ep_mem_access->receiver = args->attrs[idx].receiver; From patchwork Fri Sep 29 15:03: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: 146617 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:cae8:0:b0:403:3b70:6f57 with SMTP id r8csp4110286vqu; Fri, 29 Sep 2023 08:17:13 -0700 (PDT) X-Google-Smtp-Source: AGHT+IEMMktHGtVLfN1vAVcru2Yc0qPHIpcil/tN+HMG6c6BIUL6vpZJ+sGWs491F9ivBP0+quYz X-Received: by 2002:a17:902:e5c1:b0:1c6:ec8:4c67 with SMTP id u1-20020a170902e5c100b001c60ec84c67mr4791005plf.18.1696000632540; Fri, 29 Sep 2023 08:17:12 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696000632; cv=none; d=google.com; s=arc-20160816; b=XIQIj26xaJdLFoxd9Ha3jFdtPH8L94wqlyWqc26UJRQ56qs6D7nZV+B7ATokv9izvm 0glcvTgJPNWLEi0d6WCSkuJLh3LP/4GEIorjLHMAO4RueAs6b6/58ITHFlUCGDSSGUEe rMr0+k5U/v9Ipgyhku7BhitoGWI7f27bp/UQWm0PF2ElAs7+Iocm++7eD52AYbrqeYB2 7dw/8SyH2nPS36eldyJIYqZEL5QOQzlgFFvG26iqTX++h3JrG1XczTT2ZaehHc/zMsEu pI1JCq9G8QJTQMR6KBwSjDh0cl6T7nq2mKajm0y+Sx4LF3tAChOBaHbu64xaBoPaZZoJ pDew== 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=Rcm68xVr1sxYYD9kxwxzIU6ELOokBRxdRcbzkdSoDB8=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=0fAKWdK0Ooj6od+gW9a6sZ4pOsod30AfL/Gj41VNUXHF/ruRd81ncnvsPuQpcRYmMH sHOVLhauJuq70/JhsQCmj8e0AT1Zni4U9YNnc3Klgm2YpkIeUYsLGaDc4Ptjl5cZv4BN /i2rILZyUBi9PkBsiqqBTXa6Khsn58xQNJC4zCvYFtDu8+SfjDIIvikdLZw3CCWH9pOl iN/M57TF1gC3ElUWivk/nwatAo13dKorLHE1VDO/3Q6+/1t1lQDMXY+lR1xOOwW4WNry hj7l4he9GguUvybulH+pTJPxu69HSXh3uTRhPKqNWQIQfZGivTK3enEH+o3hMJs1psjS 2FEg== 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 x12-20020a170902ec8c00b001c0c86a541asi23570375plg.375.2023.09.29.08.17.12 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 29 Sep 2023 08:17:12 -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 99421858E8D9; Fri, 29 Sep 2023 08:04:16 -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 S233661AbjI2PEM (ORCPT + 20 others); Fri, 29 Sep 2023 11:04:12 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37250 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233575AbjI2PDw (ORCPT ); Fri, 29 Sep 2023 11:03:52 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id C0C2E1B3 for ; Fri, 29 Sep 2023 08:03:34 -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 7F4AA1FB; Fri, 29 Sep 2023 08:04:12 -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 2884C3F5A1; Fri, 29 Sep 2023 08:03:33 -0700 (PDT) From: Sudeep Holla Date: Fri, 29 Sep 2023 16:03:05 +0100 Subject: [PATCH v3 16/17] firmware: arm_ffa: Update memory descriptor to support v1.1 format MIME-Version: 1.0 Message-Id: <20230929-ffa_v1-1_notif-v3-16-c8e4f15190c8@arm.com> References: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@arm.com> In-Reply-To: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@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=4081; i=sudeep.holla@arm.com; h=from:subject:message-id; bh=WhdrDVZNbm/z1aM3IcsKqTU6ZT3SC2M0eEn3tH9qkZc=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlFucwbXjAQ8dzp00ZxFqLBv0AqMokTo704J+fB rmuIA6oMUWJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZRbnMAAKCRAAQbq8MX7i mBMUEACmH/uqQzGyBRet5JKTbwTcgVI1Vo2373bNgX4uPpmlDE4Oyfy+ai6exmpC4duHMn5NjWy i42VWuu5z2HlnqrcSUiVglmYkyKzLygQeslDAAZOn6vXpnu07OCRUm/F/JS9H44XQPLEegaYMKw Y7aFIyEIKe9Uqx+9VOAJ0P7HElKSxc5rq3sd8TI9OMfhgW7hNf5o4/0E9qaL0AUhtlM+TOAAKvk VgERES5cvrmMCvrB0wzrwDwe/+V9gIBPkVziTJtWHAwn9sGGS66DWfSOFTxcfjVaJIJ+jkpWbfd KYCNr3KA4RkzhW3ZigXoqoz1oi/iT0uvkayAfCa9VSmr00sXXmV5YUNuOctmTQQ87jqF5iekLvW 0ELWwJIj4Hl+f5ExhN6YTOYFpDBFgreJvHjCWbd41gBOg578VNODsKR2teY+VaJoXgUDhqQEr0T yqz5NcyQ+CorJBGlHdAnv0RVkXvXf5EorbzZM8RHAiHDPUg7D6ggpa/2Bb2WqMYy5xfWWgzLLM1 KF9tdwtKVjXA4HtBsSsqBIx3YbDroWv+dng6o8gUxjTpebBI8aONSt7j9WXBaJWmttINxcjhFi5 gSn3EwpPWAy6JevYs5nPGl+XxuILkJHTVw1aPev7xiH5WHhpFpOl1YXrAiHc7Dyigcf5EnmculJ p3Pf60Ckmccnwqg== X-Developer-Key: i=sudeep.holla@arm.com; a=openpgp; fpr=7360A21742ADF5A11767C1C139CFD4755FE2D5B4 X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_BLOCKED,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]); Fri, 29 Sep 2023 08:04:16 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778385559567022681 X-GMAIL-MSGID: 1778385559567022681 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 updates 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 ef7011c86d60..0168e69c495d 100644 --- a/drivers/firmware/arm_ffa/driver.c +++ b/drivers/firmware/arm_ffa/driver.c @@ -424,7 +424,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 (mdesc_v1) { + 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 7be240e37f36..f3adba0ef6c6 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, bool mem_desc_v1) { - 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 itself) + */ + if (mem_desc_v1) + 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 Fri Sep 29 15:03: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: 146618 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:cae8:0:b0:403:3b70:6f57 with SMTP id r8csp4110405vqu; Fri, 29 Sep 2023 08:17:21 -0700 (PDT) X-Google-Smtp-Source: AGHT+IFnTzOhKrHMAZuF/TREflVqKqAe19ghgnErtaN7awjR6zGb653wzcPDM1aiQSUI1JW92n3/ X-Received: by 2002:a05:6300:8004:b0:154:a1e3:f967 with SMTP id an4-20020a056300800400b00154a1e3f967mr4991243pzc.47.1696000641215; Fri, 29 Sep 2023 08:17:21 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696000641; cv=none; d=google.com; s=arc-20160816; b=HiEUcpF3V4NHO2fNVOYNCPa4ByEOajt40UxVz71YVvAoG709Y8BJAbgLfWz25nc5AT CVl5KMoRm/n+HhBwZb6nITzrDkglvuDrPzKO7VDJJpaYKi0oA2xCXEcpXVGALRjg+zyn 7xJujtKtVrUk06gGJi72pQkubM02TCTQfK0oteZtYXimv/VUGi1FBOvGYenDgZhiitZr LlrrW0fLE3W1gNFhUs+yIOg2zWhELTMDkmSvYIXUxqArOdgiWTziHwo90DE+lPcv0eU7 g8pItQ+2PiWg6EgZzwSaLjA40aD0bC8VCh+3jqcNBQUpATWOsS88/ZfMXnf9theHawfY Kktw== 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=mpvfazcO86brTlYYwl93We8mkzdmHc0RspgSYq25ZFQ=; fh=iZJRvoZuVJp3Jcg3UWu0imuTLbH0nKChof8pDyzNHj4=; b=dz8bLnOh3gt2203xoV/CyoQ5AqxMvYVwt9F66CXb9+7R9/Iih9pn9w5L/KehH4JWU4 B5xvDMwHhH6m1GY8T5CbNWd2/EvDjrcbNTvijD80KfX1KQxX0mD3Mdf+wMPTPrdXDSW5 YdG+Omo9RVWJlxoT2+qD50lox7h0LsWg21WK184s8BG5nbhpV8RJkl9qjTPHNLMEyDIG b953jh35Nk3wZihYjFfbBwzCdQoIAvPbA0xNloZqn5PFrSKEdwlt1X1vUPyWzVP3InGZ d0SdyyxoNgP9Hs1K1LiTHbrAulbPIGAVvxushqAPeks95wMMKJDwzBd5+vW/3cXHJw9P +Jow== 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 ck12-20020a056a00328c00b00690ff5e479fsi20642971pfb.332.2023.09.29.08.17.20 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 29 Sep 2023 08:17:21 -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 0F186858E8F8; Fri, 29 Sep 2023 08:04:28 -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 S233601AbjI2PEP (ORCPT + 20 others); Fri, 29 Sep 2023 11:04:15 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37266 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233576AbjI2PDw (ORCPT ); Fri, 29 Sep 2023 11:03:52 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id AA5141B7 for ; Fri, 29 Sep 2023 08:03:35 -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 AC47EDA7; Fri, 29 Sep 2023 08:04:13 -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 55A5E3F5A1; Fri, 29 Sep 2023 08:03:34 -0700 (PDT) From: Sudeep Holla Date: Fri, 29 Sep 2023 16:03:06 +0100 Subject: [PATCH v3 17/17] firmware: arm_ffa: Upgrade the driver version to v1.1 MIME-Version: 1.0 Message-Id: <20230929-ffa_v1-1_notif-v3-17-c8e4f15190c8@arm.com> References: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@arm.com> In-Reply-To: <20230929-ffa_v1-1_notif-v3-0-c8e4f15190c8@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=Xm+5FQuOK8ltFjmVMKkQ+PdVAQzeFkX0aF6wk6FDOU0=; b=owEBbQKS/ZANAwAIAQBBurwxfuKYAcsmYgBlFucxGzAT4dtPyO2lxZI7phiqRwrHuueWtGUs8 eFRbadMVFWJAjMEAAEIAB0WIQS6ceUSBvMeskPdk+EAQbq8MX7imAUCZRbnMQAKCRAAQbq8MX7i mO0MD/0QyHmOb8sV3V0Lb9aSY63l2HnDx4ye1U5oX7byMSasGabyYpk3cw50aYeKQvtEZhS7xfm Q43V8PYqoUOlaO36fMHcKOLd9F099mOjConyL3D3iMx80HQ3ZObWJtIQZW2i5bfeA/1rHpYgT3Q wfYD5O57fXo2h3Sowfez4r+hgQU44qIySiwBKqf9RX/+YScjbl7uOr1l6kWkaoOn7EO3mAl5szF 0Ejm09ReyqcCq4IoQToT1jd/drs+PBZjID8AQk9I1sGOjwTqnpxqtedU2Yu0J7vvkvJ0YPH951M NCwiajsv43RKWDXk8hTw+s4vdnBKpZFhylt+eNszjkVqRiKwZdUhMNDaCvjjrwU1E6QGKJCCPS1 +5HkuL+91d2hdJ6XJ/kxwzH01cnxIJlUch2uq4fDnU7/T8q1aaockAuqv6A+2qmQD8nqQhgeKYx byBdoChwkIfQjilwuY9zN3cqnH8opvSfqValQlYQVGvy2JHymglxD4NABkqirdLwvB1jwl7Gmfq tH7SDYUMjeuvz8mp4B/3C+tTYpnR5SluVnU4IFDs+DhRPMBNADFscKgRdmtaxbmZsJbNi08gFuL hdWO1rQn6Hn312S3CAM7tMFulJHzM++KmLTF30lUFuhsMSgftNvuRIuEa8miv5UW6lQV1AVr02o 5/CLChj1D65pywA== X-Developer-Key: i=sudeep.holla@arm.com; a=openpgp; fpr=7360A21742ADF5A11767C1C139CFD4755FE2D5B4 X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_BLOCKED,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]); Fri, 29 Sep 2023 08:04:28 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778385568270357652 X-GMAIL-MSGID: 1778385568270357652 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 0168e69c495d..e9c6282d750c 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)