From nobody Sat Feb 7 15:09:52 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id E51572F28FF; Mon, 27 Oct 2025 09:56:32 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761558993; cv=none; b=gjC7pVEiJyNcV+EgSPZqGVSVBvEwIJ8tayXKPAn4kA2zofPLL5t8Ts6KIUtSg8y5unY4yPhF/lO0Z1/0PPjOoDDM3Sin7F7+2Jr3HwXFqW+SYQBYeoybP6EOjNnBh+gjYsbLZ46dvUh7xVosLyqUZhnhLCo6XZtjhESKzeN+Om4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761558993; c=relaxed/simple; bh=pC+eGt5qR3M3nYfPyNbPQUDtDiJDp1JmXs8kzQjP70M=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=TbXzg6AUE661TPKuV4O3c0UI3KW3dN97FMGMeuhGybD7foKrRujiYqjJnSKRbHWj9wkwFhQIFwASVeX1rfhmMNR4FNlM7zVP12pysdSI2GMdy3pol2jbsDOCSN7INQs53+xygQ71tEwRtUEmntT8VL3pABqmkMusEUpwFqakiuQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=YuMef+jl; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="YuMef+jl" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 5EC34C4CEFF; Mon, 27 Oct 2025 09:56:27 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1761558992; bh=pC+eGt5qR3M3nYfPyNbPQUDtDiJDp1JmXs8kzQjP70M=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=YuMef+jlbvnSIszQtRbbNbzNF/skEyrkvd626H5XDvcCCR+znXv9sEJ4s3scLOt4a 1S3zYonPGAsbp8kNwGsRUCG3ZbDJ+JzU47QcWxiH7hnCDqWhDu62HsmRuW6WwUw0kO PJer9YzUlI1vTMrNEHIGgl0w+vHHI9O/pKhcutr3IQ2xDZiFgbRqBc7EMj9kV3hcO2 hB1EGrHo/MEDkEATbLEiNxj76xl+Ye9q1ZEAEQNQkQBLSe8L0bW2PwdNgyEYljxL0b wWEQiQP3Kyl4+x3emER1M4AvL8IwEjNpGWBTx1TIpXzqzsnPytu/8P/lz9Aq/DtEyg djADykjNi0oVA== From: "Aneesh Kumar K.V (Arm)" To: linux-coco@lists.linux.dev, kvmarm@lists.linux.dev Cc: linux-pci@vger.kernel.org, linux-kernel@vger.kernel.org, dan.j.williams@intel.com, aik@amd.com, lukas@wunner.de, Samuel Ortiz , Xu Yilun , Jason Gunthorpe , Suzuki K Poulose , Steven Price , Bjorn Helgaas , Jonathan Cameron , Catalin Marinas , Marc Zyngier , Will Deacon , Oliver Upton , "Aneesh Kumar K.V (Arm)" Subject: [PATCH RESEND v2 01/12] KVM: arm64: RMI: Export kvm_has_da_feature Date: Mon, 27 Oct 2025 15:25:51 +0530 Message-ID: <20251027095602.1154418-2-aneesh.kumar@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251027095602.1154418-1-aneesh.kumar@kernel.org> References: <20251027095602.1154418-1-aneesh.kumar@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" This will be used in later patches Signed-off-by: Aneesh Kumar K.V (Arm) --- arch/arm64/include/asm/kvm_rmi.h | 1 + arch/arm64/include/asm/rmi_smc.h | 1 + arch/arm64/kvm/rmi.c | 6 ++++++ 3 files changed, 8 insertions(+) diff --git a/arch/arm64/include/asm/kvm_rmi.h b/arch/arm64/include/asm/kvm_= rmi.h index 1b2cdaac6c50..a967061af6ed 100644 --- a/arch/arm64/include/asm/kvm_rmi.h +++ b/arch/arm64/include/asm/kvm_rmi.h @@ -90,6 +90,7 @@ u32 kvm_realm_ipa_limit(void); u32 kvm_realm_vgic_nr_lr(void); u8 kvm_realm_max_pmu_counters(void); unsigned int kvm_realm_sve_max_vl(void); +bool kvm_has_da_feature(void); =20 u64 kvm_realm_reset_id_aa64dfr0_el1(const struct kvm_vcpu *vcpu, u64 val); =20 diff --git a/arch/arm64/include/asm/rmi_smc.h b/arch/arm64/include/asm/rmi_= smc.h index 1000368f1bca..2ea657a87402 100644 --- a/arch/arm64/include/asm/rmi_smc.h +++ b/arch/arm64/include/asm/rmi_smc.h @@ -87,6 +87,7 @@ enum rmi_ripas { #define RMI_FEATURE_REGISTER_0_GICV3_NUM_LRS GENMASK(37, 34) #define RMI_FEATURE_REGISTER_0_MAX_RECS_ORDER GENMASK(41, 38) #define RMI_FEATURE_REGISTER_0_Reserved GENMASK(63, 42) +#define RMI_FEATURE_REGISTER_0_DA BIT(42) =20 #define RMI_REALM_PARAM_FLAG_LPA2 BIT(0) #define RMI_REALM_PARAM_FLAG_SVE BIT(1) diff --git a/arch/arm64/kvm/rmi.c b/arch/arm64/kvm/rmi.c index 478a73e0b35a..08f3d2362dfd 100644 --- a/arch/arm64/kvm/rmi.c +++ b/arch/arm64/kvm/rmi.c @@ -1738,6 +1738,12 @@ int kvm_init_realm_vm(struct kvm *kvm) return 0; } =20 +bool kvm_has_da_feature(void) +{ + return rmi_has_feature(RMI_FEATURE_REGISTER_0_DA); +} +EXPORT_SYMBOL_GPL(kvm_has_da_feature); + void kvm_init_rmi(void) { /* Only 4k page size on the host is supported */ --=20 2.43.0 From nobody Sat Feb 7 15:09:52 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B148A2F549A; Mon, 27 Oct 2025 09:56:39 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761558999; cv=none; b=e68h3z1MKokvl0YBGS2sdCPicDXR1PtwZn8esa0Gbkemmt6uRmLAPvQYdrpQpl1QesoINypfDHWpwjm0MuVQqX+BfE8RdEnelb8HIyeL76YzzVWsEYnsJSJqxHY9Yu3x1SYTjJ+U1VyZ+p3ev9ez3SENv5ax9ZMiCEAtB/Dgvu0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761558999; c=relaxed/simple; bh=xgScCgzz6ncBbywMhZj1X+FhxpDg3LK2VwTvSsathms=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=bXLhyHyMRF1d1PS2EJtZyNP1PAbPk8MM/zrrIX8wH1Kf91jKzICYrI7fuiyVZSvXcKW/JZbMJP+wRDxcdO1YNJSMoIzTT7SrSFhA2lYBdRecPWPNihwC++/zrwl/VYilGAbwZCnhCMJbUU5n3cM3jnaViR8NKyPtpOsYi763EGE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=s+N7JYbW; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="s+N7JYbW" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 04EA3C113D0; Mon, 27 Oct 2025 09:56:32 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1761558999; bh=xgScCgzz6ncBbywMhZj1X+FhxpDg3LK2VwTvSsathms=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=s+N7JYbW+v9ql7b6wSycTc5wCWSqb/dWr3+MBhOTNxTjWTYvYL+EM1C1sAFaSqmNQ MBL2r7YgqjS0tdKAOEw5HoJpO5Z0p2X3zTvbg+YkJ/xq+8YmRxoaGqZfGj16GCE6B9 C4SNjaormMgyCbQ0ppqGMFFXuTHJNnnpskNFW5gadvtqkHaQsgMJMSNgsFLDJKNFjr EbiGMmAYP5Jnu7afCX6y4mn/XRmVSMkpecYwD9Jhf8eRXu9cpukIoEeUSbNDDQPDJG 6Q4JoLQIcJyB82iqpRd5fnsgj1xFxqgtyddCqFAasPfxatg4f1+DLYC+8Q2zg1AJjE DPPgsAyp34GCg== From: "Aneesh Kumar K.V (Arm)" To: linux-coco@lists.linux.dev, kvmarm@lists.linux.dev Cc: linux-pci@vger.kernel.org, linux-kernel@vger.kernel.org, dan.j.williams@intel.com, aik@amd.com, lukas@wunner.de, Samuel Ortiz , Xu Yilun , Jason Gunthorpe , Suzuki K Poulose , Steven Price , Bjorn Helgaas , Jonathan Cameron , Catalin Marinas , Marc Zyngier , Will Deacon , Oliver Upton , "Aneesh Kumar K.V (Arm)" , Jeremy Linton , Greg KH , Mark Rutland , Lorenzo Pieralisi , Sudeep Holla Subject: [PATCH RESEND v2 02/12] firmware: smccc: coco: Manage arm-smccc platform device and CCA auxiliary drivers Date: Mon, 27 Oct 2025 15:25:52 +0530 Message-ID: <20251027095602.1154418-3-aneesh.kumar@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251027095602.1154418-1-aneesh.kumar@kernel.org> References: <20251027095602.1154418-1-aneesh.kumar@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Make the SMCCC driver responsible for registering the arm-smccc platform device and after confirming the relevant SMCCC function IDs, create the arm_cca_guest auxiliary device. Also update the arm-cca-guest driver to use the auxiliary device interface instead of the platform device (arm-cca-dev). The removal of the platform device registration will follow in a subsequent patch, allowing this change to be applied without immediately breaking existing userspace dependencies [1]. [1] https://lore.kernel.org/all/4a7d84b2-2ec4-4773-a2d5-7b63d5c683cf@arm.com Cc: Jeremy Linton Cc: Greg KH Cc: Mark Rutland Cc: Lorenzo Pieralisi Cc: Sudeep Holla Signed-off-by: Aneesh Kumar K.V (Arm) --- arch/arm64/include/asm/rsi.h | 2 +- arch/arm64/kernel/rsi.c | 2 +- drivers/firmware/smccc/Kconfig | 1 + drivers/firmware/smccc/smccc.c | 37 ++++++++++++ drivers/virt/coco/arm-cca-guest/Kconfig | 1 + drivers/virt/coco/arm-cca-guest/Makefile | 2 + .../{arm-cca-guest.c =3D> arm-cca.c} | 57 +++++++++---------- 7 files changed, 71 insertions(+), 31 deletions(-) rename drivers/virt/coco/arm-cca-guest/{arm-cca-guest.c =3D> arm-cca.c} (8= 5%) diff --git a/arch/arm64/include/asm/rsi.h b/arch/arm64/include/asm/rsi.h index 88b50d660e85..2d2d363aaaee 100644 --- a/arch/arm64/include/asm/rsi.h +++ b/arch/arm64/include/asm/rsi.h @@ -10,7 +10,7 @@ #include #include =20 -#define RSI_PDEV_NAME "arm-cca-dev" +#define RSI_DEV_NAME "arm-rsi-dev" =20 DECLARE_STATIC_KEY_FALSE(rsi_present); =20 diff --git a/arch/arm64/kernel/rsi.c b/arch/arm64/kernel/rsi.c index c64a06f58c0b..5d711942e543 100644 --- a/arch/arm64/kernel/rsi.c +++ b/arch/arm64/kernel/rsi.c @@ -160,7 +160,7 @@ void __init arm64_rsi_init(void) } =20 static struct platform_device rsi_dev =3D { - .name =3D RSI_PDEV_NAME, + .name =3D "arm-cca-dev", .id =3D PLATFORM_DEVID_NONE }; =20 diff --git a/drivers/firmware/smccc/Kconfig b/drivers/firmware/smccc/Kconfig index 15e7466179a6..2b6984757241 100644 --- a/drivers/firmware/smccc/Kconfig +++ b/drivers/firmware/smccc/Kconfig @@ -8,6 +8,7 @@ config HAVE_ARM_SMCCC config HAVE_ARM_SMCCC_DISCOVERY bool depends on ARM_PSCI_FW + select AUXILIARY_BUS default y help SMCCC v1.0 lacked discoverability and hence PSCI v1.0 was updated diff --git a/drivers/firmware/smccc/smccc.c b/drivers/firmware/smccc/smccc.c index bdee057db2fd..3dbf0d067cc5 100644 --- a/drivers/firmware/smccc/smccc.c +++ b/drivers/firmware/smccc/smccc.c @@ -10,7 +10,12 @@ #include #include #include +#include + #include +#ifdef CONFIG_ARM64 +#include +#endif =20 static u32 smccc_version =3D ARM_SMCCC_VERSION_1_0; static enum arm_smccc_conduit smccc_conduit =3D SMCCC_CONDUIT_NONE; @@ -81,10 +86,42 @@ bool arm_smccc_hypervisor_has_uuid(const uuid_t *hyp_uu= id) } EXPORT_SYMBOL_GPL(arm_smccc_hypervisor_has_uuid); =20 +#ifdef CONFIG_ARM64 +static void __init register_rsi_device(struct platform_device *pdev) +{ + unsigned long ver_lower, ver_higher; + unsigned long ret =3D rsi_request_version(RSI_ABI_VERSION, + &ver_lower, + &ver_higher); + + if (ret =3D=3D RSI_SUCCESS) + __devm_auxiliary_device_create(&pdev->dev, + "arm_cca_guest", RSI_DEV_NAME, NULL, 0); + +} +#else +static void __init register_rsi_device(struct platform_device *pdev) +{ + +} +#endif + static int __init smccc_devices_init(void) { struct platform_device *pdev; =20 + pdev =3D platform_device_register_simple("arm-smccc", + PLATFORM_DEVID_NONE, NULL, 0); + if (IS_ERR(pdev)) { + pr_err("arm-smccc: could not register device: %ld\n", PTR_ERR(pdev)); + } else { + /* + * Register the RMI and RSI devices only when firmware exposes + * the required SMCCC function IDs at a supported revision. + */ + register_rsi_device(pdev); + } + if (smccc_trng_available) { pdev =3D platform_device_register_simple("smccc_trng", -1, NULL, 0); diff --git a/drivers/virt/coco/arm-cca-guest/Kconfig b/drivers/virt/coco/ar= m-cca-guest/Kconfig index 3f0f013f03f1..a42359a90558 100644 --- a/drivers/virt/coco/arm-cca-guest/Kconfig +++ b/drivers/virt/coco/arm-cca-guest/Kconfig @@ -2,6 +2,7 @@ config ARM_CCA_GUEST tristate "Arm CCA Guest driver" depends on ARM64 select TSM_REPORTS + select AUXILIARY_BUS help The driver provides userspace interface to request and attestation report from the Realm Management Monitor(RMM). diff --git a/drivers/virt/coco/arm-cca-guest/Makefile b/drivers/virt/coco/a= rm-cca-guest/Makefile index 69eeba08e98a..75a120e24fda 100644 --- a/drivers/virt/coco/arm-cca-guest/Makefile +++ b/drivers/virt/coco/arm-cca-guest/Makefile @@ -1,2 +1,4 @@ # SPDX-License-Identifier: GPL-2.0-only obj-$(CONFIG_ARM_CCA_GUEST) +=3D arm-cca-guest.o + +arm-cca-guest-y +=3D arm-cca.o diff --git a/drivers/virt/coco/arm-cca-guest/arm-cca-guest.c b/drivers/virt= /coco/arm-cca-guest/arm-cca.c similarity index 85% rename from drivers/virt/coco/arm-cca-guest/arm-cca-guest.c rename to drivers/virt/coco/arm-cca-guest/arm-cca.c index 0c9ea24a200c..dc96171791db 100644 --- a/drivers/virt/coco/arm-cca-guest/arm-cca-guest.c +++ b/drivers/virt/coco/arm-cca-guest/arm-cca.c @@ -3,6 +3,7 @@ * Copyright (C) 2023 ARM Ltd. */ =20 +#include #include #include #include @@ -181,52 +182,50 @@ static int arm_cca_report_new(struct tsm_report *repo= rt, void *data) return ret; } =20 -static const struct tsm_report_ops arm_cca_tsm_ops =3D { +static const struct tsm_report_ops arm_cca_tsm_report_ops =3D { .name =3D KBUILD_MODNAME, .report_new =3D arm_cca_report_new, }; =20 -/** - * arm_cca_guest_init - Register with the Trusted Security Module (TSM) - * interface. - * - * Return: - * * %0 - Registered successfully with the TSM interface. - * * %-ENODEV - The execution context is not an Arm Realm. - * * %-EBUSY - Already registered. - */ -static int __init arm_cca_guest_init(void) +static void unregister_cca_tsm_report(void *data) +{ + tsm_report_unregister(&arm_cca_tsm_report_ops); +} + +static int cca_devsec_tsm_probe(struct auxiliary_device *adev, + const struct auxiliary_device_id *id) { int ret; =20 if (!is_realm_world()) return -ENODEV; =20 - ret =3D tsm_report_register(&arm_cca_tsm_ops, NULL); - if (ret < 0) + ret =3D tsm_report_register(&arm_cca_tsm_report_ops, NULL); + if (ret < 0) { pr_err("Error %d registering with TSM\n", ret); + return ret; + } =20 - return ret; -} -module_init(arm_cca_guest_init); + ret =3D devm_add_action_or_reset(&adev->dev, unregister_cca_tsm_report, N= ULL); + if (ret < 0) { + pr_err("Error %d registering devm action\n", ret); + return ret; + } =20 -/** - * arm_cca_guest_exit - unregister with the Trusted Security Module (TSM) - * interface. - */ -static void __exit arm_cca_guest_exit(void) -{ - tsm_report_unregister(&arm_cca_tsm_ops); + return 0; } -module_exit(arm_cca_guest_exit); =20 -/* modalias, so userspace can autoload this module when RSI is available */ -static const struct platform_device_id arm_cca_match[] __maybe_unused =3D { - { RSI_PDEV_NAME, 0}, - { } +static const struct auxiliary_device_id cca_devsec_tsm_id_table[] =3D { + { .name =3D KBUILD_MODNAME "." RSI_DEV_NAME }, + {} }; +MODULE_DEVICE_TABLE(auxiliary, cca_devsec_tsm_id_table); =20 -MODULE_DEVICE_TABLE(platform, arm_cca_match); +static struct auxiliary_driver cca_devsec_tsm_driver =3D { + .probe =3D cca_devsec_tsm_probe, + .id_table =3D cca_devsec_tsm_id_table, +}; +module_auxiliary_driver(cca_devsec_tsm_driver); MODULE_AUTHOR("Sami Mujawar "); MODULE_DESCRIPTION("Arm CCA Guest TSM Driver"); MODULE_LICENSE("GPL"); --=20 2.43.0 From nobody Sat Feb 7 15:09:52 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 470212F49E4; Mon, 27 Oct 2025 09:56:45 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761559005; cv=none; b=ASwwT6P4vPXw8NtylDJlpSj0uo/eFK3n9ISpekbPEy4PFaLmbWvb7wRG2cd70fOSGFrUZapfjEEl0mHpqjvbF3p1/ieXyzedAGSAnoSyyPphxaQ+HGolOaU0wx7vOtyqU192Hob7JGgw4BpELZWKn3YHvjFNbQIyGawhf5xHsn8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761559005; c=relaxed/simple; bh=sYVeDu9M+oOjuuqkIzrIaSA25SCHmjEU+UGiJsr+pIQ=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=DUKUNsGhxWnwsGU+C0lO8sZyDUnEjZ9g812B2ek9q6kjH2D3Q5nbasm12pJCzw9MMSvfs6zFx6bn4H1sle5HoMpLSJvclTILgqgcmaksK4mU0g6R148rwtu3JqhxlrDZRKEp0VIrHn8OVSdQ0TrTo8mcGRoYSHe1Ipi/q7Zp9Ko= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=A7ea78Yl; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="A7ea78Yl" Received: by smtp.kernel.org (Postfix) with ESMTPSA id CF2A2C4CEF1; Mon, 27 Oct 2025 09:56:39 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1761559004; bh=sYVeDu9M+oOjuuqkIzrIaSA25SCHmjEU+UGiJsr+pIQ=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=A7ea78Yl1VUrPFcktNScG+wmQp4Vagz7qRKK4leTFiG9jaWbiqeulHFn+07OO1OZ+ E1hAqSzeqamYBuoHqtOSbRa4SthnbQZuph7otTXHI5/s8SwjOFythGlsoAkQB9zIF0 wppCbeIwCOuB8QI3uLOTSxZPu2in+MJa6rI6KOLcl1QmfnjSqn6yUBx66Jp3jm9e8n FQbE2laJceQECIlmGvQvy7oUfSd0SgQLGe5lVJ1srEgk9vDyhHZOUCLacNe6r80nXc mOameMpSx1sWbW4gZJ0oaOXElYYsJgP2KkTMDIN6IJ0RCZWsBj3KtN5Vv4FgpA1/fW UiPQAMfmbUMAQ== From: "Aneesh Kumar K.V (Arm)" To: linux-coco@lists.linux.dev, kvmarm@lists.linux.dev Cc: linux-pci@vger.kernel.org, linux-kernel@vger.kernel.org, dan.j.williams@intel.com, aik@amd.com, lukas@wunner.de, Samuel Ortiz , Xu Yilun , Jason Gunthorpe , Suzuki K Poulose , Steven Price , Bjorn Helgaas , Jonathan Cameron , Catalin Marinas , Marc Zyngier , Will Deacon , Oliver Upton , "Aneesh Kumar K.V (Arm)" Subject: [PATCH RESEND v2 03/12] coco: guest: arm64: Drop dummy RSI platform device stub Date: Mon, 27 Oct 2025 15:25:53 +0530 Message-ID: <20251027095602.1154418-4-aneesh.kumar@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251027095602.1154418-1-aneesh.kumar@kernel.org> References: <20251027095602.1154418-1-aneesh.kumar@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" The SMCCC firmware driver now creates the `arm-smccc` platform device and also creates the CCA auxiliary devices once the RSI ABI is discovered. This makes the arch-specific arm64_create_dummy_rsi_dev() helper redundant. Remove the arm-cca-dev platform device registration and let the SMCCC probe manage the RSI device. systemd match on platform:arm-cca-dev for confidential vm detection [1]. Losing the platform device registration can break that. Keeping this removal in its own change makes it easy to revert if that regression blocks the rollout. [1] https://lore.kernel.org/all/4a7d84b2-2ec4-4773-a2d5-7b63d5c683cf@arm.com Signed-off-by: Aneesh Kumar K.V (Arm) Reviewed-by: Jonathan Cameron --- arch/arm64/kernel/rsi.c | 15 --------------- 1 file changed, 15 deletions(-) diff --git a/arch/arm64/kernel/rsi.c b/arch/arm64/kernel/rsi.c index 5d711942e543..1b716d18b80e 100644 --- a/arch/arm64/kernel/rsi.c +++ b/arch/arm64/kernel/rsi.c @@ -158,18 +158,3 @@ void __init arm64_rsi_init(void) =20 static_branch_enable(&rsi_present); } - -static struct platform_device rsi_dev =3D { - .name =3D "arm-cca-dev", - .id =3D PLATFORM_DEVID_NONE -}; - -static int __init arm64_create_dummy_rsi_dev(void) -{ - if (is_realm_world() && - platform_device_register(&rsi_dev)) - pr_err("failed to register rsi platform device\n"); - return 0; -} - -arch_initcall(arm64_create_dummy_rsi_dev) --=20 2.43.0 From nobody Sat Feb 7 15:09:52 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 31D412FA0DD; Mon, 27 Oct 2025 09:56:50 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761559011; cv=none; b=eHcMAK79Izjx3uVB0ncqu6+Pa9/fpCju3FryJCVLOaHu3B8Rc0lPYzXHH6GO/AT0OoGwNutwSdoTbuAIMcxJ/bCjd1JCCEWmmp42mAnV3gcARGDKQhxkelQ5K9AMaFM4eyeWGn6K3Cy8v+IeUKuI85TFNlnLyGPUDbZTcm/QEd0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761559011; c=relaxed/simple; bh=gBvpmEpy6YyVBCSVn6cH5J7g2XLImTLNf6qfNZEbRhg=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=a+5Ln9Q4YF0ju+6W0FaJZ0nMQ0sfNbUDA0OGtSeIkEvNDQMJPsobpTY9cr2CTmmW5fryV3QzyNUwJhuqnRJcZLWERbZTKLrxWSPAR3VUSjYldnqYNK3+5x9FWkQnAPbmr+lkgePW4/VMsbMc2oqH8jirR9hjdpEzsjNLzdCyAZg= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=fhvEXaNP; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="fhvEXaNP" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 73D90C4CEF1; Mon, 27 Oct 2025 09:56:45 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1761559010; bh=gBvpmEpy6YyVBCSVn6cH5J7g2XLImTLNf6qfNZEbRhg=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=fhvEXaNP7qD/GKDMkjKy+jrOpMDYjukeeERAfjmEbps1GbOQ5k9l1j65no8Ka8nLM Qdh9q0DQ47vdUxzGUGbiLxB5umnUWAjdfxhs+elqLOIJwC/+6MNSc7O+e07OiRP8Uc q9ejIdMNIV76DfGd1iLddGiwtjPOSUH1gczkQscX2kFgPL23Sosk6Bfywj1mxzVL6T CF7rR8IFjfgXeZFLYh1ZRSRJ3G7nBY5p/H5dWXDX+AUMr8/u78NAwbtjInTgJeZdwC /svKBvX2d5G+vKJAH0IfKxv3Dhm2FCvPygP58n3egjzKOkqC8Y2HgUUlI6O/mW9O9U 3ulZNqDS5zYlQ== From: "Aneesh Kumar K.V (Arm)" To: linux-coco@lists.linux.dev, kvmarm@lists.linux.dev Cc: linux-pci@vger.kernel.org, linux-kernel@vger.kernel.org, dan.j.williams@intel.com, aik@amd.com, lukas@wunner.de, Samuel Ortiz , Xu Yilun , Jason Gunthorpe , Suzuki K Poulose , Steven Price , Bjorn Helgaas , Jonathan Cameron , Catalin Marinas , Marc Zyngier , Will Deacon , Oliver Upton , "Aneesh Kumar K.V (Arm)" Subject: [PATCH RESEND v2 04/12] coco: host: arm64: Add host TSM callback and IDE stream allocation support Date: Mon, 27 Oct 2025 15:25:54 +0530 Message-ID: <20251027095602.1154418-5-aneesh.kumar@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251027095602.1154418-1-aneesh.kumar@kernel.org> References: <20251027095602.1154418-1-aneesh.kumar@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Register the TSM callback when the DA feature is supported by KVM. This driver handles IDE stream setup for both the root port and PCIe endpoints. Root port IDE stream enablement itself is managed by RMM. In addition, the driver registers `pci_tsm_ops` with the TSM subsystem. Signed-off-by: Aneesh Kumar K.V (Arm) --- arch/arm64/include/asm/rmi_smc.h | 2 + drivers/firmware/smccc/smccc.c | 19 +++ drivers/virt/coco/Kconfig | 2 + drivers/virt/coco/Makefile | 1 + drivers/virt/coco/arm-cca-host/Kconfig | 19 +++ drivers/virt/coco/arm-cca-host/Makefile | 5 + drivers/virt/coco/arm-cca-host/arm-cca.c | 192 +++++++++++++++++++++++ drivers/virt/coco/arm-cca-host/rmi-da.h | 41 +++++ 8 files changed, 281 insertions(+) create mode 100644 drivers/virt/coco/arm-cca-host/Kconfig create mode 100644 drivers/virt/coco/arm-cca-host/Makefile create mode 100644 drivers/virt/coco/arm-cca-host/arm-cca.c create mode 100644 drivers/virt/coco/arm-cca-host/rmi-da.h diff --git a/arch/arm64/include/asm/rmi_smc.h b/arch/arm64/include/asm/rmi_= smc.h index 2ea657a87402..fe1c91ffc0ab 100644 --- a/arch/arm64/include/asm/rmi_smc.h +++ b/arch/arm64/include/asm/rmi_smc.h @@ -12,6 +12,8 @@ =20 #include =20 +#define RMI_DEV_NAME "arm-rmi-dev" + #define SMC_RMI_CALL(func) \ ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, \ ARM_SMCCC_SMC_64, \ diff --git a/drivers/firmware/smccc/smccc.c b/drivers/firmware/smccc/smccc.c index 3dbf0d067cc5..9cabe750533c 100644 --- a/drivers/firmware/smccc/smccc.c +++ b/drivers/firmware/smccc/smccc.c @@ -15,6 +15,7 @@ #include #ifdef CONFIG_ARM64 #include +#include #endif =20 static u32 smccc_version =3D ARM_SMCCC_VERSION_1_0; @@ -99,10 +100,27 @@ static void __init register_rsi_device(struct platform= _device *pdev) "arm_cca_guest", RSI_DEV_NAME, NULL, 0); =20 } + +static void __init register_rmi_device(struct platform_device *pdev) +{ + struct arm_smccc_res res; + unsigned long host_version =3D RMI_ABI_VERSION(RMI_ABI_MAJOR_VERSION, + RMI_ABI_MINOR_VERSION); + + arm_smccc_1_1_invoke(SMC_RMI_VERSION, host_version, &res); + if (res.a0 =3D=3D RMI_SUCCESS) + __devm_auxiliary_device_create(&pdev->dev, + "arm_cca_host", RMI_DEV_NAME, NULL, 0); +} #else static void __init register_rsi_device(struct platform_device *pdev) { =20 +} + +static void __init register_rmi_device(struct platform_device *pdev) +{ + } #endif =20 @@ -120,6 +138,7 @@ static int __init smccc_devices_init(void) * the required SMCCC function IDs at a supported revision. */ register_rsi_device(pdev); + register_rmi_device(pdev); } =20 if (smccc_trng_available) { diff --git a/drivers/virt/coco/Kconfig b/drivers/virt/coco/Kconfig index bb0c6d6ddcc8..65b284c59b96 100644 --- a/drivers/virt/coco/Kconfig +++ b/drivers/virt/coco/Kconfig @@ -15,5 +15,7 @@ source "drivers/virt/coco/arm-cca-guest/Kconfig" =20 source "drivers/virt/coco/guest/Kconfig" =20 +source "drivers/virt/coco/arm-cca-host/Kconfig" + config TSM bool diff --git a/drivers/virt/coco/Makefile b/drivers/virt/coco/Makefile index cb52021912b3..c06b66041a49 100644 --- a/drivers/virt/coco/Makefile +++ b/drivers/virt/coco/Makefile @@ -9,3 +9,4 @@ obj-$(CONFIG_INTEL_TDX_GUEST) +=3D tdx-guest/ obj-$(CONFIG_ARM_CCA_GUEST) +=3D arm-cca-guest/ obj-$(CONFIG_TSM) +=3D tsm-core.o obj-$(CONFIG_TSM_GUEST) +=3D guest/ +obj-$(CONFIG_ARM_CCA_HOST) +=3D arm-cca-host/ diff --git a/drivers/virt/coco/arm-cca-host/Kconfig b/drivers/virt/coco/arm= -cca-host/Kconfig new file mode 100644 index 000000000000..1febd316fb77 --- /dev/null +++ b/drivers/virt/coco/arm-cca-host/Kconfig @@ -0,0 +1,19 @@ +# SPDX-License-Identifier: GPL-2.0-only +# +# TSM (TEE Security Manager) host drivers +# +config ARM_CCA_HOST + tristate "Arm CCA Host driver" + depends on ARM64 + depends on PCI_TSM + depends on KVM + select TSM + select AUXILIARY_BUS + + help + ARM CCA RMM firmware is the trusted runtime that enforces memory + isolation and security for confidential computing on ARM. This driver + provides the interface for communicating with RMM to support secure + device assignment. + + If you choose 'M' here, this module will be called arm-cca-host. diff --git a/drivers/virt/coco/arm-cca-host/Makefile b/drivers/virt/coco/ar= m-cca-host/Makefile new file mode 100644 index 000000000000..ad353b07e95a --- /dev/null +++ b/drivers/virt/coco/arm-cca-host/Makefile @@ -0,0 +1,5 @@ +# SPDX-License-Identifier: GPL-2.0-only +# +obj-$(CONFIG_ARM_CCA_HOST) +=3D arm-cca-host.o + +arm-cca-host-$(CONFIG_TSM) +=3D arm-cca.o diff --git a/drivers/virt/coco/arm-cca-host/arm-cca.c b/drivers/virt/coco/a= rm-cca-host/arm-cca.c new file mode 100644 index 000000000000..18e5bf6adea4 --- /dev/null +++ b/drivers/virt/coco/arm-cca-host/arm-cca.c @@ -0,0 +1,192 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (C) 2025 ARM Ltd. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "rmi-da.h" + +/* Total number of stream id supported at root port level */ +#define MAX_STREAM_ID 256 + + +static struct pci_tsm *cca_tsm_pci_probe(struct tsm_dev *tsm_dev, struct p= ci_dev *pdev) +{ + int rc; + + if (!is_pci_tsm_pf0(pdev)) { + struct cca_host_fn_dsc *fn_dsc __free(kfree) =3D + kzalloc(sizeof(*fn_dsc), GFP_KERNEL); + + if (!fn_dsc) + return NULL; + + rc =3D pci_tsm_link_constructor(pdev, &fn_dsc->pci, tsm_dev); + if (rc) + return NULL; + + return &no_free_ptr(fn_dsc)->pci; + } + + if (!pdev->ide_cap) + return NULL; + + struct cca_host_pf0_dsc *pf0_dsc __free(kfree) =3D + kzalloc(sizeof(*pf0_dsc), GFP_KERNEL); + if (!pf0_dsc) + return NULL; + + rc =3D pci_tsm_pf0_constructor(pdev, &pf0_dsc->pci, tsm_dev); + if (rc) + return NULL; + + pci_dbg(pdev, "tsm enabled\n"); + return &no_free_ptr(pf0_dsc)->pci.base_tsm; +} + +static void cca_tsm_pci_remove(struct pci_tsm *tsm) +{ + struct pci_dev *pdev =3D tsm->pdev; + + if (is_pci_tsm_pf0(pdev)) { + struct cca_host_pf0_dsc *pf0_dsc =3D to_cca_pf0_dsc(pdev); + + pci_tsm_pf0_destructor(&pf0_dsc->pci); + kfree(pf0_dsc); + } else { + struct cca_host_fn_dsc *fn_dsc =3D to_cca_fn_dsc(pdev); + + kfree(fn_dsc); + return; + } +} + +/* For now global for simplicity. Protected by pci_tsm_rwsem */ +static DECLARE_BITMAP(cca_stream_ids, MAX_STREAM_ID); + +static int cca_tsm_connect(struct pci_dev *pdev) +{ + struct pci_dev *rp =3D pcie_find_root_port(pdev); + struct cca_host_pf0_dsc *pf0_dsc; + struct pci_ide *ide; + int rc, stream_id; + + /* Only function 0 supports connect in host */ + if (WARN_ON(!is_pci_tsm_pf0(pdev))) + return -EIO; + + pf0_dsc =3D to_cca_pf0_dsc(pdev); + /* Allocate stream id */ + stream_id =3D find_first_zero_bit(cca_stream_ids, MAX_STREAM_ID); + if (stream_id =3D=3D MAX_STREAM_ID) + return -EBUSY; + set_bit(stream_id, cca_stream_ids); + + ide =3D pci_ide_stream_alloc(pdev); + if (!ide) { + rc =3D -ENOMEM; + goto err_stream_alloc; + } + + pf0_dsc->sel_stream =3D ide; + ide->stream_id =3D stream_id; + rc =3D pci_ide_stream_register(ide); + if (rc) + goto err_stream; + + pci_ide_stream_setup(pdev, ide); + pci_ide_stream_setup(rp, ide); + + rc =3D tsm_ide_stream_register(ide); + if (rc) + goto err_tsm; + + /* + * Once ide is setup, enable the stream at the endpoint + * Root port will be done by RMM + */ + pci_ide_stream_enable(pdev, ide); + return 0; + +err_tsm: + pci_ide_stream_teardown(rp, ide); + pci_ide_stream_teardown(pdev, ide); + pci_ide_stream_unregister(ide); +err_stream: + pci_ide_stream_free(ide); +err_stream_alloc: + clear_bit(stream_id, cca_stream_ids); + + return rc; +} + +static void cca_tsm_disconnect(struct pci_dev *pdev) +{ + int stream_id; + struct pci_ide *ide; + struct cca_host_pf0_dsc *pf0_dsc; + + pf0_dsc =3D to_cca_pf0_dsc(pdev); + if (!pf0_dsc) + return; + + ide =3D pf0_dsc->sel_stream; + stream_id =3D ide->stream_id; + pf0_dsc->sel_stream =3D NULL; + + pci_ide_stream_release(ide); + clear_bit(stream_id, cca_stream_ids); +} + +static struct pci_tsm_ops cca_link_pci_ops =3D { + .probe =3D cca_tsm_pci_probe, + .remove =3D cca_tsm_pci_remove, + .connect =3D cca_tsm_connect, + .disconnect =3D cca_tsm_disconnect, +}; + +static void cca_link_tsm_remove(void *tsm_dev) +{ + tsm_unregister(tsm_dev); +} + +static int cca_link_tsm_probe(struct auxiliary_device *adev, + const struct auxiliary_device_id *id) +{ + if (kvm_has_da_feature()) { + struct tsm_dev *tsm_dev; + + tsm_dev =3D tsm_register(&adev->dev, &cca_link_pci_ops); + if (IS_ERR(tsm_dev)) + return PTR_ERR(tsm_dev); + + return devm_add_action_or_reset(&adev->dev, + cca_link_tsm_remove, tsm_dev); + } + return -ENODEV; +} + +static const struct auxiliary_device_id cca_link_tsm_id_table[] =3D { + { .name =3D KBUILD_MODNAME "." RMI_DEV_NAME }, + {} +}; +MODULE_DEVICE_TABLE(auxiliary, cca_link_tsm_id_table); + +static struct auxiliary_driver cca_link_tsm_driver =3D { + .probe =3D cca_link_tsm_probe, + .id_table =3D cca_link_tsm_id_table, +}; +module_auxiliary_driver(cca_link_tsm_driver); +MODULE_IMPORT_NS("PCI_IDE"); +MODULE_AUTHOR("Aneesh Kumar "); +MODULE_DESCRIPTION("ARM CCA Host TSM driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/virt/coco/arm-cca-host/rmi-da.h b/drivers/virt/coco/ar= m-cca-host/rmi-da.h new file mode 100644 index 000000000000..01dfb42cd39e --- /dev/null +++ b/drivers/virt/coco/arm-cca-host/rmi-da.h @@ -0,0 +1,41 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Copyright (C) 2025 ARM Ltd. + */ + +#ifndef _VIRT_COCO_RMM_DA_H_ +#define _VIRT_COCO_RMM_DA_H_ + +#include +#include +#include +#include + +/* dsc =3D device security context */ +struct cca_host_pf0_dsc { + struct pci_tsm_pf0 pci; + struct pci_ide *sel_stream; +}; + +struct cca_host_fn_dsc { + struct pci_tsm pci; +}; + +static inline struct cca_host_pf0_dsc *to_cca_pf0_dsc(struct pci_dev *pdev) +{ + struct pci_tsm *tsm =3D pdev->tsm; + + if (!tsm || pdev->is_virtfn || !is_pci_tsm_pf0(pdev)) + return NULL; + + return container_of(tsm, struct cca_host_pf0_dsc, pci.base_tsm); +} + +static inline struct cca_host_fn_dsc *to_cca_fn_dsc(struct pci_dev *pdev) +{ + struct pci_tsm *tsm =3D pdev->tsm; + + return container_of(tsm, struct cca_host_fn_dsc, pci); +} + +#endif --=20 2.43.0 From nobody Sat Feb 7 15:09:52 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id BA3B72FB098; Mon, 27 Oct 2025 09:56:56 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761559016; cv=none; b=nH4tjLmTxTKlhE9xi915c9GbONgqVvjUUD14vJ9GJFcmhIfjpZ3dS0x9WVRYf6LUduphjb1QUZKoMjyMs/+Z/u6c1tbaq/GzRDS6ITTx4+8QOJwLJgB/FMWWXu9eulK86DqVJSxUTYRG5x3nlSmRYqMEIHxAEahEhGSze3Q1KCc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761559016; c=relaxed/simple; bh=QyVzkmCjMu/50vNSNAkzNRdjuRbF3e26UinRbPg+dDA=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=U1aBmOXB0qCtuMyHmWk1+xuxP/bQVt72Gr+lxcKDDtjOb0Bn9bVPJwHaLr4g/7YfND6/UUkWxXbGmYMVFrbaHApM3vbXEU7d2IlHQYSNXPbCDx7+gS/REOepGDxGwNq9zObhgcfec+MpX2GRgvuzmno88qswELkTf2pdCa7738k= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=tJlcBNA3; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="tJlcBNA3" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 51040C116B1; Mon, 27 Oct 2025 09:56:51 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1761559016; bh=QyVzkmCjMu/50vNSNAkzNRdjuRbF3e26UinRbPg+dDA=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=tJlcBNA3+4Yhov5KrB+mRKl4WzMDTBADx0RsmBLYiwRheSRdZcSPe4wzenu5Rp8G+ gxy2JV8nkNLSx0/Wa2flTCWnx6G96RlrJzCAkuD3Lx+JjCkjbsMy3JdF234gBCux3k NOAvxLiyYkqoIKDCOdqDhLDPYSQqGkusR1PTN7oTL7ZGJbwdryQ0wIqIPGe+XN7qwK ChBCfx7QLMwH48Klp8HeStViDS0k5TR337WwYI3pgjvicfqTLD0w129WfpMpIqvghU PuDHVqM0jKywEizMBSkZwG0zQ8LfZ3iAtztXcZtVFRaJoETlQDK02X2hH5ciqLrda9 tL+5Wq1CB2Rqg== From: "Aneesh Kumar K.V (Arm)" To: linux-coco@lists.linux.dev, kvmarm@lists.linux.dev Cc: linux-pci@vger.kernel.org, linux-kernel@vger.kernel.org, dan.j.williams@intel.com, aik@amd.com, lukas@wunner.de, Samuel Ortiz , Xu Yilun , Jason Gunthorpe , Suzuki K Poulose , Steven Price , Bjorn Helgaas , Jonathan Cameron , Catalin Marinas , Marc Zyngier , Will Deacon , Oliver Upton , "Aneesh Kumar K.V (Arm)" Subject: [PATCH RESEND v2 05/12] coco: host: arm64: Build and register RMM pdev descriptors Date: Mon, 27 Oct 2025 15:25:55 +0530 Message-ID: <20251027095602.1154418-6-aneesh.kumar@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251027095602.1154418-1-aneesh.kumar@kernel.org> References: <20251027095602.1154418-1-aneesh.kumar@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add the SMCCC plumbing for RMI_PDEV_AUX_COUNT, RMI_PDEV_CREATE, and RMI_PDEV_GET_STATE, describe the pdev state enum/flags in rmi_smc.h, and extend the PF0 descriptor so we can hold the RMM-side pdev handle plus its auxiliary granules. Implement pdev_create() to delegate backing pages, populate the pdev parameters from the device's RID, ECAM window, IDE stream, and non-coherent address ranges, and invoke RMI_PDEV_CREATE. The helper keeps track of the allocated/assigned granules and unwinds them on failure, so the host driver can reliably establish the pdev channel before kicking off further IDE/TSM setup. Signed-off-by: Aneesh Kumar K.V (Arm) --- arch/arm64/include/asm/rmi_cmds.h | 31 ++++++ arch/arm64/include/asm/rmi_smc.h | 94 +++++++++++++++- drivers/virt/coco/arm-cca-host/Makefile | 2 +- drivers/virt/coco/arm-cca-host/rmi-da.c | 141 ++++++++++++++++++++++++ drivers/virt/coco/arm-cca-host/rmi-da.h | 5 + 5 files changed, 271 insertions(+), 2 deletions(-) create mode 100644 drivers/virt/coco/arm-cca-host/rmi-da.c diff --git a/arch/arm64/include/asm/rmi_cmds.h b/arch/arm64/include/asm/rmi= _cmds.h index ef53147c1984..4547ce0901a6 100644 --- a/arch/arm64/include/asm/rmi_cmds.h +++ b/arch/arm64/include/asm/rmi_cmds.h @@ -505,4 +505,35 @@ static inline int rmi_rtt_unmap_unprotected(unsigned l= ong rd, return res.a0; } =20 +static inline unsigned long rmi_pdev_aux_count(unsigned long flags, u64 *a= ux_count) +{ + struct arm_smccc_res res; + + arm_smccc_1_1_invoke(SMC_RMI_PDEV_AUX_COUNT, flags, &res); + + *aux_count =3D res.a1; + return res.a0; +} + +static inline unsigned long rmi_pdev_create(unsigned long pdev_phys, + unsigned long pdev_params_phys) +{ + struct arm_smccc_res res; + + arm_smccc_1_1_invoke(SMC_RMI_PDEV_CREATE, + pdev_phys, pdev_params_phys, &res); + + return res.a0; +} + +static inline unsigned long rmi_pdev_get_state(unsigned long pdev_phys, en= um rmi_pdev_state *state) +{ + struct arm_smccc_res res; + + arm_smccc_1_1_invoke(SMC_RMI_PDEV_GET_STATE, pdev_phys, &res); + + *state =3D res.a1; + return res.a0; +} + #endif /* __ASM_RMI_CMDS_H */ diff --git a/arch/arm64/include/asm/rmi_smc.h b/arch/arm64/include/asm/rmi_= smc.h index fe1c91ffc0ab..10f87a18f09a 100644 --- a/arch/arm64/include/asm/rmi_smc.h +++ b/arch/arm64/include/asm/rmi_smc.h @@ -26,7 +26,7 @@ #define SMC_RMI_DATA_CREATE SMC_RMI_CALL(0x0153) #define SMC_RMI_DATA_CREATE_UNKNOWN SMC_RMI_CALL(0x0154) #define SMC_RMI_DATA_DESTROY SMC_RMI_CALL(0x0155) - +#define SMC_RMI_PDEV_AUX_COUNT SMC_RMI_CALL(0x0156) #define SMC_RMI_REALM_ACTIVATE SMC_RMI_CALL(0x0157) #define SMC_RMI_REALM_CREATE SMC_RMI_CALL(0x0158) #define SMC_RMI_REALM_DESTROY SMC_RMI_CALL(0x0159) @@ -47,6 +47,9 @@ #define SMC_RMI_RTT_INIT_RIPAS SMC_RMI_CALL(0x0168) #define SMC_RMI_RTT_SET_RIPAS SMC_RMI_CALL(0x0169) =20 +#define SMC_RMI_PDEV_CREATE SMC_RMI_CALL(0x0176) +#define SMC_RMI_PDEV_GET_STATE SMC_RMI_CALL(0x0178) + #define RMI_ABI_MAJOR_VERSION 1 #define RMI_ABI_MINOR_VERSION 0 =20 @@ -269,4 +272,93 @@ struct rec_run { struct rec_exit exit; }; =20 +enum rmi_pdev_state { + RMI_PDEV_NEW, + RMI_PDEV_NEEDS_KEY, + RMI_PDEV_HAS_KEY, + RMI_PDEV_READY, + RMI_PDEV_IDE_RESETTING, + RMI_PDEV_COMMUNICATING, + RMI_PDEV_STOPPING, + RMI_PDEV_STOPPED, + RMI_PDEV_ERROR, +}; + +#define MAX_PDEV_AUX_GRANULES 32 +#define MAX_IOCOH_ADDR_RANGE 16 +#define MAX_FCOH_ADDR_RANGE 4 + +#define RMI_PDEV_FLAGS_SPDM BIT(0) +#define RMI_PDEV_FLAGS_NCOH_IDE BIT(1) +#define RMI_PDEV_FLAGS_NCOH_ADDR BIT(2) +#define RMI_PDEV_FLAGS_COH_IDE BIT(3) +#define RMI_PDEV_FLAGS_COH_ADDR BIT(4) +#define RMI_PDEV_FLAGS_P2P BIT(5) +#define RMI_PDEV_FLAGS_COMP_TRUST BIT(6) +#define RMI_PDEV_FLAGS_CATEGORY GENMASK(8, 7) + +#define RMI_PDEV_CMEM_CXL_CATEGORY BIT(7) + +#define RMI_HASH_SHA_256 0 +#define RMI_HASH_SHA_512 1 + +struct rmi_pdev_addr_range { + u64 base; + u64 top; +}; + +struct rmi_pdev_params { + union { + struct { + u64 flags; + u64 pdev_id; + union { + u8 segment_id; + u64 padding0; + }; + u64 ecam_addr; + union { + u16 root_id; + u64 padding1; + }; + u64 cert_id; + union { + u16 rid_base; + u64 padding2; + }; + union { + u16 rid_top; + u64 padding3; + }; + union { + u8 hash_algo; + u64 padding4; + }; + u64 num_aux; + u64 ncoh_ide_sid; + u64 ncoh_num_addr_range; + u64 coh_num_addr_range; + }; + u8 padding5[0x100]; + }; + + union { /* 0x100 */ + u64 aux_granule[MAX_PDEV_AUX_GRANULES]; + u8 padding6[0x100]; + }; + + union { /* 0x200 */ + struct { + struct rmi_pdev_addr_range ncoh_addr_range[MAX_IOCOH_ADDR_RANGE]; + }; + u8 padding7[0x100]; + }; + union { /* 0x300 */ + struct { + struct rmi_pdev_addr_range coh_addr_range[MAX_FCOH_ADDR_RANGE]; + }; + u8 padding8[0x100]; + }; +}; + #endif /* __ASM_RMI_SMC_H */ diff --git a/drivers/virt/coco/arm-cca-host/Makefile b/drivers/virt/coco/ar= m-cca-host/Makefile index ad353b07e95a..a5694a3a7983 100644 --- a/drivers/virt/coco/arm-cca-host/Makefile +++ b/drivers/virt/coco/arm-cca-host/Makefile @@ -2,4 +2,4 @@ # obj-$(CONFIG_ARM_CCA_HOST) +=3D arm-cca-host.o =20 -arm-cca-host-$(CONFIG_TSM) +=3D arm-cca.o +arm-cca-host-$(CONFIG_TSM) +=3D arm-cca.o rmi-da.o diff --git a/drivers/virt/coco/arm-cca-host/rmi-da.c b/drivers/virt/coco/ar= m-cca-host/rmi-da.c new file mode 100644 index 000000000000..390b8f05c7cf --- /dev/null +++ b/drivers/virt/coco/arm-cca-host/rmi-da.c @@ -0,0 +1,141 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (C) 2025 ARM Ltd. + */ + +#include +#include +#include + +#include "rmi-da.h" + +static int pci_ide_aassoc_register_to_pdev_addr(struct rmi_pdev_addr_range= *pdev_addr, + unsigned int naddr, struct pci_ide_partner *partner) +{ + pdev_addr[0].base =3D partner->mem_assoc.start; + pdev_addr[0].top =3D partner->mem_assoc.end + 1; + naddr--; + + if (!naddr) + return 1; + + pdev_addr[1].base =3D partner->pref_assoc.start; + pdev_addr[1].top =3D partner->pref_assoc.end + 1; + + return 2; +} + +static void free_aux_pages(int cnt, void *aux[]) +{ + int ret; + + while (cnt--) { + ret =3D rmi_granule_undelegate(virt_to_phys(aux[cnt])); + if (!ret) + free_page((unsigned long)aux[cnt]); + } +} + +static int init_pdev_params(struct pci_dev *pdev, struct rmi_pdev_params *= params) +{ + int rid, ret, i; + phys_addr_t aux_phys; + struct pci_config_window *cfg =3D pdev->bus->sysdata; + struct cca_host_pf0_dsc *pf0_dsc =3D to_cca_pf0_dsc(pdev); + struct pci_ide *ide =3D pf0_dsc->sel_stream; + + /* assign the ep device with RMM */ + rid =3D pci_dev_id(pdev); + params->pdev_id =3D rid; + /* slot number for certificate chain */ + params->cert_id =3D 0; + /* io coherent spdm/ide and non p2p */ + params->flags =3D RMI_PDEV_FLAGS_SPDM | RMI_PDEV_FLAGS_NCOH_IDE | + RMI_PDEV_FLAGS_NCOH_ADDR; + params->ncoh_ide_sid =3D ide->stream_id; + params->hash_algo =3D RMI_HASH_SHA_256; + /* use the rid and MMIO resources of the end point pdev */ + params->rid_base =3D rid; + params->rid_top =3D params->rid_base + 1; + params->ecam_addr =3D cfg->res.start; + params->root_id =3D pci_dev_id(pcie_find_root_port(pdev)); + + params->ncoh_num_addr_range =3D pci_ide_aassoc_register_to_pdev_addr(para= ms->ncoh_addr_range, + ARRAY_SIZE(params->ncoh_addr_range), + &ide->partner[PCI_IDE_RP]); + + rmi_pdev_aux_count(params->flags, ¶ms->num_aux); + pf0_dsc->num_aux =3D params->num_aux; + for (i =3D 0; i < params->num_aux; i++) { + void *aux =3D (void *)__get_free_page(GFP_KERNEL); + + if (!aux) { + ret =3D -ENOMEM; + goto err_free_aux; + } + + aux_phys =3D virt_to_phys(aux); + if (rmi_granule_delegate(aux_phys)) { + ret =3D -ENXIO; + free_page((unsigned long)aux); + goto err_free_aux; + } + params->aux_granule[i] =3D aux_phys; + pf0_dsc->aux[i] =3D aux; + } + return 0; + +err_free_aux: + free_aux_pages(i, pf0_dsc->aux); + return ret; +} + +int pdev_create(struct pci_dev *pci_dev) +{ + int ret; + void *rmm_pdev; + bool should_free =3D true; + phys_addr_t rmm_pdev_phys; + struct rmi_pdev_params *params; + struct cca_host_pf0_dsc *pf0_dsc =3D to_cca_pf0_dsc(pci_dev); + + rmm_pdev =3D (void *)get_zeroed_page(GFP_KERNEL); + if (!rmm_pdev) + return -ENOMEM; + + rmm_pdev_phys =3D virt_to_phys(rmm_pdev); + if (rmi_granule_delegate(rmm_pdev_phys)) { + ret =3D -ENXIO; + goto err_granule_delegate; + } + + params =3D (struct rmi_pdev_params *)get_zeroed_page(GFP_KERNEL); + if (!params) { + ret =3D -ENOMEM; + goto err_param_alloc; + } + + ret =3D init_pdev_params(pci_dev, params); + if (ret) + goto err_init_pdev_params; + + ret =3D rmi_pdev_create(rmm_pdev_phys, virt_to_phys(params)); + if (ret) + goto err_pdev_create; + + pf0_dsc->rmm_pdev =3D rmm_pdev; + free_page((unsigned long)params); + return 0; + +err_pdev_create: + free_aux_pages(pf0_dsc->num_aux, pf0_dsc->aux); +err_init_pdev_params: + free_page((unsigned long)params); +err_param_alloc: + if (rmi_granule_undelegate(rmm_pdev_phys)) + should_free =3D false; +err_granule_delegate: + if (should_free) + free_page((unsigned long)rmm_pdev); + return ret; +} diff --git a/drivers/virt/coco/arm-cca-host/rmi-da.h b/drivers/virt/coco/ar= m-cca-host/rmi-da.h index 01dfb42cd39e..6764bf8d98ce 100644 --- a/drivers/virt/coco/arm-cca-host/rmi-da.h +++ b/drivers/virt/coco/arm-cca-host/rmi-da.h @@ -15,6 +15,10 @@ struct cca_host_pf0_dsc { struct pci_tsm_pf0 pci; struct pci_ide *sel_stream; + + void *rmm_pdev; + int num_aux; + void *aux[MAX_PDEV_AUX_GRANULES]; }; =20 struct cca_host_fn_dsc { @@ -38,4 +42,5 @@ static inline struct cca_host_fn_dsc *to_cca_fn_dsc(struc= t pci_dev *pdev) return container_of(tsm, struct cca_host_fn_dsc, pci); } =20 +int pdev_create(struct pci_dev *pdev); #endif --=20 2.43.0 From nobody Sat Feb 7 15:09:52 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 560E32F3C31; Mon, 27 Oct 2025 09:57:02 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761559022; cv=none; b=DCirfjvBdsgjdtmVVLALL+X7J4M2jctszIBFSa9oeeRqBbY2RSpZWyS0VEmzxxP6RgLT6omG39oGH40KZ6B6MffrcJAd6uIUFI3oDpGOeBxh6JLWXsfbsia/tHE3gYPlRMtWEhc/3lHz21PFDnF5HvLU3STLHXEJGCk/IWvSycI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761559022; c=relaxed/simple; bh=8xMFN/TY7tHDrYwOABVfX/JHpdB9RJVhkUzDkm+xiUo=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Im1IRgv1ko3zAb/GWiFvJ3AUk5IHvvuPneNidarRwqLNN+DGfNq0+ra+ftXLuWHlagIA0yYAlrc1DKPS57ImIaDT0ZRqEmWjDYmZzTHQEs2fjL81Q7Ck1gZTha7Ddk5CPX2Dje8mrvBI5NuTwHYl0gw1h2P/5A+R7AMnzo3OAtY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Pe0hjflk; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="Pe0hjflk" Received: by smtp.kernel.org (Postfix) with ESMTPSA id E72EAC4CEF1; Mon, 27 Oct 2025 09:56:56 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1761559022; bh=8xMFN/TY7tHDrYwOABVfX/JHpdB9RJVhkUzDkm+xiUo=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Pe0hjflkB5EiFzda6IDMP8FTV93VulBHe9UAbDBiEwEyqLkI951WVGr4x8PL2m5Tp is7Oawi4gIAc/IjazibbJmGmpDjkU9Y8kP6Fgk2Vk5gaxEki4LAOYUkaBHglBhhcvd gbrJVp3fRGIsLx5sq2q6zqgdrnwKGSyGlqQ2kAqqomPBxQnfuFcYY03aQDy2u+cNRJ B4IZiP8kJDBtCeTj+7peZgjPADDtfnFuMqOw0WvQRKxtYgG0eoIeE/FOY5cf4WzeVT vlFkF0d2bAKiTjDk0Tl6/zu8AliXpW+Tv/1OH0WZceydsVTp4uw6UsZXEcTafSuDCu kDhrv5irPhhQw== From: "Aneesh Kumar K.V (Arm)" To: linux-coco@lists.linux.dev, kvmarm@lists.linux.dev Cc: linux-pci@vger.kernel.org, linux-kernel@vger.kernel.org, dan.j.williams@intel.com, aik@amd.com, lukas@wunner.de, Samuel Ortiz , Xu Yilun , Jason Gunthorpe , Suzuki K Poulose , Steven Price , Bjorn Helgaas , Jonathan Cameron , Catalin Marinas , Marc Zyngier , Will Deacon , Oliver Upton , "Aneesh Kumar K.V (Arm)" Subject: [PATCH RESEND v2 06/12] coco: host: arm64: Add RMM device communication helpers Date: Mon, 27 Oct 2025 15:25:56 +0530 Message-ID: <20251027095602.1154418-7-aneesh.kumar@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251027095602.1154418-1-aneesh.kumar@kernel.org> References: <20251027095602.1154418-1-aneesh.kumar@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" - add SMCCC IDs/wrappers for RMI_PDEV_COMMUNICATE/RMI_PDEV_ABORT - describe the RMM device-communication ABI (struct rmi_dev_comm_*, cache flags, protocol/object IDs, busy error code) - track per-PF0 communication state (buffers, workqueue, cache metadata) and serialize access behind object_lock - plumb a DOE/SPDM worker (pdev_communicate_work) plus shared helpers that submit the SMCCC call, cache multi-part responses, and handle retries/abo= rt - hook the new helpers into the physical function connect path so IDE setup can drive the device to the expected state Signed-off-by: Aneesh Kumar K.V (Arm) --- arch/arm64/include/asm/rmi_cmds.h | 20 ++ arch/arm64/include/asm/rmi_smc.h | 63 ++++++ drivers/virt/coco/arm-cca-host/arm-cca.c | 50 +++++ drivers/virt/coco/arm-cca-host/rmi-da.c | 273 +++++++++++++++++++++++ drivers/virt/coco/arm-cca-host/rmi-da.h | 63 ++++++ 5 files changed, 469 insertions(+) diff --git a/arch/arm64/include/asm/rmi_cmds.h b/arch/arm64/include/asm/rmi= _cmds.h index 4547ce0901a6..b86bf15afcda 100644 --- a/arch/arm64/include/asm/rmi_cmds.h +++ b/arch/arm64/include/asm/rmi_cmds.h @@ -536,4 +536,24 @@ static inline unsigned long rmi_pdev_get_state(unsigne= d long pdev_phys, enum rmi return res.a0; } =20 +static inline unsigned long rmi_pdev_communicate(unsigned long pdev_phys, + unsigned long pdev_comm_data_phys) +{ + struct arm_smccc_res res; + + arm_smccc_1_1_invoke(SMC_RMI_PDEV_COMMUNICATE, + pdev_phys, pdev_comm_data_phys, &res); + + return res.a0; +} + +static inline unsigned long rmi_pdev_abort(unsigned long pdev_phys) +{ + struct arm_smccc_res res; + + arm_smccc_1_1_invoke(SMC_RMI_PDEV_ABORT, pdev_phys, &res); + + return res.a0; +} + #endif /* __ASM_RMI_CMDS_H */ diff --git a/arch/arm64/include/asm/rmi_smc.h b/arch/arm64/include/asm/rmi_= smc.h index 10f87a18f09a..53e46e24c921 100644 --- a/arch/arm64/include/asm/rmi_smc.h +++ b/arch/arm64/include/asm/rmi_smc.h @@ -47,6 +47,8 @@ #define SMC_RMI_RTT_INIT_RIPAS SMC_RMI_CALL(0x0168) #define SMC_RMI_RTT_SET_RIPAS SMC_RMI_CALL(0x0169) =20 +#define SMC_RMI_PDEV_ABORT SMC_RMI_CALL(0x0174) +#define SMC_RMI_PDEV_COMMUNICATE SMC_RMI_CALL(0x0175) #define SMC_RMI_PDEV_CREATE SMC_RMI_CALL(0x0176) #define SMC_RMI_PDEV_GET_STATE SMC_RMI_CALL(0x0178) =20 @@ -69,6 +71,7 @@ #define RMI_ERROR_REALM 2 #define RMI_ERROR_REC 3 #define RMI_ERROR_RTT 4 +#define RMI_BUSY 10 =20 enum rmi_ripas { RMI_EMPTY =3D 0, @@ -361,4 +364,64 @@ struct rmi_pdev_params { }; }; =20 +#define RMI_DEV_COMM_EXIT_CACHE_REQ BIT(0) +#define RMI_DEV_COMM_EXIT_CACHE_RSP BIT(1) +#define RMI_DEV_COMM_EXIT_SEND BIT(2) +#define RMI_DEV_COMM_EXIT_WAIT BIT(3) +#define RMI_DEV_COMM_EXIT_RSP_RESET BIT(4) +#define RMI_DEV_COMM_EXIT_MULTI BIT(5) + +#define RMI_DEV_COMM_NONE 0 +#define RMI_DEV_COMM_RESPONSE 1 +#define RMI_DEV_COMM_ERROR 2 + +#define RMI_PROTOCOL_SPDM 0 +#define RMI_PROTOCOL_SECURE_SPDM 1 + +#define RMI_DEV_VCA 0 +#define RMI_DEV_CERTIFICATE 1 +#define RMI_DEV_MEASUREMENTS 2 +#define RMI_DEV_INTERFACE_REPORT 3 + +struct rmi_dev_comm_enter { + union { + u8 status; + u64 padding0; + }; + u64 req_addr; + u64 resp_addr; + u64 resp_len; +}; + +struct rmi_dev_comm_exit { + u64 flags; + u64 req_cache_offset; + u64 req_cache_len; + u64 rsp_cache_offset; + u64 rsp_cache_len; + union { + u8 cache_obj_id; + u64 padding0; + }; + + union { + u8 protocol; + u64 padding1; + }; + u64 req_delay; + u64 req_len; + u64 rsp_timeout; +}; + +struct rmi_dev_comm_data { + union { /* 0x0 */ + struct rmi_dev_comm_enter enter; + u8 padding0[0x800]; + }; + union { /* 0x800 */ + struct rmi_dev_comm_exit exit; + u8 padding1[0x800]; + }; +}; + #endif /* __ASM_RMI_SMC_H */ diff --git a/drivers/virt/coco/arm-cca-host/arm-cca.c b/drivers/virt/coco/a= rm-cca-host/arm-cca.c index 18e5bf6adea4..e79f05fee516 100644 --- a/drivers/virt/coco/arm-cca-host/arm-cca.c +++ b/drivers/virt/coco/arm-cca-host/arm-cca.c @@ -48,6 +48,7 @@ static struct pci_tsm *cca_tsm_pci_probe(struct tsm_dev *= tsm_dev, struct pci_dev rc =3D pci_tsm_pf0_constructor(pdev, &pf0_dsc->pci, tsm_dev); if (rc) return NULL; + mutex_init(&pf0_dsc->object_lock); =20 pci_dbg(pdev, "tsm enabled\n"); return &no_free_ptr(pf0_dsc)->pci.base_tsm; @@ -70,6 +71,55 @@ static void cca_tsm_pci_remove(struct pci_tsm *tsm) } } =20 +static __maybe_unused int init_dev_communication_buffers(struct pci_dev *p= dev, + struct cca_host_comm_data *comm_data) +{ + int ret =3D -ENOMEM; + + comm_data->io_params =3D (struct rmi_dev_comm_data *)get_zeroed_page(GFP_= KERNEL); + if (!comm_data->io_params) + goto err_out; + + comm_data->rsp_buff =3D (void *)__get_free_page(GFP_KERNEL); + if (!comm_data->rsp_buff) + goto err_res_buff; + + comm_data->req_buff =3D (void *)__get_free_page(GFP_KERNEL); + if (!comm_data->req_buff) + goto err_req_buff; + + comm_data->work_queue =3D alloc_ordered_workqueue("%s %s DEV_COMM", 0, + dev_bus_name(&pdev->dev), + pci_name(pdev)); + if (!comm_data->work_queue) + goto err_work_queue; + + comm_data->io_params->enter.status =3D RMI_DEV_COMM_NONE; + comm_data->io_params->enter.resp_addr =3D virt_to_phys(comm_data->rsp_buf= f); + comm_data->io_params->enter.req_addr =3D virt_to_phys(comm_data->req_buf= f); + comm_data->io_params->enter.resp_len =3D 0; + + return 0; + +err_work_queue: + free_page((unsigned long)comm_data->req_buff); +err_req_buff: + free_page((unsigned long)comm_data->rsp_buff); +err_res_buff: + free_page((unsigned long)comm_data->io_params); +err_out: + return ret; +} + +static inline void free_dev_communication_buffers(struct cca_host_comm_dat= a *comm_data) +{ + destroy_workqueue(comm_data->work_queue); + + free_page((unsigned long)comm_data->req_buff); + free_page((unsigned long)comm_data->rsp_buff); + free_page((unsigned long)comm_data->io_params); +} + /* For now global for simplicity. Protected by pci_tsm_rwsem */ static DECLARE_BITMAP(cca_stream_ids, MAX_STREAM_ID); =20 diff --git a/drivers/virt/coco/arm-cca-host/rmi-da.c b/drivers/virt/coco/ar= m-cca-host/rmi-da.c index 390b8f05c7cf..592abe0dd252 100644 --- a/drivers/virt/coco/arm-cca-host/rmi-da.c +++ b/drivers/virt/coco/arm-cca-host/rmi-da.c @@ -5,6 +5,8 @@ =20 #include #include +#include +#include #include =20 #include "rmi-da.h" @@ -139,3 +141,274 @@ int pdev_create(struct pci_dev *pci_dev) free_page((unsigned long)rmm_pdev); return ret; } + +static int doe_send_req_resp(struct pci_tsm *tsm) +{ + int ret, data_obj_type; + struct cca_host_comm_data *comm_data =3D to_cca_comm_data(tsm->pdev); + struct rmi_dev_comm_exit *io_exit =3D &comm_data->io_params->exit; + u8 protocol =3D io_exit->protocol; + + if (protocol =3D=3D RMI_PROTOCOL_SPDM) + data_obj_type =3D PCI_DOE_FEATURE_CMA; + else if (protocol =3D=3D RMI_PROTOCOL_SECURE_SPDM) + data_obj_type =3D PCI_DOE_FEATURE_SSESSION; + else + return -EINVAL; + + /* delay the send */ + if (io_exit->req_delay) + fsleep(io_exit->req_delay); + + ret =3D pci_tsm_doe_transfer(tsm->dsm_dev, data_obj_type, + comm_data->req_buff, io_exit->req_len, + comm_data->rsp_buff, PAGE_SIZE); + return ret; +} + +static inline bool pending_dev_communicate(struct rmi_dev_comm_exit *io_ex= it) +{ + bool pending =3D io_exit->flags & (RMI_DEV_COMM_EXIT_CACHE_REQ | + RMI_DEV_COMM_EXIT_CACHE_RSP | + RMI_DEV_COMM_EXIT_SEND | + RMI_DEV_COMM_EXIT_WAIT | + RMI_DEV_COMM_EXIT_MULTI); + return pending; +} + +static int ___do_dev_communicate(enum dev_comm_type type, struct pci_tsm *= tsm) +{ + int ret, nbytes, cp_len; + struct cache_object **cache_objp, *cache_obj; + struct cca_host_pf0_dsc *pf0_dsc =3D to_cca_pf0_dsc(tsm->dsm_dev); + struct cca_host_comm_data *comm_data =3D to_cca_comm_data(tsm->pdev); + struct rmi_dev_comm_enter *io_enter =3D &comm_data->io_params->enter; + struct rmi_dev_comm_exit *io_exit =3D &comm_data->io_params->exit; + +redo_communicate: + + if (type =3D=3D PDEV_COMMUNICATE) + ret =3D rmi_pdev_communicate(virt_to_phys(pf0_dsc->rmm_pdev), + virt_to_phys(comm_data->io_params)); + else + ret =3D RMI_ERROR_INPUT; + if (ret !=3D RMI_SUCCESS) { + if (ret =3D=3D RMI_BUSY) + return -EBUSY; + return -ENXIO; + } + + if (io_exit->flags & RMI_DEV_COMM_EXIT_CACHE_REQ || + io_exit->flags & RMI_DEV_COMM_EXIT_CACHE_RSP) { + + switch (io_exit->cache_obj_id) { + case RMI_DEV_VCA: + cache_objp =3D &pf0_dsc->vca; + break; + case RMI_DEV_CERTIFICATE: + cache_objp =3D &pf0_dsc->cert_chain.cache; + break; + default: + return -EINVAL; + } + cache_obj =3D *cache_objp; + } + + if (io_exit->flags & RMI_DEV_COMM_EXIT_CACHE_REQ) + cp_len =3D io_exit->req_cache_len; + else + cp_len =3D io_exit->rsp_cache_len; + + /* response and request len should be <=3D SZ_4k */ + if (cp_len > CACHE_CHUNK_SIZE) + return -EINVAL; + + if (io_exit->flags & RMI_DEV_COMM_EXIT_CACHE_REQ || + io_exit->flags & RMI_DEV_COMM_EXIT_CACHE_RSP) { + int cache_remaining; + struct cache_object *new_obj; + + /* new allocation */ + if (!cache_obj) { + cache_obj =3D kvmalloc(struct_size(cache_obj, buf, CACHE_CHUNK_SIZE), + GFP_KERNEL); + if (!cache_obj) + return -ENOMEM; + + cache_obj->size =3D CACHE_CHUNK_SIZE; + cache_obj->offset =3D 0; + *cache_objp =3D cache_obj; + } + + cache_remaining =3D cache_obj->size - cache_obj->offset; + if (cp_len > cache_remaining) { + + if (cache_obj->size + CACHE_CHUNK_SIZE > MAX_CACHE_OBJ_SIZE) + return -EINVAL; + + new_obj =3D kvmalloc(struct_size(cache_obj, buf, + cache_obj->size + CACHE_CHUNK_SIZE), + GFP_KERNEL); + if (!new_obj) + return -ENOMEM; + memcpy(new_obj, cache_obj, struct_size(cache_obj, buf, cache_obj->size)= ); + new_obj->size =3D cache_obj->size + CACHE_CHUNK_SIZE; + *cache_objp =3D new_obj; + kvfree(cache_obj); + } + + /* cache object can change above. */ + cache_obj =3D *cache_objp; + } + + + if (io_exit->flags & RMI_DEV_COMM_EXIT_CACHE_REQ) { + memcpy(cache_obj->buf + cache_obj->offset, + (comm_data->req_buff + io_exit->req_cache_offset), io_exit->req_c= ache_len); + cache_obj->offset +=3D io_exit->req_cache_len; + } + + if (io_exit->flags & RMI_DEV_COMM_EXIT_CACHE_RSP) { + memcpy(cache_obj->buf + cache_obj->offset, + (comm_data->rsp_buff + io_exit->rsp_cache_offset), io_exit->rsp_c= ache_len); + cache_obj->offset +=3D io_exit->rsp_cache_len; + } + + /* + * wait for last packet request from RMM. + * We should not find this because our device communication is synchronous + */ + if (io_exit->flags & RMI_DEV_COMM_EXIT_WAIT) + return -ENXIO; + + /* next packet to send */ + if (io_exit->flags & RMI_DEV_COMM_EXIT_SEND) { + nbytes =3D doe_send_req_resp(tsm); + if (nbytes < 0) { + /* report error back to RMM */ + io_enter->status =3D RMI_DEV_COMM_ERROR; + } else { + /* send response back to RMM */ + io_enter->resp_len =3D nbytes; + io_enter->status =3D RMI_DEV_COMM_RESPONSE; + } + } else { + /* no data transmitted =3D> no data received */ + io_enter->resp_len =3D 0; + io_enter->status =3D RMI_DEV_COMM_NONE; + } + + if (pending_dev_communicate(io_exit)) + goto redo_communicate; + + return 0; +} + +static int __do_dev_communicate(enum dev_comm_type type, + struct pci_tsm *tsm, unsigned long error_state) +{ + int ret; + int state; + struct rmi_dev_comm_enter *io_enter; + struct cca_host_pf0_dsc *pf0_dsc =3D to_cca_pf0_dsc(tsm->dsm_dev); + + io_enter =3D &pf0_dsc->comm_data.io_params->enter; + io_enter->resp_len =3D 0; + io_enter->status =3D RMI_DEV_COMM_NONE; + + ret =3D ___do_dev_communicate(type, tsm); + if (ret) { + if (type =3D=3D PDEV_COMMUNICATE) + rmi_pdev_abort(virt_to_phys(pf0_dsc->rmm_pdev)); + + state =3D error_state; + } else { + /* + * Some device communication error will transition the + * device to error state. Report that. + */ + if (type =3D=3D PDEV_COMMUNICATE) + ret =3D rmi_pdev_get_state(virt_to_phys(pf0_dsc->rmm_pdev), + (enum rmi_pdev_state *)&state); + if (ret) + state =3D error_state; + } + + if (state =3D=3D error_state) + pci_err(tsm->pdev, "device communication error\n"); + + return state; +} + +static int do_dev_communicate(enum dev_comm_type type, struct pci_tsm *tsm, + unsigned long target_state, + unsigned long error_state) +{ + int state; + + do { + state =3D __do_dev_communicate(type, tsm, error_state); + + if (state =3D=3D target_state || state =3D=3D error_state) + break; + } while (1); + + return state; +} + +static int do_pdev_communicate(struct pci_tsm *tsm, enum rmi_pdev_state ta= rget_state) +{ + return do_dev_communicate(PDEV_COMMUNICATE, tsm, target_state, RMI_PDEV_E= RROR); +} + +void pdev_communicate_work(struct work_struct *work) +{ + unsigned long state; + struct pci_tsm *tsm; + struct dev_comm_work *setup_work; + struct cca_host_pf0_dsc *pf0_dsc; + + setup_work =3D container_of(work, struct dev_comm_work, work); + tsm =3D setup_work->tsm; + pf0_dsc =3D to_cca_pf0_dsc(tsm->dsm_dev); + + guard(mutex)(&pf0_dsc->object_lock); + state =3D do_pdev_communicate(tsm, setup_work->target_state); + WARN_ON(state !=3D setup_work->target_state); + + complete(&setup_work->complete); +} + +static int submit_pdev_comm_work(struct pci_dev *pdev, int target_state) +{ + int ret; + enum rmi_pdev_state state; + struct dev_comm_work comm_work; + struct cca_host_pf0_dsc *pf0_dsc =3D to_cca_pf0_dsc(pdev); + struct cca_host_comm_data *comm_data =3D to_cca_comm_data(pdev); + + INIT_WORK_ONSTACK(&comm_work.work, pdev_communicate_work); + init_completion(&comm_work.complete); + comm_work.tsm =3D pdev->tsm; + comm_work.target_state =3D target_state; + + queue_work(comm_data->work_queue, &comm_work.work); + + wait_for_completion(&comm_work.complete); + destroy_work_on_stack(&comm_work.work); + + /* check if we reached target state */ + ret =3D rmi_pdev_get_state(virt_to_phys(pf0_dsc->rmm_pdev), &state); + if (ret) + return ret; + + if (state !=3D target_state) + /* no specific error for this */ + return -1; + return 0; +} + +int pdev_ide_setup(struct pci_dev *pdev) +{ + return submit_pdev_comm_work(pdev, RMI_PDEV_NEEDS_KEY); +} diff --git a/drivers/virt/coco/arm-cca-host/rmi-da.h b/drivers/virt/coco/ar= m-cca-host/rmi-da.h index 6764bf8d98ce..1d513e0b74d9 100644 --- a/drivers/virt/coco/arm-cca-host/rmi-da.h +++ b/drivers/virt/coco/arm-cca-host/rmi-da.h @@ -9,22 +9,68 @@ #include #include #include +#include #include =20 +#define MAX_CACHE_OBJ_SIZE SZ_16M +#define CACHE_CHUNK_SIZE SZ_4K +struct cache_object { + int size; + int offset; + u8 buf[] __counted_by(size); +}; + +struct dev_comm_work { + struct pci_tsm *tsm; + int target_state; + struct work_struct work; + struct completion complete; +}; + +struct cca_host_comm_data { + void *rsp_buff; + void *req_buff; + struct rmi_dev_comm_data *io_params; + /* + * Only one device communication request can be active at + * a time. This limitation comes from using the DOE mailbox + * at the pdev level. Requests such as get_measurements may + * span multiple mailbox messages, which must not be + * interleaved with other SPDM requests. + */ + struct workqueue_struct *work_queue; +}; + /* dsc =3D device security context */ struct cca_host_pf0_dsc { + struct cca_host_comm_data comm_data; struct pci_tsm_pf0 pci; struct pci_ide *sel_stream; =20 void *rmm_pdev; int num_aux; void *aux[MAX_PDEV_AUX_GRANULES]; + + struct mutex object_lock; + struct { + struct cache_object *cache; + + void *public_key; + size_t public_key_size; + + bool valid; + } cert_chain; + struct cache_object *vca; }; =20 struct cca_host_fn_dsc { struct pci_tsm pci; }; =20 +enum dev_comm_type { + PDEV_COMMUNICATE =3D 0x1, +}; + static inline struct cca_host_pf0_dsc *to_cca_pf0_dsc(struct pci_dev *pdev) { struct pci_tsm *tsm =3D pdev->tsm; @@ -42,5 +88,22 @@ static inline struct cca_host_fn_dsc *to_cca_fn_dsc(stru= ct pci_dev *pdev) return container_of(tsm, struct cca_host_fn_dsc, pci); } =20 +static inline struct cca_host_comm_data *to_cca_comm_data(struct pci_dev *= pdev) +{ + struct cca_host_pf0_dsc *pf0_dsc; + + pf0_dsc =3D to_cca_pf0_dsc(pdev); + if (pf0_dsc) + return &pf0_dsc->comm_data; + + pf0_dsc =3D to_cca_pf0_dsc(pdev->tsm->dsm_dev); + if (pf0_dsc) + return &pf0_dsc->comm_data; + + return NULL; +} + int pdev_create(struct pci_dev *pdev); +void pdev_communicate_work(struct work_struct *work); +int pdev_ide_setup(struct pci_dev *pdev); #endif --=20 2.43.0 From nobody Sat Feb 7 15:09:52 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 11B892FB967; Mon, 27 Oct 2025 09:57:07 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761559028; cv=none; b=Pl8e5aKmrnc2zW8V0QNo1ebIw7Eicea6NfEy/at/9RovDxMkiZkTXqB7TC4oNgRncdGzwwtTMTQ2Aiwh67EGS12pm3R9/fGAi1bdQ4U6PP5gMGwQPkhDizgzFpACvfLidGJHNqnzQrJasrD0udgJzRYqmssBVy8AtQXbySONHeA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761559028; c=relaxed/simple; bh=B7+ugvWyCLD3rludeB5A8gujO3Mf6Ml2lNniTy9+Wsw=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=j16MABK0qgeNUnBEw83GIcdeJRI2L5bO2vZyvawMhp6/b0xIBfHDIttQpt3XNLDmiVJ8vyex4d6Mx6L5PCbMdExVbkCk6vkFAU7nZA/8DqGun4bqKRP/dX7sxhRTDcpbdTAzjOmC51gnIlOTIZb0VYAfqysqDHUX+eWtfhgNbtQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=LAYt0soL; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="LAYt0soL" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 8BDE2C4CEF1; Mon, 27 Oct 2025 09:57:02 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1761559027; bh=B7+ugvWyCLD3rludeB5A8gujO3Mf6Ml2lNniTy9+Wsw=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=LAYt0soLSpVtRM2lX3hz4geVUjRoS1cF4K/bdu9SaNR/p4/juwLCKgXq0Tr5LmdfZ XSww+3UfDf08kLx6JNiLdLTOwwpO7QRkKXsC1rTz6p1VVz3ijz5vskxYh6IRSbF5sL oBv8I1oA+InDwwe3TtUXEe2tvEXMFOjdSy9M6JGgQJ202k56Cgjo50+cvZ12vOuznm oSacrlGND1g7BYFKJ/xVjJ5O7b8Aus+XC817Wizb3oVP2PV06aXhiLGDkSHzmnfK12 m4/f4u3wx5J+yl0zfhU/BMdlSG6+urtT650heoPMkCAeFdcvhfvVq9DtHm91uMzxpy XLFImIQc6QuVg== From: "Aneesh Kumar K.V (Arm)" To: linux-coco@lists.linux.dev, kvmarm@lists.linux.dev Cc: linux-pci@vger.kernel.org, linux-kernel@vger.kernel.org, dan.j.williams@intel.com, aik@amd.com, lukas@wunner.de, Samuel Ortiz , Xu Yilun , Jason Gunthorpe , Suzuki K Poulose , Steven Price , Bjorn Helgaas , Jonathan Cameron , Catalin Marinas , Marc Zyngier , Will Deacon , Oliver Upton , "Aneesh Kumar K.V (Arm)" Subject: [PATCH RESEND v2 07/12] coco: host: arm64: Add helper to stop and tear down an RMM pdev Date: Mon, 27 Oct 2025 15:25:57 +0530 Message-ID: <20251027095602.1154418-8-aneesh.kumar@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251027095602.1154418-1-aneesh.kumar@kernel.org> References: <20251027095602.1154418-1-aneesh.kumar@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" - describe the RMI_PDEV_STOP/RMI_PDEV_DESTROY SMC IDs and provide wrappers in rmi_cmds.h - implement pdev_stop_and_destroy() so the host driver stops the pdev, waits for it to reach RMI_PDEV_STOPPED, destroys it, frees auxiliary granules, and drops the delegated page Signed-off-by: Aneesh Kumar K.V (Arm) Reviewed-by: Jonathan Cameron --- arch/arm64/include/asm/rmi_cmds.h | 18 +++++++++++++++ arch/arm64/include/asm/rmi_smc.h | 2 ++ drivers/virt/coco/arm-cca-host/rmi-da.c | 30 +++++++++++++++++++++++++ drivers/virt/coco/arm-cca-host/rmi-da.h | 1 + 4 files changed, 51 insertions(+) diff --git a/arch/arm64/include/asm/rmi_cmds.h b/arch/arm64/include/asm/rmi= _cmds.h index b86bf15afcda..f10a0dcaa308 100644 --- a/arch/arm64/include/asm/rmi_cmds.h +++ b/arch/arm64/include/asm/rmi_cmds.h @@ -556,4 +556,22 @@ static inline unsigned long rmi_pdev_abort(unsigned lo= ng pdev_phys) return res.a0; } =20 +static inline unsigned long rmi_pdev_stop(unsigned long pdev_phys) +{ + struct arm_smccc_res res; + + arm_smccc_1_1_invoke(SMC_RMI_PDEV_STOP, pdev_phys, &res); + + return res.a0; +} + +static inline unsigned long rmi_pdev_destroy(unsigned long pdev_phys) +{ + struct arm_smccc_res res; + + arm_smccc_1_1_invoke(SMC_RMI_PDEV_DESTROY, pdev_phys, &res); + + return res.a0; +} + #endif /* __ASM_RMI_CMDS_H */ diff --git a/arch/arm64/include/asm/rmi_smc.h b/arch/arm64/include/asm/rmi_= smc.h index 53e46e24c921..6eb6f7e4b77f 100644 --- a/arch/arm64/include/asm/rmi_smc.h +++ b/arch/arm64/include/asm/rmi_smc.h @@ -50,7 +50,9 @@ #define SMC_RMI_PDEV_ABORT SMC_RMI_CALL(0x0174) #define SMC_RMI_PDEV_COMMUNICATE SMC_RMI_CALL(0x0175) #define SMC_RMI_PDEV_CREATE SMC_RMI_CALL(0x0176) +#define SMC_RMI_PDEV_DESTROY SMC_RMI_CALL(0x0177) #define SMC_RMI_PDEV_GET_STATE SMC_RMI_CALL(0x0178) +#define SMC_RMI_PDEV_STOP SMC_RMI_CALL(0x017c) =20 #define RMI_ABI_MAJOR_VERSION 1 #define RMI_ABI_MINOR_VERSION 0 diff --git a/drivers/virt/coco/arm-cca-host/rmi-da.c b/drivers/virt/coco/ar= m-cca-host/rmi-da.c index 592abe0dd252..644609618a7a 100644 --- a/drivers/virt/coco/arm-cca-host/rmi-da.c +++ b/drivers/virt/coco/arm-cca-host/rmi-da.c @@ -412,3 +412,33 @@ int pdev_ide_setup(struct pci_dev *pdev) { return submit_pdev_comm_work(pdev, RMI_PDEV_NEEDS_KEY); } + +void pdev_stop_and_destroy(struct pci_dev *pdev) +{ + unsigned long ret; + struct cca_host_pf0_dsc *pf0_dsc =3D to_cca_pf0_dsc(pdev); + phys_addr_t rmm_pdev_phys =3D virt_to_phys(pf0_dsc->rmm_pdev); + + ret =3D rmi_pdev_stop(rmm_pdev_phys); + if (WARN_ON(ret !=3D RMI_SUCCESS)) + return; + + submit_pdev_comm_work(pdev, RMI_PDEV_STOPPED); + + ret =3D rmi_pdev_destroy(rmm_pdev_phys); + if (WARN_ON(ret !=3D RMI_SUCCESS)) + return; + + kfree(pf0_dsc->cert_chain.public_key); + kvfree(pf0_dsc->cert_chain.cache); + kvfree(pf0_dsc->vca); + pf0_dsc->cert_chain.cache =3D NULL; + pf0_dsc->vca =3D NULL; + + /* Free the aux granules */ + free_aux_pages(pf0_dsc->num_aux, pf0_dsc->aux); + pf0_dsc->num_aux =3D 0; + if (!rmi_granule_undelegate(rmm_pdev_phys)) + free_page((unsigned long)pf0_dsc->rmm_pdev); + pf0_dsc->rmm_pdev =3D NULL; +} diff --git a/drivers/virt/coco/arm-cca-host/rmi-da.h b/drivers/virt/coco/ar= m-cca-host/rmi-da.h index 1d513e0b74d9..e556ccecc1cb 100644 --- a/drivers/virt/coco/arm-cca-host/rmi-da.h +++ b/drivers/virt/coco/arm-cca-host/rmi-da.h @@ -104,6 +104,7 @@ static inline struct cca_host_comm_data *to_cca_comm_da= ta(struct pci_dev *pdev) } =20 int pdev_create(struct pci_dev *pdev); +void pdev_stop_and_destroy(struct pci_dev *pdev); void pdev_communicate_work(struct work_struct *work); int pdev_ide_setup(struct pci_dev *pdev); #endif --=20 2.43.0 From nobody Sat Feb 7 15:09:52 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A0FE12F6935; Mon, 27 Oct 2025 09:57:13 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761559033; cv=none; b=Yfg5F4+/G0NPZmdQ3iqoTkGG9RF+HgKiPi8GcoQYzJI4i8V/+BjKGakhdcu3RrIb2VTs4NUSfJp6/BIZFS80CtHou85oBsUhcCbEvk3uKzOOLBmgmewS2w+TpWeFfAR3dlA201f70nmJRYkknszceGEqGDE91+uyLyKCEbGZDL0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761559033; c=relaxed/simple; bh=+QJQxLvf5/Nw2WwKAhM43PutwuEiTS23ygXc8gN9Crc=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=rvhoB7y6PwfJRh9lhZOX7kpDWAOEhikiz+p020WulbmPS0r32Ta/MGWSKZxRRNrswXbW9kcYpFdNFXUmq81Uhb+BGqHvdlotW4C+ILED3AYOA8clPbfjPTeimcbjf4+SqI5T6BnT0RRu4O+6IZPUKDM2SRkcOgVtA80Su6xIyTQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=A0Os/H7j; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="A0Os/H7j" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 2FB02C4CEFF; Mon, 27 Oct 2025 09:57:07 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1761559033; bh=+QJQxLvf5/Nw2WwKAhM43PutwuEiTS23ygXc8gN9Crc=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=A0Os/H7j8zaFaQWVYnDkr4ulrgBuxWXxJ6Cgfpd6XKuKi4FMcrMqWwYteaIV6w2Az KwBdKAHplsA/Jr6QUbgktRLb2SJYONtBFqUNzFkyVbOoK5+UL5VZg/6+nV1upo+yWm xBZ2VCwsv23tf90eJlDD14ibPq3FFHYKU4mtfvyfUQx6+OsmT9lfS+rQ7c8M+fsanR 3GineL9o6r9n2VI6wie01IFNyZ1gh5gnwawl/aGyJKqvKBO6vdU3ZEMYgt6sNgM2qE z8snAyYKZzOQMfie3RKa7BzJ89n7PD7Vvmap6wCv7CB1FSgYLflrSYprcKmpz/vg5s zaGYEvYTEb/Aw== From: "Aneesh Kumar K.V (Arm)" To: linux-coco@lists.linux.dev, kvmarm@lists.linux.dev Cc: linux-pci@vger.kernel.org, linux-kernel@vger.kernel.org, dan.j.williams@intel.com, aik@amd.com, lukas@wunner.de, Samuel Ortiz , Xu Yilun , Jason Gunthorpe , Suzuki K Poulose , Steven Price , Bjorn Helgaas , Jonathan Cameron , Catalin Marinas , Marc Zyngier , Will Deacon , Oliver Upton , "Aneesh Kumar K.V (Arm)" Subject: [PATCH RESEND v2 08/12] coco: host: arm64: Instantiate RMM pdev during device connect Date: Mon, 27 Oct 2025 15:25:58 +0530 Message-ID: <20251027095602.1154418-9-aneesh.kumar@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251027095602.1154418-1-aneesh.kumar@kernel.org> References: <20251027095602.1154418-1-aneesh.kumar@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" An RMM pdev object represents a communication channel between the RMM and a physical device, for example a PCIe device. With the required helpers now in place, update the connect callback to create an RMM pdev object. Signed-off-by: Aneesh Kumar K.V (Arm) Reviewed-by: Jonathan Cameron --- drivers/virt/coco/arm-cca-host/arm-cca.c | 23 +++++++++++++++++++++-- 1 file changed, 21 insertions(+), 2 deletions(-) diff --git a/drivers/virt/coco/arm-cca-host/arm-cca.c b/drivers/virt/coco/a= rm-cca-host/arm-cca.c index e79f05fee516..8eaf8749e59d 100644 --- a/drivers/virt/coco/arm-cca-host/arm-cca.c +++ b/drivers/virt/coco/arm-cca-host/arm-cca.c @@ -71,8 +71,8 @@ static void cca_tsm_pci_remove(struct pci_tsm *tsm) } } =20 -static __maybe_unused int init_dev_communication_buffers(struct pci_dev *p= dev, - struct cca_host_comm_data *comm_data) +static int init_dev_communication_buffers(struct pci_dev *pdev, + struct cca_host_comm_data *comm_data) { int ret =3D -ENOMEM; =20 @@ -160,6 +160,16 @@ static int cca_tsm_connect(struct pci_dev *pdev) if (rc) goto err_tsm; =20 + rc =3D init_dev_communication_buffers(pdev, &pf0_dsc->comm_data); + if (rc) + goto err_comm_buff; + rc =3D pdev_create(pdev); + if (rc) + goto err_pdev_create; + + rc =3D pdev_ide_setup(pdev); + if (rc) + goto err_ide_setup; /* * Once ide is setup, enable the stream at the endpoint * Root port will be done by RMM @@ -167,6 +177,12 @@ static int cca_tsm_connect(struct pci_dev *pdev) pci_ide_stream_enable(pdev, ide); return 0; =20 +err_ide_setup: + pdev_stop_and_destroy(pdev); +err_pdev_create: + free_dev_communication_buffers(&pf0_dsc->comm_data); +err_comm_buff: + tsm_ide_stream_unregister(ide); err_tsm: pci_ide_stream_teardown(rp, ide); pci_ide_stream_teardown(pdev, ide); @@ -193,6 +209,9 @@ static void cca_tsm_disconnect(struct pci_dev *pdev) stream_id =3D ide->stream_id; pf0_dsc->sel_stream =3D NULL; =20 + pdev_stop_and_destroy(pdev); + free_dev_communication_buffers(&pf0_dsc->comm_data); + pci_ide_stream_release(ide); clear_bit(stream_id, cca_stream_ids); } --=20 2.43.0 From nobody Sat Feb 7 15:09:52 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id F240C2F7AAA; Mon, 27 Oct 2025 09:57:18 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761559039; cv=none; b=SGQiaTy2OpVZBseoDr4WqRg+IyxxoTTac6nOMwv6B2AclpdW/YRixzv84NKKr4IUZbO10P7XJUBjThCZZsFd/iacVYiICriaqlgr+6lLWcqORa1kWWuIQsiv3eENKgJXEtlm37IQnyzTgRd5VmMjPLcoPydX9fPdpn1TDSM12hw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761559039; c=relaxed/simple; bh=Jxd55h7fhwYrRLJ8lptvnzcQtZN9e7g9TUuMgKyZmrY=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=czuIEFHS3EyD4YMz5MldZfnlMQ9F0Q7zVVvkBQZXxQJBHZpl4YNaPJEsqZlmXX1VlG9rPRCeqKTtf7gWaGTbeB9V+Mrd79f41jpYdxTadnaTSillwhSHlHQJklivWYaRp7fpxjlV8EK5pfCkezuRu6fw8FlQb7eTrsGR06jqX3E= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=L6X7veGd; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="L6X7veGd" Received: by smtp.kernel.org (Postfix) with ESMTPSA id C780FC4CEF1; Mon, 27 Oct 2025 09:57:13 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1761559038; bh=Jxd55h7fhwYrRLJ8lptvnzcQtZN9e7g9TUuMgKyZmrY=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=L6X7veGdLfJhgq56bplu7ClyjS1WoEYD502xsc+nFDnZaaomDcx9ACEkvD9lLOWnz apOSPwC52Uraor5x0zb40iH06U0EaeMzSasRS0C4FHNKBjAuyfB+08b5EjJb4yI2oS yqMb0j8zwc4Ot0HnuvyET5680YIn94TFj36+9HWsZGmnrFirhC5IAfbo9njJmXAqHk O2DkhCG2/XrOJvXEJ/KZmB4MBN1KOp5uIKUQ3SgteiNTTIVhXrPOrws5YXLNShW3IW Rib2t3b90eK5sPNOfYMFq2OAH+UCIPb8xJxPsokh4ONVFVeg8g29E3MqW2zcmvbfbZ cufvbhYNHvQPw== From: "Aneesh Kumar K.V (Arm)" To: linux-coco@lists.linux.dev, kvmarm@lists.linux.dev Cc: linux-pci@vger.kernel.org, linux-kernel@vger.kernel.org, dan.j.williams@intel.com, aik@amd.com, lukas@wunner.de, Samuel Ortiz , Xu Yilun , Jason Gunthorpe , Suzuki K Poulose , Steven Price , Bjorn Helgaas , Jonathan Cameron , Catalin Marinas , Marc Zyngier , Will Deacon , Oliver Upton , =?UTF-8?q?Ilpo=20J=C3=A4rvinen?= Subject: [PATCH RESEND v2 09/12] X.509: Make certificate parser public Date: Mon, 27 Oct 2025 15:25:59 +0530 Message-ID: <20251027095602.1154418-10-aneesh.kumar@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251027095602.1154418-1-aneesh.kumar@kernel.org> References: <20251027095602.1154418-1-aneesh.kumar@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Lukas Wunner The upcoming support for PCI device authentication with CMA-SPDM (PCIe r6.1 sec 6.31) requires validating the Subject Alternative Name in X.509 certificates. High-level functions for X.509 parsing such as key_create_or_update() throw away the internal, low-level struct x509_certificate after extracting the struct public_key and public_key_signature from it. The Subject Alternative Name is thus inaccessible when using those functions. Afford CMA-SPDM access to the Subject Alternative Name by making struct x509_certificate public, together with the functions for parsing an X.509 certificate into such a struct and freeing such a struct. The private header file x509_parser.h previously included for the definition of time64_t. That definition was since moved to by commit 361a3bf00582 ("time64: Add time64.h header and define struct timespec64"), so adjust the #include directive as part of the move to the new public header file . No functional change intended. Signed-off-by: Lukas Wunner Reviewed-by: Dan Williams Reviewed-by: Ilpo J=C3=A4rvinen Reviewed-by: Jonathan Cameron --- crypto/asymmetric_keys/x509_parser.h | 40 +-------------------- include/keys/x509-parser.h | 53 ++++++++++++++++++++++++++++ 2 files changed, 54 insertions(+), 39 deletions(-) create mode 100644 include/keys/x509-parser.h diff --git a/crypto/asymmetric_keys/x509_parser.h b/crypto/asymmetric_keys/= x509_parser.h index 0688c222806b..39f1521b773d 100644 --- a/crypto/asymmetric_keys/x509_parser.h +++ b/crypto/asymmetric_keys/x509_parser.h @@ -5,49 +5,11 @@ * Written by David Howells (dhowells@redhat.com) */ =20 -#include -#include -#include -#include - -struct x509_certificate { - struct x509_certificate *next; - struct x509_certificate *signer; /* Certificate that signed this one */ - struct public_key *pub; /* Public key details */ - struct public_key_signature *sig; /* Signature parameters */ - char *issuer; /* Name of certificate issuer */ - char *subject; /* Name of certificate subject */ - struct asymmetric_key_id *id; /* Issuer + Serial number */ - struct asymmetric_key_id *skid; /* Subject + subjectKeyId (optional) */ - time64_t valid_from; - time64_t valid_to; - const void *tbs; /* Signed data */ - unsigned tbs_size; /* Size of signed data */ - unsigned raw_sig_size; /* Size of signature */ - const void *raw_sig; /* Signature data */ - const void *raw_serial; /* Raw serial number in ASN.1 */ - unsigned raw_serial_size; - unsigned raw_issuer_size; - const void *raw_issuer; /* Raw issuer name in ASN.1 */ - const void *raw_subject; /* Raw subject name in ASN.1 */ - unsigned raw_subject_size; - unsigned raw_skid_size; - const void *raw_skid; /* Raw subjectKeyId in ASN.1 */ - unsigned index; - bool seen; /* Infinite recursion prevention */ - bool verified; - bool self_signed; /* T if self-signed (check unsupported_sig too) */ - bool unsupported_sig; /* T if signature uses unsupported crypto */ - bool blacklisted; -}; +#include =20 /* * x509_cert_parser.c */ -extern void x509_free_certificate(struct x509_certificate *cert); -DEFINE_FREE(x509_free_certificate, struct x509_certificate *, - if (!IS_ERR(_T)) x509_free_certificate(_T)) -extern struct x509_certificate *x509_cert_parse(const void *data, size_t d= atalen); extern int x509_decode_time(time64_t *_t, size_t hdrlen, unsigned char tag, const unsigned char *value, size_t vlen); diff --git a/include/keys/x509-parser.h b/include/keys/x509-parser.h new file mode 100644 index 000000000000..37436a5c7526 --- /dev/null +++ b/include/keys/x509-parser.h @@ -0,0 +1,53 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* X.509 certificate parser + * + * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved. + * Written by David Howells (dhowells@redhat.com) + */ + +#ifndef _KEYS_X509_PARSER_H +#define _KEYS_X509_PARSER_H + +#include +#include +#include +#include + +struct x509_certificate { + struct x509_certificate *next; + struct x509_certificate *signer; /* Certificate that signed this one */ + struct public_key *pub; /* Public key details */ + struct public_key_signature *sig; /* Signature parameters */ + char *issuer; /* Name of certificate issuer */ + char *subject; /* Name of certificate subject */ + struct asymmetric_key_id *id; /* Issuer + Serial number */ + struct asymmetric_key_id *skid; /* Subject + subjectKeyId (optional) */ + time64_t valid_from; + time64_t valid_to; + const void *tbs; /* Signed data */ + unsigned tbs_size; /* Size of signed data */ + unsigned raw_sig_size; /* Size of signature */ + const void *raw_sig; /* Signature data */ + const void *raw_serial; /* Raw serial number in ASN.1 */ + unsigned raw_serial_size; + unsigned raw_issuer_size; + const void *raw_issuer; /* Raw issuer name in ASN.1 */ + const void *raw_subject; /* Raw subject name in ASN.1 */ + unsigned raw_subject_size; + unsigned raw_skid_size; + const void *raw_skid; /* Raw subjectKeyId in ASN.1 */ + unsigned index; + bool seen; /* Infinite recursion prevention */ + bool verified; + bool self_signed; /* T if self-signed (check unsupported_sig too) */ + bool unsupported_sig; /* T if signature uses unsupported crypto */ + bool blacklisted; +}; + +struct x509_certificate *x509_cert_parse(const void *data, size_t datalen); +void x509_free_certificate(struct x509_certificate *cert); + +DEFINE_FREE(x509_free_certificate, struct x509_certificate *, + if (!IS_ERR(_T)) x509_free_certificate(_T)) + +#endif /* _KEYS_X509_PARSER_H */ --=20 2.43.0 From nobody Sat Feb 7 15:09:52 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id D21672FDC43; Mon, 27 Oct 2025 09:57:24 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761559044; cv=none; b=ap8QGVZSa6mpdZBcLQPoj9BamXJ4fDubxn7G/vA5UZM+GQulIo2f0lLwkj08boyyFwfRnp08OHSiJrZaHkbV99nQ/qdAVxLA4xxqver/fQ7QbV/br9NIFcbFb75LpNrs1mOZ0Y8ZzxaoMUY7NRCNWsHAMNWWhUdRndWvRXDwnTs= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761559044; c=relaxed/simple; bh=ZwxWW0luOHwrk3YhZSDx0yDOjLl070ZaGpU4yv5QUjk=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=l7iUyOkjvCWLs6uTdqUWyFqE2FrEzcLMH9F/1U5mPWSrQSeOl6vgx+EENFFu5EPvUEs4pRsGFZozzSngtf1zFbSRiqCSjZy0gqG4ESChu6TxeUOVvoOgtob4E3yWOjuxmEtBiG7FV23H04i4tIchV33gUv8+7TuL1pqDfHcp6O8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=W1LlDcvw; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="W1LlDcvw" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 6BFD8C4CEF1; Mon, 27 Oct 2025 09:57:19 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1761559044; bh=ZwxWW0luOHwrk3YhZSDx0yDOjLl070ZaGpU4yv5QUjk=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=W1LlDcvwTXxW06qjy3XDmvfDvXP91pdPM5d2IXrDmPBJlty0DPUFgh5f9uASxG8/l 4Tz6e5zAYP3z9AGRZ/ViAOdnA9KOAsJdt7hEPwImdZDyD3dol1BaLaKyk9cSJuEJsQ ghfk8y/stkNMdQPriW03OqYLVq2Zco52ezqn28Lu+0iQ/lFRl9szPsnGi5W49zxPyg dDwhwleBuFslD4qKGyZl5Ytw0w3bom7sbBtGzHxfBxlc4/tmkc8fnOQtQ4hPKaXbcc 7FkjpnHosWZ6xL2icrVdZUHtk33DU+kFN1VgHrHS6vUCG62jTfg2gBpwtyO6ayq1aG 5jcceteJqNRUA== From: "Aneesh Kumar K.V (Arm)" To: linux-coco@lists.linux.dev, kvmarm@lists.linux.dev Cc: linux-pci@vger.kernel.org, linux-kernel@vger.kernel.org, dan.j.williams@intel.com, aik@amd.com, lukas@wunner.de, Samuel Ortiz , Xu Yilun , Jason Gunthorpe , Suzuki K Poulose , Steven Price , Bjorn Helgaas , Jonathan Cameron , Catalin Marinas , Marc Zyngier , Will Deacon , Oliver Upton , Wilfred Mallawa , =?UTF-8?q?Ilpo=20J=C3=A4rvinen?= Subject: [PATCH RESEND v2 10/12] X.509: Parse Subject Alternative Name in certificates Date: Mon, 27 Oct 2025 15:26:00 +0530 Message-ID: <20251027095602.1154418-11-aneesh.kumar@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251027095602.1154418-1-aneesh.kumar@kernel.org> References: <20251027095602.1154418-1-aneesh.kumar@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Lukas Wunner The upcoming support for PCI device authentication with CMA-SPDM (PCIe r6.1 sec 6.31) requires validating the Subject Alternative Name in X.509 certificates. Store a pointer to the Subject Alternative Name upon parsing for consumption by CMA-SPDM. Signed-off-by: Lukas Wunner Reviewed-by: Wilfred Mallawa Reviewed-by: Ilpo J=C3=A4rvinen Reviewed-by: Jonathan Cameron Acked-by: Dan Williams --- crypto/asymmetric_keys/x509_cert_parser.c | 9 +++++++++ include/keys/x509-parser.h | 2 ++ 2 files changed, 11 insertions(+) diff --git a/crypto/asymmetric_keys/x509_cert_parser.c b/crypto/asymmetric_= keys/x509_cert_parser.c index 8df3fa60a44f..5942679f125a 100644 --- a/crypto/asymmetric_keys/x509_cert_parser.c +++ b/crypto/asymmetric_keys/x509_cert_parser.c @@ -571,6 +571,15 @@ int x509_process_extension(void *context, size_t hdrle= n, return 0; } =20 + if (ctx->last_oid =3D=3D OID_subjectAltName) { + if (ctx->cert->raw_san) + return -EBADMSG; + + ctx->cert->raw_san =3D v; + ctx->cert->raw_san_size =3D vlen; + return 0; + } + if (ctx->last_oid =3D=3D OID_keyUsage) { /* * Get hold of the keyUsage bit string diff --git a/include/keys/x509-parser.h b/include/keys/x509-parser.h index 37436a5c7526..8e450befe3b9 100644 --- a/include/keys/x509-parser.h +++ b/include/keys/x509-parser.h @@ -36,6 +36,8 @@ struct x509_certificate { unsigned raw_subject_size; unsigned raw_skid_size; const void *raw_skid; /* Raw subjectKeyId in ASN.1 */ + const void *raw_san; /* Raw subjectAltName in ASN.1 */ + unsigned raw_san_size; unsigned index; bool seen; /* Infinite recursion prevention */ bool verified; --=20 2.43.0 From nobody Sat Feb 7 15:09:52 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 8A8CD2FDC43; Mon, 27 Oct 2025 09:57:30 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761559050; cv=none; b=DIx4/QJ9iYGmq5oEpqbcdyzZoTAnUZ2ROvXMttI6+HqeBc5HmBf28ZoCI3+wd8YNWk8IyJXPdslxWdlI8H16Vir8GdgrASRIN1KfCbsBFgrb0LxYFPr83YywcQ3e4VE24TA2LllcwaLgqCleMi3N1iNbOvtxXuHYo8lvrjNvb9c= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761559050; c=relaxed/simple; bh=GTTAsUvGA0z7kzwZp8HnqrA/zR5zZGrXrfASn4SucGI=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=lAbcx+iPKDnARPNyTiLD+8pVADNAAa7M1/xpKTSAGu00a35PbH89aJZX7HT8AHyz4dlEpdyc7Oet4fGTjtFQ4spmVQefqChoqtG+4kTlvinajp4c4HWfQoHNKRMQpBZvjMMe4kqPr93vNS6cefvMx4r0SU2IJs5yaTtYIOm2FmM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=TrIVyutI; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="TrIVyutI" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 4C1C4C4AF09; Mon, 27 Oct 2025 09:57:25 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1761559050; bh=GTTAsUvGA0z7kzwZp8HnqrA/zR5zZGrXrfASn4SucGI=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=TrIVyutIeoBVtHYSgc5jRD4mKXIkOHf4NCJWvf2BAymqfzV+xijEoXBYb9hZ49ErO LZ1TrIN1hXoAqZcSqTbJ0ddBC3LoVr5grpj86t47NAjAyv2XVwbjqyvGyq+xWyDHmJ OjrOQB+c13uBxF/+eaZQYEBXLfD60NjyJjFsQ9dNx6zmpDoNHzo5tnfX8Q9ivRFmqQ zmbXVpGBFzEZreE0D7LiCXxX7iT4aXBwfI+lFw4YWh8F5nkwpIGZqCTLg9zU2p0v6T bNx99RBrf37deWhtJCOFioRltNFenAbUNwkZCTYXVTvJqJdyO8o6coyzcxzoIeOcCP pfQ9RexDmQKXg== From: "Aneesh Kumar K.V (Arm)" To: linux-coco@lists.linux.dev, kvmarm@lists.linux.dev Cc: linux-pci@vger.kernel.org, linux-kernel@vger.kernel.org, dan.j.williams@intel.com, aik@amd.com, lukas@wunner.de, Samuel Ortiz , Xu Yilun , Jason Gunthorpe , Suzuki K Poulose , Steven Price , Bjorn Helgaas , Jonathan Cameron , Catalin Marinas , Marc Zyngier , Will Deacon , Oliver Upton Subject: [PATCH RESEND v2 11/12] X.509: Move certificate length retrieval into new helper Date: Mon, 27 Oct 2025 15:26:01 +0530 Message-ID: <20251027095602.1154418-12-aneesh.kumar@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251027095602.1154418-1-aneesh.kumar@kernel.org> References: <20251027095602.1154418-1-aneesh.kumar@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Lukas Wunner The upcoming in-kernel SPDM library (Security Protocol and Data Model, https://www.dmtf.org/dsp/DSP0274) needs to retrieve the length from ASN.1 DER-encoded X.509 certificates. Such code already exists in x509_load_certificate_list(), so move it into a new helper for reuse by SPDM. Export the helper so that SPDM can be tristate. (Some upcoming users of the SPDM libray may be modular, such as SCSI and ATA.) No functional change intended. Signed-off-by: Lukas Wunner Reviewed-by: Dan Williams Reviewed-by: Jonathan Cameron --- crypto/asymmetric_keys/x509_loader.c | 38 +++++++++++++++++++--------- include/keys/asymmetric-type.h | 2 ++ 2 files changed, 28 insertions(+), 12 deletions(-) diff --git a/crypto/asymmetric_keys/x509_loader.c b/crypto/asymmetric_keys/= x509_loader.c index a41741326998..25ff027fad1d 100644 --- a/crypto/asymmetric_keys/x509_loader.c +++ b/crypto/asymmetric_keys/x509_loader.c @@ -4,28 +4,42 @@ #include #include =20 +ssize_t x509_get_certificate_length(const u8 *p, unsigned long buflen) +{ + ssize_t plen; + + /* Each cert begins with an ASN.1 SEQUENCE tag and must be more + * than 256 bytes in size. + */ + if (buflen < 4) + return -EINVAL; + + if (p[0] !=3D 0x30 && + p[1] !=3D 0x82) + return -EINVAL; + + plen =3D (p[2] << 8) | p[3]; + plen +=3D 4; + if (plen > buflen) + return -EINVAL; + + return plen; +} +EXPORT_SYMBOL_GPL(x509_get_certificate_length); + int x509_load_certificate_list(const u8 cert_list[], const unsigned long list_size, const struct key *keyring) { key_ref_t key; const u8 *p, *end; - size_t plen; + ssize_t plen; =20 p =3D cert_list; end =3D p + list_size; while (p < end) { - /* Each cert begins with an ASN.1 SEQUENCE tag and must be more - * than 256 bytes in size. - */ - if (end - p < 4) - goto dodgy_cert; - if (p[0] !=3D 0x30 && - p[1] !=3D 0x82) - goto dodgy_cert; - plen =3D (p[2] << 8) | p[3]; - plen +=3D 4; - if (plen > end - p) + plen =3D x509_get_certificate_length(p, end - p); + if (plen < 0) goto dodgy_cert; =20 key =3D key_create_or_update(make_key_ref(keyring, 1), diff --git a/include/keys/asymmetric-type.h b/include/keys/asymmetric-type.h index 69a13e1e5b2e..e2af07fec3c6 100644 --- a/include/keys/asymmetric-type.h +++ b/include/keys/asymmetric-type.h @@ -84,6 +84,8 @@ extern struct key *find_asymmetric_key(struct key *keyrin= g, const struct asymmetric_key_id *id_2, bool partial); =20 +ssize_t x509_get_certificate_length(const u8 *p, unsigned long buflen); + int x509_load_certificate_list(const u8 cert_list[], const unsigned long l= ist_size, const struct key *keyring); =20 --=20 2.43.0 From nobody Sat Feb 7 15:09:52 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3D1772F90DB; Mon, 27 Oct 2025 09:57:35 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761559056; cv=none; b=nYP20eignur2XdjEhT74BBvx/uny7xwUuz6HWaP9O1oucJgK1cWw5lHaqI3G5p5J898VBoAwq8EUUZwy6oLuYa5nDGg1RFGu2SN+rJDwkX26VtPSaVLo6i8LV5JepR810lqKfa4RppAv11++NsXAAvfcsyUxmHYxzdWfpvLChac= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761559056; c=relaxed/simple; bh=Af4vjbB3fxE+UHzJd2A7AwcGlqakMGAYFn/zD5eKCZI=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=WVnTX8MiuA4Rp8tVIRvczrbDfC9XUcrLNeQ2bFjFS/xxHyvYu9TAsguZ+9Vr1ZysaEzAHb+zFTVKU/wjQ+Xd8QrdX5kYVTYn1zc5ws303W5QwK3y4YtyqzZV2sALP6/0RKVPTWFWkJTbQE/iSYy+OBCAiBqK/Mws03Qwpnz/4eg= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=e86reWha; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="e86reWha" Received: by smtp.kernel.org (Postfix) with ESMTPSA id A8AA5C4CEF1; Mon, 27 Oct 2025 09:57:30 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1761559055; bh=Af4vjbB3fxE+UHzJd2A7AwcGlqakMGAYFn/zD5eKCZI=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=e86reWhawKCnn1Iw7EL7PEH3wYdcVXTpJBhThkQ9GHc/6htsoIDHyqggO3Fea/Tv2 vp2oJ75KV6ipIAxyOxlBndh+ojOV32LG9wuz6/jg+gi+PSfHAcT7Ft1cIqEtqAvubA g1kEgzQnEr3ElZ2xkmLNPCf7MHF03455OzNc8JHqC/GghaaoiMO7ZLHxFFf7K61beh iEsXqN8UGlNpJ9TUjPcrk70pSJnNlwGPboEODToTbpOH4YIN/xpEA6wnlRjWWQ6nTd NjqA2f8k1Pu/fo2kYuqULWi7pBrCFLx7haVs52wPwV0D/OG1zbziA5A7M2KyOLsAOd yT6DlyT/+7IIA== From: "Aneesh Kumar K.V (Arm)" To: linux-coco@lists.linux.dev, kvmarm@lists.linux.dev Cc: linux-pci@vger.kernel.org, linux-kernel@vger.kernel.org, dan.j.williams@intel.com, aik@amd.com, lukas@wunner.de, Samuel Ortiz , Xu Yilun , Jason Gunthorpe , Suzuki K Poulose , Steven Price , Bjorn Helgaas , Jonathan Cameron , Catalin Marinas , Marc Zyngier , Will Deacon , Oliver Upton , "Aneesh Kumar K.V (Arm)" Subject: [PATCH RESEND v2 12/12] coco: host: arm64: Register device public key with RMM Date: Mon, 27 Oct 2025 15:26:02 +0530 Message-ID: <20251027095602.1154418-13-aneesh.kumar@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251027095602.1154418-1-aneesh.kumar@kernel.org> References: <20251027095602.1154418-1-aneesh.kumar@kernel.org> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable - Introduce the SMC_RMI_PDEV_SET_PUBKEY helper and the associated struct rmi_public_key_params so the host can hand the device=E2=80=99s public key = to the RMM. - Parse the certificate chain cached during IDE setup, extract the final certificate=E2=80=99s public key, and recognise RSA-3072, ECDSA-P256, and ECDSA-P384 keys before calling into the RMM. Signed-off-by: Aneesh Kumar K.V (Arm) --- arch/arm64/include/asm/rmi_cmds.h | 9 ++ arch/arm64/include/asm/rmi_smc.h | 18 +++ drivers/virt/coco/arm-cca-host/Kconfig | 4 + drivers/virt/coco/arm-cca-host/rmi-da.c | 166 +++++++++++++++++++++++- drivers/virt/coco/arm-cca-host/rmi-da.h | 1 + 5 files changed, 197 insertions(+), 1 deletion(-) diff --git a/arch/arm64/include/asm/rmi_cmds.h b/arch/arm64/include/asm/rmi= _cmds.h index f10a0dcaa308..339bea517760 100644 --- a/arch/arm64/include/asm/rmi_cmds.h +++ b/arch/arm64/include/asm/rmi_cmds.h @@ -574,4 +574,13 @@ static inline unsigned long rmi_pdev_destroy(unsigned = long pdev_phys) return res.a0; } =20 +static inline unsigned long rmi_pdev_set_pubkey(unsigned long pdev_phys, u= nsigned long key_phys) +{ + struct arm_smccc_res res; + + arm_smccc_1_1_invoke(SMC_RMI_PDEV_SET_PUBKEY, pdev_phys, key_phys, &res); + + return res.a0; +} + #endif /* __ASM_RMI_CMDS_H */ diff --git a/arch/arm64/include/asm/rmi_smc.h b/arch/arm64/include/asm/rmi_= smc.h index 6eb6f7e4b77f..1f46e13b92a4 100644 --- a/arch/arm64/include/asm/rmi_smc.h +++ b/arch/arm64/include/asm/rmi_smc.h @@ -52,6 +52,7 @@ #define SMC_RMI_PDEV_CREATE SMC_RMI_CALL(0x0176) #define SMC_RMI_PDEV_DESTROY SMC_RMI_CALL(0x0177) #define SMC_RMI_PDEV_GET_STATE SMC_RMI_CALL(0x0178) +#define SMC_RMI_PDEV_SET_PUBKEY SMC_RMI_CALL(0x017b) #define SMC_RMI_PDEV_STOP SMC_RMI_CALL(0x017c) =20 #define RMI_ABI_MAJOR_VERSION 1 @@ -426,4 +427,21 @@ struct rmi_dev_comm_data { }; }; =20 +#define RMI_SIG_RSASSA_3072 0 +#define RMI_SIG_ECDSA_P256 1 +#define RMI_SIG_ECDSA_P384 2 + +struct rmi_public_key_params { + union { + struct { + u8 public_key[1024]; + u8 metadata[1024]; + u64 public_key_len; + u64 metadata_len; + u8 rmi_signature_algorithm; + } __packed; + u8 padding[0x1000]; + }; +}; + #endif /* __ASM_RMI_SMC_H */ diff --git a/drivers/virt/coco/arm-cca-host/Kconfig b/drivers/virt/coco/arm= -cca-host/Kconfig index 1febd316fb77..efa66e960ad5 100644 --- a/drivers/virt/coco/arm-cca-host/Kconfig +++ b/drivers/virt/coco/arm-cca-host/Kconfig @@ -7,8 +7,12 @@ config ARM_CCA_HOST depends on ARM64 depends on PCI_TSM depends on KVM + select KEYS + select X509_CERTIFICATE_PARSER select TSM select AUXILIARY_BUS + select CRYPTO_ECDSA + select CRYPTO_RSA =20 help ARM CCA RMM firmware is the trusted runtime that enforces memory diff --git a/drivers/virt/coco/arm-cca-host/rmi-da.c b/drivers/virt/coco/ar= m-cca-host/rmi-da.c index 644609618a7a..c9780ca64c17 100644 --- a/drivers/virt/coco/arm-cca-host/rmi-da.c +++ b/drivers/virt/coco/arm-cca-host/rmi-da.c @@ -8,6 +8,9 @@ #include #include #include +#include +#include +#include =20 #include "rmi-da.h" =20 @@ -361,6 +364,146 @@ static int do_pdev_communicate(struct pci_tsm *tsm, e= num rmi_pdev_state target_s return do_dev_communicate(PDEV_COMMUNICATE, tsm, target_state, RMI_PDEV_E= RROR); } =20 +static int parse_certificate_chain(struct pci_tsm *tsm) +{ + struct cca_host_pf0_dsc *pf0_dsc; + unsigned int chain_size; + unsigned int offset =3D 0; + u8 *chain_data; + + pf0_dsc =3D to_cca_pf0_dsc(tsm->pdev); + + /* If device communication didn't results in certificate caching. */ + if (!pf0_dsc->cert_chain.cache || !pf0_dsc->cert_chain.cache->offset) + return -EINVAL; + + chain_size =3D pf0_dsc->cert_chain.cache->offset; + chain_data =3D pf0_dsc->cert_chain.cache->buf; + + while (offset < chain_size) { + ssize_t cert_len =3D + x509_get_certificate_length(chain_data + offset, + chain_size - offset); + if (cert_len < 0) + return cert_len; + + struct x509_certificate *cert __free(x509_free_certificate) =3D + x509_cert_parse(chain_data + offset, cert_len); + + if (IS_ERR(cert)) { + pci_warn(tsm->pdev, "parsing of certificate chain not successful\n"); + return PTR_ERR(cert); + } + + /* The key in the last cert in the chain is used */ + if (offset + cert_len =3D=3D chain_size) { + pf0_dsc->cert_chain.public_key =3D kzalloc(cert->pub->keylen, GFP_KERNE= L); + if (!pf0_dsc->cert_chain.public_key) + return -ENOMEM; + + if (!strcmp("ecdsa-nist-p256", cert->pub->pkey_algo)) { + pf0_dsc->rmi_signature_algorithm =3D RMI_SIG_ECDSA_P256; + } else if (!strcmp("ecdsa-nist-p384", cert->pub->pkey_algo)) { + pf0_dsc->rmi_signature_algorithm =3D RMI_SIG_ECDSA_P384; + } else if (!strcmp("rsa", cert->pub->pkey_algo)) { + pf0_dsc->rmi_signature_algorithm =3D RMI_SIG_RSASSA_3072; + } else { + kfree(pf0_dsc->cert_chain.public_key); + pf0_dsc->cert_chain.public_key =3D NULL; + return -ENXIO; + } + memcpy(pf0_dsc->cert_chain.public_key, cert->pub->key, cert->pub->keyle= n); + pf0_dsc->cert_chain.public_key_size =3D cert->pub->keylen; + } + + offset +=3D cert_len; + } + + pf0_dsc->cert_chain.valid =3D true; + return 0; +} + +DEFINE_FREE(free_page, unsigned long, if (_T) free_page(_T)) +static int pdev_set_public_key(struct pci_tsm *tsm) +{ + unsigned long expected_key_len; + struct cca_host_pf0_dsc *pf0_dsc; + int ret; + + pf0_dsc =3D to_cca_pf0_dsc(tsm->pdev); + /* Check that all the necessary information was captured from communicati= on */ + if (!pf0_dsc->cert_chain.valid) + return -EINVAL; + + struct rmi_public_key_params *key_params __free(free_page) =3D + (struct rmi_public_key_params *)get_zeroed_page(GFP_KERNEL); + if (!key_params) + return -ENOMEM; + + key_params->rmi_signature_algorithm =3D pf0_dsc->rmi_signature_algorithm; + + switch (key_params->rmi_signature_algorithm) { + case RMI_SIG_ECDSA_P384: + { + expected_key_len =3D 97; + + if (pf0_dsc->cert_chain.public_key_size !=3D expected_key_len) + return -EINVAL; + + key_params->public_key_len =3D pf0_dsc->cert_chain.public_key_size; + memcpy(key_params->public_key, + pf0_dsc->cert_chain.public_key, + pf0_dsc->cert_chain.public_key_size); + key_params->metadata_len =3D 0; + break; + } + case RMI_SIG_ECDSA_P256: + { + expected_key_len =3D 65; + + if (pf0_dsc->cert_chain.public_key_size !=3D expected_key_len) + return -EINVAL; + + key_params->public_key_len =3D pf0_dsc->cert_chain.public_key_size; + memcpy(key_params->public_key, + pf0_dsc->cert_chain.public_key, + pf0_dsc->cert_chain.public_key_size); + key_params->metadata_len =3D 0; + break; + } + case RMI_SIG_RSASSA_3072: + { + struct rsa_key rsa_key =3D {0}; + + expected_key_len =3D 385; + int ret_rsa_parse =3D rsa_parse_pub_key(&rsa_key, + pf0_dsc->cert_chain.public_key, + pf0_dsc->cert_chain.public_key_size); + /* This also checks the key_len */ + if (ret_rsa_parse) + return ret_rsa_parse; + /* + * exponent is usually 65537 (size =3D 24bits) but in rare cases + * the size can be as large as the modulus + */ + if (rsa_key.e_sz > expected_key_len) + return -EINVAL; + + key_params->public_key_len =3D rsa_key.n_sz; + key_params->metadata_len =3D rsa_key.e_sz; + memcpy(key_params->public_key, rsa_key.n, rsa_key.n_sz); + memcpy(key_params->metadata, rsa_key.e, rsa_key.e_sz); + break; + } + default: + return -EINVAL; + } + + ret =3D rmi_pdev_set_pubkey(virt_to_phys(pf0_dsc->rmm_pdev), + virt_to_phys(key_params)); + return ret; +} + void pdev_communicate_work(struct work_struct *work) { unsigned long state; @@ -410,7 +553,28 @@ static int submit_pdev_comm_work(struct pci_dev *pdev,= int target_state) =20 int pdev_ide_setup(struct pci_dev *pdev) { - return submit_pdev_comm_work(pdev, RMI_PDEV_NEEDS_KEY); + int ret; + + ret =3D submit_pdev_comm_work(pdev, RMI_PDEV_NEEDS_KEY); + if (ret) + return ret; + /* + * we now have certificate chain in dsm->cert_chain. Parse + * that and set the pubkey. + */ + ret =3D parse_certificate_chain(pdev->tsm); + if (ret) + return ret; + + ret =3D pdev_set_public_key(pdev->tsm); + if (ret) + return ret; + + ret =3D submit_pdev_comm_work(pdev, RMI_PDEV_READY); + if (ret) + return ret; + + return 0; } =20 void pdev_stop_and_destroy(struct pci_dev *pdev) diff --git a/drivers/virt/coco/arm-cca-host/rmi-da.h b/drivers/virt/coco/ar= m-cca-host/rmi-da.h index e556ccecc1cb..f1a840b6d4fb 100644 --- a/drivers/virt/coco/arm-cca-host/rmi-da.h +++ b/drivers/virt/coco/arm-cca-host/rmi-da.h @@ -51,6 +51,7 @@ struct cca_host_pf0_dsc { int num_aux; void *aux[MAX_PDEV_AUX_GRANULES]; =20 + uint8_t rmi_signature_algorithm; struct mutex object_lock; struct { struct cache_object *cache; --=20 2.43.0