From patchwork Fri Jul 23 09:44:17 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jens Wiklander X-Patchwork-Id: 484593 Delivered-To: patches@linaro.org Received: by 2002:a02:c94a:0:0:0:0:0 with SMTP id u10csp1161641jao; Fri, 23 Jul 2021 02:44:31 -0700 (PDT) X-Received: by 2002:a19:a408:: with SMTP id q8mr2562657lfc.154.1627033471703; Fri, 23 Jul 2021 02:44:31 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1627033471; cv=none; d=google.com; s=arc-20160816; b=gXu/NowhRn21Yq9be/9FMcKEmLT+wK9pakrM0Rx2SDv4LlT+/w2hiWQJGkMPC/RpRW PlJbXqxtlZ6dEoUsiuksobD6JWdFx1aVw+JiUbHYLrAxHxaK52jlUljvRl+lIq3tNj+p pMjW6H7/O7jb4Gr1XC8nyylF+stRO0F3ZThh+Zo7aPnSurqBiaoYDZectXw0mtiO7HyD 2SFn6Keb2+jPKs2J0n7w8R4aKwIO+XDPIRbWJpTcIRipJ93sfLhxNqrieWdKelNvLlSE UMs82BGZace79l7NwavsDpfz5HssthaEwiVx1qByTjA+cLiDPg04uFN3zBfjT6rVT443 qlzg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:dkim-signature; bh=bPEFf1WmEOew3wXqjPL0D4ZH5STaPbCOCI4W4KStU94=; b=fxyvIIPfJPdJ3AM/JcRWxPWEB3/yMIDyRNQd+bUOaPH15pNU0uCrN+4fNdiGlAYBcA twehhJXNyukV5NrPyF8ROYqRedDia9Gl0dscPRdvgqtH7uKGyB4lpNLRibShbuW4LfjP bg+Hidgu5ePtPqH5/PBcl16ocTJ+Mj1phfWJeUL2IEepvNZ7VJJ6fk2S5rwp9BuzMgs4 Kj4eSkcG8brBNOZN7xwiAdZCCGBXjVNIW5KW61+IswU5n7hWQWD0LJtLzONlR8jZ2jb7 pUIBj63n69WG1Wy4c1T7witVBPTQNTFabZl1LBbs3djeum+4IHR5Hj/Nz8m+dME/91Jy IN/g== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=a1fNzzb0; spf=pass (google.com: domain of jens.wiklander@linaro.org designates 209.85.220.41 as permitted sender) smtp.mailfrom=jens.wiklander@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from mail-sor-f41.google.com (mail-sor-f41.google.com. [209.85.220.41]) by mx.google.com with SMTPS id m9sor3813563ljq.33.2021.07.23.02.44.31 for (Google Transport Security); Fri, 23 Jul 2021 02:44:31 -0700 (PDT) Received-SPF: pass (google.com: domain of jens.wiklander@linaro.org designates 209.85.220.41 as permitted sender) client-ip=209.85.220.41; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=a1fNzzb0; spf=pass (google.com: domain of jens.wiklander@linaro.org designates 209.85.220.41 as permitted sender) smtp.mailfrom=jens.wiklander@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=bPEFf1WmEOew3wXqjPL0D4ZH5STaPbCOCI4W4KStU94=; b=a1fNzzb05/JkuSVhINb3YkWj8d51JCyyRxYXYiYj6ThohOUOIgdXhsta9RGshy6sRO xGlH3w6PjD2kM6rgZ6xDjYJak4yoqpeogR3WPs2QpRsvLqBzVNel7IRXN0mFXfCTnX7S 9IWMtJCO3+23ZWBKcQ3Hi3z/6mF5vmmuUBGL+TK0LGY6aU1lR3qKU8kvC89mEs8slS8J ypst2K75DdwycYWpHinbHEBc4GxCrlBNvFBEEAaF7246BMUGJ5Bcg5OeHWYvkgVAP62r 9Qo/fmzeZyJ5j0AIfui9ZSA7N/VcVEQZjWzi/xrPfQs43+96jbu4dpbJ7RVjsp2uMjSj EYDg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=bPEFf1WmEOew3wXqjPL0D4ZH5STaPbCOCI4W4KStU94=; b=bXMMhCbF5ruwa0qCZoHxpp+aAyJzKkAP+XRREkMGrA1TWsll0J9BLIY+8SyHarTgQ+ hvNC6intfa3MLvb0GFsUfxCnK/N8vGxlmqcGB2g8p9gx46Kobe4Hqab2o/lpPpQN48+3 qVR0SzSlhnGRVLn1uQBOdcXzHDzekuxPot1qr5AY/D3xuH221jRZaWhdDUG2VdpBjQwf /oS3SqJVq5brMfcMqaqj5PurzIHZ1DfDpFBOKb3Zg1rHKFIVbX3ozuqFmPaVClKvrNXl aQzcdbHk0aA8ueTg+SgIeUPMZL9iPiPgYC1y9sR8kfDUqpGLCSlYYPLY6omfgAxK5dDo VO+w== X-Gm-Message-State: AOAM530w2B39dHEnU0ZwLGaphHbI622MA0QMbNCNvZYAWAlt8UBkRtKx Tq4Bc9Gl02DtEsspuqtjqGWl2m+D X-Google-Smtp-Source: ABdhPJyrtqd7az4W16h9/E8eGPNfaNqKDq1w3C76bT8yiFDLgB8Q722esL9ZhZ/kU/AVPUI6p9JWeQ== X-Received: by 2002:a2e:a54d:: with SMTP id e13mr2804045ljn.1.1627033471323; Fri, 23 Jul 2021 02:44:31 -0700 (PDT) Return-Path: Received: from jade.urgonet (h-94-254-48-165.A175.priv.bahnhof.se. [94.254.48.165]) by smtp.gmail.com with ESMTPSA id f2sm403808ljq.131.2021.07.23.02.44.30 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 23 Jul 2021 02:44:31 -0700 (PDT) From: Jens Wiklander To: linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, op-tee@lists.trustedfirmware.org, devicetree@vger.kernel.org, linux-doc@vger.kernel.org Cc: Jerome Forissier , Etienne Carriere , Sumit Garg , Vincent Guittot , Rob Herring , Jonathan Corbet , Ard Biesheuvel , Marc Zyngier , Jens Wiklander Subject: [PATCH v3 1/6] docs: staging/tee.rst: add a section on OP-TEE notifications Date: Fri, 23 Jul 2021 11:44:17 +0200 Message-Id: <20210723094422.2150313-2-jens.wiklander@linaro.org> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210723094422.2150313-1-jens.wiklander@linaro.org> References: <20210723094422.2150313-1-jens.wiklander@linaro.org> MIME-Version: 1.0 Adds a section on notifications used by OP-TEE, synchronous and asynchronous. Signed-off-by: Jens Wiklander --- Documentation/staging/tee.rst | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) -- 2.31.1 diff --git a/Documentation/staging/tee.rst b/Documentation/staging/tee.rst index 4d4b5f889603..37bdd097336f 100644 --- a/Documentation/staging/tee.rst +++ b/Documentation/staging/tee.rst @@ -184,6 +184,33 @@ order to support device enumeration. In other words, OP-TEE driver invokes this application to retrieve a list of Trusted Applications which can be registered as devices on the TEE bus. +OP-TEE notifications +-------------------- + +There are two kinds of notifications that secure world can use to make +normal world aware of some event. + +1. Synchronous notifications delivered with ``OPTEE_RPC_CMD_NOTIFICATION`` + using the ``OPTEE_RPC_NOTIFICATION_SEND`` parameter. +2. Asynchronous notifications delivered with a combination of a non-secure + interrupt and a fast call from the non-secure interrupt handler. + +Synchronous notifications are limited by depending on RPC for delivery, +this is only usable when secure world is entered with a yielding call via +``OPTEE_SMC_CALL_WITH_ARG``. This excludes such notifications from secure +world interrupt handlers. + +An asynchronous notification is delivered via a non-secure interrupt to an +interrupt handler registered in the OP-TEE driver. The actual notification +value are retrieved with the fast call ``OPTEE_SMC_GET_ASYNC_NOTIF_VALUE``. + +One notification value ``OPTEE_SMC_ASYNC_NOTIF_VALUE_DO_BOTTOM_HALF`` has a +special meaning. When this value is received it means that normal world is +supposed to make a yielding call ``OPTEE_MSG_CMD_DO_BOTTOM_HALF``. This +call is done from the thread assisting the interrupt handler. This is a +building block for OP-TEE OS in secure world to implement the top half and +bottom half style of device drivers. + AMD-TEE driver ============== From patchwork Fri Jul 23 09:44:18 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jens Wiklander X-Patchwork-Id: 484594 Delivered-To: patches@linaro.org Received: by 2002:a02:c94a:0:0:0:0:0 with SMTP id u10csp1161673jao; Fri, 23 Jul 2021 02:44:33 -0700 (PDT) X-Received: by 2002:a19:c18c:: with SMTP id r134mr2397680lff.606.1627033473189; Fri, 23 Jul 2021 02:44:33 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1627033473; cv=none; d=google.com; s=arc-20160816; b=iYSqETylOXlpnffktvn1Zw0d9Z4MtScAC6qZXvTjhW3meg1hL44ZQsQgQuAHo5nEDv gPTfxfS2gY6fbCAGrS2/PaRKwRuiI9QwN85zk3RxMABuJy/QiDNd1DYd2QH0QkFpXMxF KK8JKvQg0mhWndQeYtCmcEBMXf4+UctGOk/v3XlcCZ0aFvVjm3An84pX1Bt0qMg6xqlN yIwn99P2qCkZaWjVE6+GK6UZA4VeQXC5MXa4wZ3PLKEpqZXJl6WbVU9EvxaVrMJKlxRQ ygFnAvCplhImd0kHVIrrBSwKVFKo2dYC7aKwfFul44kJCb/e/H3xE4jujMq5Hx8sfOKA wIDA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:dkim-signature; bh=a/bqTZzKIHdxC3kmt2eWiFK7QCi70Duu4Zv6wBW6jAs=; b=IJYrYIKIhfApCi68auKIlVwZeG2Xw7Oku4W7ArqUJBxnbXIxXHveRQNmLnWV2OhJvJ rNHb72k0ZMiA+VvSIPsc1hh6N4uV8q2zn+0tUjPTBiC/7Eo2hzQN+tGkNfmFXjjTcVAm 3ulrEjQGOqBYZtznabeHJ1zw4za/tXPjcgsXtZtklVUz2ZYdsAb12gjqBqa3mYHDqpAw VPgrJfZlTE7UvWuQhuUI97/IzlDOlLFEGofIFgCA7JXledGxp5FGrjN7ldmpJnV0KbBv anCR14Rsh0tqmRo4s1w/atMral8ZN6EkQXHVfdqFI9hbCArxl4Xkx8eGnuV6VBGhtKKy 9fPw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=Wre17vH1; spf=pass (google.com: domain of jens.wiklander@linaro.org designates 209.85.220.41 as permitted sender) smtp.mailfrom=jens.wiklander@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from mail-sor-f41.google.com (mail-sor-f41.google.com. [209.85.220.41]) by mx.google.com with SMTPS id m21sor4033046lji.51.2021.07.23.02.44.33 for (Google Transport Security); Fri, 23 Jul 2021 02:44:33 -0700 (PDT) Received-SPF: pass (google.com: domain of jens.wiklander@linaro.org designates 209.85.220.41 as permitted sender) client-ip=209.85.220.41; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=Wre17vH1; spf=pass (google.com: domain of jens.wiklander@linaro.org designates 209.85.220.41 as permitted sender) smtp.mailfrom=jens.wiklander@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=a/bqTZzKIHdxC3kmt2eWiFK7QCi70Duu4Zv6wBW6jAs=; b=Wre17vH1r/X0eGI3ub3IhX+LY6NyisVfyC8qRkjVRtDIdjQvxGDzjODeaerxk018+e Jfkow/wywwMiwtR50JxRHzx8KNDPZalnSiP9ajJ0JcovcE4OiPkWhN5ndwtv70X7ujwj +YegKy2IBiarSxeg/3uddwJojhDNatwolFX97w+o/E+rwXmdmh3OziNRbqT9aYJ5TbPx UnT9Pccv9Wey/vrGVhr5CJqDfHB4hkDuLfrx5jYv0Idz0c+bXSaMVy9AhNiNIuF1VTAw IRvKn4lx/lZV4F+dK4B87RFYmNeVVg8Ao3FrnwV1IVc+gmR7Oj3kKIcHADe6eC6LmRKY Yprw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=a/bqTZzKIHdxC3kmt2eWiFK7QCi70Duu4Zv6wBW6jAs=; b=CflYmtl9sgLPjpTQqBikyahyV1cbADHWua9S62LR5CWP2++rSdtG1vOV726oh15cYy x7iGFQOZONWzigVKAUpA5sZJIW3lubElAspEiFsS/3qg28rI0YjgMsdr4VF0NSqUv6Vb XnHgP62vja03x/SCyUYKgfAw8WNPCigRxeBP6eOs4Ae3EHBxrXX5tMYy4t+g6dNJF80I wodz1eOfbYwjHWjyKC2m6yG6SQED6pT83GUhmhc07VtR6cat6S5MAQRn4SWJHj9Eqva3 oRuKsTOzmE07UNJq3op5YLUkRZl8sRHFj3LiGDORNOrxL8O/iesld8v0ra235YYKCai0 PUhQ== X-Gm-Message-State: AOAM533AFigxbIyUcQGafYQLEBasd1vvnHFhj9X+UOHQQueyZr2mwooI r6gmGUdV/gJrHqhILjbdoVtSahIG X-Google-Smtp-Source: ABdhPJwgaayYlGhMH6FoRP7pTpWRDBeBdQZDLPJ2kTl9qmB5jvRR/VWAISr1k4cjc8iHnmB7QeI2eQ== X-Received: by 2002:a2e:5c86:: with SMTP id q128mr2789959ljb.316.1627033472827; Fri, 23 Jul 2021 02:44:32 -0700 (PDT) Return-Path: Received: from jade.urgonet (h-94-254-48-165.A175.priv.bahnhof.se. [94.254.48.165]) by smtp.gmail.com with ESMTPSA id f2sm403808ljq.131.2021.07.23.02.44.31 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 23 Jul 2021 02:44:32 -0700 (PDT) From: Jens Wiklander To: linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, op-tee@lists.trustedfirmware.org, devicetree@vger.kernel.org, linux-doc@vger.kernel.org Cc: Jerome Forissier , Etienne Carriere , Sumit Garg , Vincent Guittot , Rob Herring , Jonathan Corbet , Ard Biesheuvel , Marc Zyngier , Jens Wiklander Subject: [PATCH v3 2/6] dt-bindings: arm: optee: add interrupt property Date: Fri, 23 Jul 2021 11:44:18 +0200 Message-Id: <20210723094422.2150313-3-jens.wiklander@linaro.org> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210723094422.2150313-1-jens.wiklander@linaro.org> References: <20210723094422.2150313-1-jens.wiklander@linaro.org> MIME-Version: 1.0 Adds an optional interrupt property to the optee binding. Signed-off-by: Jens Wiklander --- .../devicetree/bindings/arm/firmware/linaro,optee-tz.yaml | 4 ++++ 1 file changed, 4 insertions(+) -- 2.31.1 diff --git a/Documentation/devicetree/bindings/arm/firmware/linaro,optee-tz.yaml b/Documentation/devicetree/bindings/arm/firmware/linaro,optee-tz.yaml index c24047c1fdd5..73811a5d1714 100644 --- a/Documentation/devicetree/bindings/arm/firmware/linaro,optee-tz.yaml +++ b/Documentation/devicetree/bindings/arm/firmware/linaro,optee-tz.yaml @@ -24,6 +24,9 @@ properties: compatible: const: linaro,optee-tz + interrupts: + maxItems: 1 + method: enum: [smc, hvc] description: | @@ -46,6 +49,7 @@ examples: optee { compatible = "linaro,optee-tz"; method = "smc"; + interrupts = <0 187 4>; }; }; From patchwork Fri Jul 23 09:44:19 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jens Wiklander X-Patchwork-Id: 484595 Delivered-To: patches@linaro.org Received: by 2002:a02:c94a:0:0:0:0:0 with SMTP id u10csp1161689jao; Fri, 23 Jul 2021 02:44:34 -0700 (PDT) X-Received: by 2002:a05:651c:1590:: with SMTP id h16mr2747930ljq.147.1627033474072; Fri, 23 Jul 2021 02:44:34 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1627033474; cv=none; d=google.com; s=arc-20160816; b=CzDnS53LTfVQQwyYRH3hewDM/3dN1O3iUu2gSpDRoA0+/pHkOvlconfmicEr9a61cW ihktpCDYh8lBSJhFEJUrHcOTDIJle+3RuDIcRpcilYANkt0aWa8m6XTN7zznxDBATMSa 8XkxcYn9gpr+r9Y2ojN3pdUspQ6tmcQ3vbv5qkVWPBR8qRptoFNYJPmWym4z27bw42OS LZeVQKlmRJetQ/xtlsxO5+9iex8tOTElHRfd5grW4rKbTpO+AZxhiK4QP5/40u00cAyS 55upJAdzm5Uy58UC0DEyIxyYWuh6nE+7xvOF/WpKDHHkH783OlNtKyFHWkQRc5rrekZp Kqyw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:dkim-signature; bh=JoodeoEbWA8KFPSDaqBt6HBmf+JeOe0hbWt7ocF/yag=; b=T5v3TRC+SPWDut9/DXy9H7vCvgi29w/uZdA67Y3TZbaqcl2Xs7UiZZxaUckrzdA2qg 5rtuJ1BHmoCQIpIKmsw9UTysaZ552AQWqkAL8VcJ2mU8wq77s5YguMErdJEpfp+E7F/T LBesMrAagL6OIT2bwGuICU1Dt/9SYySSCXJ47LUHSl/0/HRo84+gMcFArL2QgTVcypMa rOFWVyHlc5YDu/hg5tW+dOGTOmMU4B59bN73NHbo2iBt1KWdZYiw2UKTmzPrfwj6xdiU K8opxcb4W63GLj3oQw64Qjni7+wo2sG8F0heYfHR/8n+R4tDjAs2vE2R50/lkr79w2Rt yeCQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=IQupQu09; spf=pass (google.com: domain of jens.wiklander@linaro.org designates 209.85.220.41 as permitted sender) smtp.mailfrom=jens.wiklander@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from mail-sor-f41.google.com (mail-sor-f41.google.com. [209.85.220.41]) by mx.google.com with SMTPS id k10sor4011301lji.5.2021.07.23.02.44.33 for (Google Transport Security); Fri, 23 Jul 2021 02:44:34 -0700 (PDT) Received-SPF: pass (google.com: domain of jens.wiklander@linaro.org designates 209.85.220.41 as permitted sender) client-ip=209.85.220.41; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=IQupQu09; spf=pass (google.com: domain of jens.wiklander@linaro.org designates 209.85.220.41 as permitted sender) smtp.mailfrom=jens.wiklander@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=JoodeoEbWA8KFPSDaqBt6HBmf+JeOe0hbWt7ocF/yag=; b=IQupQu096dOf2RXy1dTEeXIOMGbe6WjJhcaIEXhbvkmYHJXjdMb0znsum0XkoEfm0b oZAyT0no0mbv1QNkEJCIL8Ycp+A2wxAnySr21P6vwmTnbM0x54jAaRuSlsmJSsk9KvIc 3+lzExnUxYmBgMM6D2awrRdlxwmCx0eFrn77sO8iolEDUBqktiTOwi+QBv6ve/3SK65f welVLkY/7gXxj/KGu52/SQBYzf7iXLxHHs5Ovc7izB3FaJhmLEwKcyT/7PTU41IsPpqu XvEPhAOHUMGRifagj7+ZhmEkZsJdF9rYyoUuXIHuqVnL/DUQ4h6w1oeymhdrXUOT6laJ 6eQg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=JoodeoEbWA8KFPSDaqBt6HBmf+JeOe0hbWt7ocF/yag=; b=YkMKH06uWg/oKuobZmgsiIBXYBARZcbbb9Gkw4yvHIrDNqHsLbNxZHgKY59GJGocOc gwI+/dlbU776FCz5DbX6wtp5QV1RhEvSNXDSBA7c8ZZTvPWMlAcHrg/S/xg49znx6wHi HQnP0fWw6jcHJ510NrWHQeO5NkRk8GiaMUAy0XfpJSUt/eXMFvo8HXBAz8h6urUIL9/x WyLKVbXNfiYmzmLJUxnnAabCBlDevReVb9MZ7Ggdhn9NLBFN3S09M6PfkJiL6idB1ov+ OpMbHsY74/hqdb/f2EM4+yFozYdiYmBR4N2dXI7tCf540+htDjPVGfcT7NBSga9gHQO2 W0jg== X-Gm-Message-State: AOAM5330Mqj4vSqEJDtEmfNIwSDVB8qdJN2jVzpLni+nFmZquA2ewLRe pAiWtYbF9PXVF6jwlF1Yp+7PSo6n X-Google-Smtp-Source: ABdhPJxthOMwVWH+D74X2QymqEcjwWIzgiPvVu2K8kpmy+fsoCGXSl6heRTr6xFDRTRKY7MJE5SvuA== X-Received: by 2002:a2e:9b10:: with SMTP id u16mr2747522lji.228.1627033473706; Fri, 23 Jul 2021 02:44:33 -0700 (PDT) Return-Path: Received: from jade.urgonet (h-94-254-48-165.A175.priv.bahnhof.se. [94.254.48.165]) by smtp.gmail.com with ESMTPSA id f2sm403808ljq.131.2021.07.23.02.44.32 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 23 Jul 2021 02:44:33 -0700 (PDT) From: Jens Wiklander To: linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, op-tee@lists.trustedfirmware.org, devicetree@vger.kernel.org, linux-doc@vger.kernel.org Cc: Jerome Forissier , Etienne Carriere , Sumit Garg , Vincent Guittot , Rob Herring , Jonathan Corbet , Ard Biesheuvel , Marc Zyngier , Jens Wiklander Subject: [PATCH v3 3/6] tee: fix put order in teedev_close_context() Date: Fri, 23 Jul 2021 11:44:19 +0200 Message-Id: <20210723094422.2150313-4-jens.wiklander@linaro.org> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210723094422.2150313-1-jens.wiklander@linaro.org> References: <20210723094422.2150313-1-jens.wiklander@linaro.org> MIME-Version: 1.0 Prior to this patch was teedev_close_context() calling tee_device_put() before teedev_ctx_put() leading to teedev_ctx_release() accessing ctx->teedev just after the reference counter was decreased on the teedev. Fix this by calling teedev_ctx_put() before tee_device_put(). Fixes: 217e0250cccb ("tee: use reference counting for tee_context") Signed-off-by: Jens Wiklander --- drivers/tee/tee_core.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) -- 2.31.1 diff --git a/drivers/tee/tee_core.c b/drivers/tee/tee_core.c index 2b37bc408fc3..85102d12d716 100644 --- a/drivers/tee/tee_core.c +++ b/drivers/tee/tee_core.c @@ -98,8 +98,10 @@ void teedev_ctx_put(struct tee_context *ctx) static void teedev_close_context(struct tee_context *ctx) { - tee_device_put(ctx->teedev); + struct tee_device *teedev = ctx->teedev; + teedev_ctx_put(ctx); + tee_device_put(teedev); } static int tee_open(struct inode *inode, struct file *filp) From patchwork Fri Jul 23 09:44:20 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jens Wiklander X-Patchwork-Id: 484596 Delivered-To: patches@linaro.org Received: by 2002:a02:c94a:0:0:0:0:0 with SMTP id u10csp1161706jao; Fri, 23 Jul 2021 02:44:35 -0700 (PDT) X-Received: by 2002:a2e:8858:: with SMTP id z24mr2787730ljj.413.1627033475289; Fri, 23 Jul 2021 02:44:35 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1627033475; cv=none; d=google.com; s=arc-20160816; b=HkmshGMSZXnHPQ95sAP/Ax2+rM+T1GGti4vIZmqrJoLDjimEsyG9K+S+9gIphSlGnW 8o6qHzceqrCjGc5ZgQgA9CrgjWu9Jhs53uEeN1wZtwrE8ik6DxvjEJFFywSj8guzyvLH yRTARJ5yHg9ghJKxkq5brC/58Jxw+iU4OIt/9QdTflOa3FTPV/hlrlEL5fm5tsZnrRq1 ilonCLoJTJMEpTVq75ggb9A4PNZMTsvjRkyPPvmg2sHHCtGa+zxkBsRCd0/3wB2YKudW Rij9fn29bgBYfB+GVd4YXEgAIZZUrjWbiFD5+N7fpPRTfQ0NCDDzG5Dqyuxz2Vl29Xf+ RSmQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:dkim-signature; bh=WPLYx23a2mlUDNIPIrmDSM+cSt8akT06mvONQVQY3/s=; b=aWI5LwYzEk1+SzkMdbQDekL7MO6mbBvmbI38UTT49KYWSmyMqKCNn/RC8iyYkML4og u9b7mqpLPNLmNl64qMInRpB7faNa8hVDxW66IVrd6IdibDq8/K0dENP7JP051NqeY2nn 2Zlx21hLLF6ozm1sKZbfNKjFWAQsSkJaGKQkBpJTMJCXhxR0VE2PSA750ARaZUTzSQrh 1UZYX885LftaBHPjkTACIxIRoQocTzkB3zgRAFBzLgYKwuxXX+z31yBm8gN0jRXdkSeK o1ht5bxo0oRVlk6pBc6t8otS7MvHgl4XQIPnsvO24+KwQAyDYGMZ8hfJR7V7JcZtbvU3 xOsg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=rCZNiQTt; spf=pass (google.com: domain of jens.wiklander@linaro.org designates 209.85.220.41 as permitted sender) smtp.mailfrom=jens.wiklander@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from mail-sor-f41.google.com (mail-sor-f41.google.com. [209.85.220.41]) by mx.google.com with SMTPS id r28sor4028046ljn.31.2021.07.23.02.44.35 for (Google Transport Security); Fri, 23 Jul 2021 02:44:35 -0700 (PDT) Received-SPF: pass (google.com: domain of jens.wiklander@linaro.org designates 209.85.220.41 as permitted sender) client-ip=209.85.220.41; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=rCZNiQTt; spf=pass (google.com: domain of jens.wiklander@linaro.org designates 209.85.220.41 as permitted sender) smtp.mailfrom=jens.wiklander@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=WPLYx23a2mlUDNIPIrmDSM+cSt8akT06mvONQVQY3/s=; b=rCZNiQTtlGlnelUgxTWe4qNxD7ZBVpZgUQsXhcEhdRoKuCGWpPiAOXtoTVWlWQpoLC LJRQccJsNRTOJJF2w8+52TBOW9t4f9iXcQL42XbxhkQZNoCXRkgE/5dsDdA+QXtW5QRx o0ZuMJyvGQ7HKHgGUGQRka8rstx+KtyPrioXNrkHPzL0L+lCxstbYcyKBooqzbXKLRll sRi4Kz3HFkHMMt1TqCMacoALTx7DZX4qemcG91xk1Bg4wNOijr2QCs54EFqwuiKDnQma O8ZxOQOh5POr/YMLAsJu5yydL/xt3plOha5Nr1HVox1GWERCHcaxVKE5tEc4W5EY5j2s /jrg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=WPLYx23a2mlUDNIPIrmDSM+cSt8akT06mvONQVQY3/s=; b=nDYpYjkQzsQ6woo5nVWPMH3VPA5LPELQWZ6KnLGqDrpqwUQpnEp50CcTOxlqQhRtAC U0B8mi2/ajzXK6WBEFxsX21HYkN0EPGwldzIRVnDmPUGlmwY2HzwoxPfnBx8Ai5NeuCa WJF/dGkwcO+TGyUISLaCX4H7r3KDdQnkQctx4yaXSQch9rc07EYKOqnQ/R0jscn5CNdD ONl1Iac+71KbP+ErRX2DmyGWNM8Y75ss5Ovg34wqMxyEguqmAGi7PFnd+GdRw23QyrVy 6BQC4BToN6PIo+kwYf2F/1+A8SnWGSDmkvF/dxDfEs42Uk5udY+2qAqyH9XxIxgUGvaz Eyjw== X-Gm-Message-State: AOAM533BecjhXIooG3mdEO30af775hUnFmL/yd2GSedWOqoy8BQLvg69 n1jFK2rOhl81pALYWHflMfEf/wap X-Google-Smtp-Source: ABdhPJwryV2kGUFQOzaeEnVmeuptMeG5ynwTmIpI2zfA8ANVJqV3rrWwmLtiVSvvMHmHB3bPpncBcQ== X-Received: by 2002:a2e:b4a8:: with SMTP id q8mr2724250ljm.263.1627033474846; Fri, 23 Jul 2021 02:44:34 -0700 (PDT) Return-Path: Received: from jade.urgonet (h-94-254-48-165.A175.priv.bahnhof.se. [94.254.48.165]) by smtp.gmail.com with ESMTPSA id f2sm403808ljq.131.2021.07.23.02.44.33 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 23 Jul 2021 02:44:34 -0700 (PDT) From: Jens Wiklander To: linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, op-tee@lists.trustedfirmware.org, devicetree@vger.kernel.org, linux-doc@vger.kernel.org Cc: Jerome Forissier , Etienne Carriere , Sumit Garg , Vincent Guittot , Rob Herring , Jonathan Corbet , Ard Biesheuvel , Marc Zyngier , Jens Wiklander Subject: [PATCH v3 4/6] tee: add tee_dev_open_helper() primitive Date: Fri, 23 Jul 2021 11:44:20 +0200 Message-Id: <20210723094422.2150313-5-jens.wiklander@linaro.org> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210723094422.2150313-1-jens.wiklander@linaro.org> References: <20210723094422.2150313-1-jens.wiklander@linaro.org> MIME-Version: 1.0 Adds tee_dev_open_helper() and tee_dev_ctx_put() to make it easier to create a driver internal struct tee_context without the usual tee_device_get() on the struct tee_device as that adds a circular reference counter dependency and would prevent the struct tee_device from ever being released again. Signed-off-by: Jens Wiklander --- drivers/tee/tee_core.c | 33 ++++++++++++++++++++++++--------- include/linux/tee_drv.h | 27 +++++++++++++++++++++++++++ 2 files changed, 51 insertions(+), 9 deletions(-) -- 2.31.1 diff --git a/drivers/tee/tee_core.c b/drivers/tee/tee_core.c index 85102d12d716..3beb682684a8 100644 --- a/drivers/tee/tee_core.c +++ b/drivers/tee/tee_core.c @@ -43,14 +43,11 @@ static DEFINE_SPINLOCK(driver_lock); static struct class *tee_class; static dev_t tee_devt; -static struct tee_context *teedev_open(struct tee_device *teedev) +struct tee_context *tee_dev_open_helper(struct tee_device *teedev) { int rc; struct tee_context *ctx; - if (!tee_device_get(teedev)) - return ERR_PTR(-EINVAL); - ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); if (!ctx) { rc = -ENOMEM; @@ -66,10 +63,30 @@ static struct tee_context *teedev_open(struct tee_device *teedev) return ctx; err: kfree(ctx); - tee_device_put(teedev); return ERR_PTR(rc); } +EXPORT_SYMBOL_GPL(tee_dev_open_helper); + +void tee_dev_ctx_put(struct tee_context *ctx) +{ + teedev_ctx_put(ctx); +} +EXPORT_SYMBOL_GPL(tee_dev_ctx_put); + +static struct tee_context *teedev_open(struct tee_device *teedev) +{ + struct tee_context *ctx; + + if (!tee_device_get(teedev)) + return ERR_PTR(-EINVAL); + + ctx = tee_dev_open_helper(teedev); + if (IS_ERR(ctx)) + tee_device_put(teedev); + + return ctx; +} void teedev_ctx_get(struct tee_context *ctx) { @@ -90,10 +107,8 @@ static void teedev_ctx_release(struct kref *ref) void teedev_ctx_put(struct tee_context *ctx) { - if (ctx->releasing) - return; - - kref_put(&ctx->refcount, teedev_ctx_release); + if (ctx && !ctx->releasing) + kref_put(&ctx->refcount, teedev_ctx_release); } static void teedev_close_context(struct tee_context *ctx) diff --git a/include/linux/tee_drv.h b/include/linux/tee_drv.h index 54269e47ac9a..f592ba4e9561 100644 --- a/include/linux/tee_drv.h +++ b/include/linux/tee_drv.h @@ -456,6 +456,33 @@ static inline int tee_shm_get_id(struct tee_shm *shm) */ struct tee_shm *tee_shm_get_from_id(struct tee_context *ctx, int id); +/** + * tee_dev_open_helper() - helper function to make a struct tee_context + * @teedev: Device to open + * + * Creates the struct tee_context without increasing the reference counter + * on @teedev. This is needed for instance when a driver need an internal + * struct tee_context to operate on. By skipping the reference counter + * the circular dependency is broken. + * + * Note that this struct tee_context need special care when freeing in + * order to avoid the normal put on the struct tee_device. + * tee_dev_ctx_put() is the best choice for this. + * + * @returns a pointer 'struct tee_context' on success or an ERR_PTR on failure + */ +struct tee_context *tee_dev_open_helper(struct tee_device *teedev); + +/** + * tee_dev_ctx_put() - helper function to release a struct tee_context + * @ctx: The struct tee_context to release + * + * Note that this function doesn't do a tee_device_put() on the internal + * struct tee_device so this function should normal only be used when + * releasing a struct tee_context obtained with tee_dev_open_helper(). + */ +void tee_dev_ctx_put(struct tee_context *ctx); + /** * tee_client_open_context() - Open a TEE context * @start: if not NULL, continue search after this context From patchwork Fri Jul 23 09:44:21 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jens Wiklander X-Patchwork-Id: 484597 Delivered-To: patches@linaro.org Received: by 2002:a02:c94a:0:0:0:0:0 with SMTP id u10csp1161715jao; Fri, 23 Jul 2021 02:44:36 -0700 (PDT) X-Received: by 2002:a05:6512:3444:: with SMTP id j4mr2593465lfr.147.1627033476187; Fri, 23 Jul 2021 02:44:36 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1627033476; cv=none; d=google.com; s=arc-20160816; b=TSSFXmYGdGXy6Axj8nwlTnCkoHsaMKNc/ryAW3CYQyZ1/qiSHLo09TZKZJL/X20EzQ bLX7Dfho4qi9ZygCDft43JtVsBRwR5qnbjn+Lnr2qSVoX52rh4ENMhe0lRK9OUU5oL6o nvGrjrFQIjQC/25VEsnol2MGOc2AXY7hQkc0VISsJzytJcjqY9krgP90U05zDaYVXXnt +T2M610Hr9dmg3lH0TBoZoojNzVfcJnJwwR1uj1PcECL9nSvFJFeJH9gAykpqgWtNiR9 rdqCqqRhWcgruZc4Zn5jZnVeUNqJ7T4EXiwhzvXPpAZe1jTK/LTo3yUrxjgOOrGzdryA yTHg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:dkim-signature; bh=FdRv9iNdXE4gJIWcq1jF51m1svA1oer9OapZtgMeh2g=; b=b+LR7gZHVjVRfgnL7gyFOFWs1QmJBpnH0tNu8SOVrkYnDvpQIYd4HL2GGZ2WjJW0ue kKodJTiaVtwPlp0Md1+ur5LyGo3pVJxi4FBnM5rYUwl2nXlgyJV3IAxD2cb2pmc5U8a2 volvzuKaqRZbtDGau84s/rqTG1Deefk/DvLJ5Rkx5zLfMRl4LojNSHfIov6s4ECft6QR NZsrk0nEfT3s5aVlcWB+5JeMoud0BPJ0EcpJQfULkHAFKMrar3SZ4DqP2Q78Z2gx78nF 9cuBXAUelZ6DK68E/Utvq6WL3Ilbr5ARGr/hyonFuVuWA1/HzLAIchoXf+QDxThONrix gXGg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=vkmRmMqI; spf=pass (google.com: domain of jens.wiklander@linaro.org designates 209.85.220.41 as permitted sender) smtp.mailfrom=jens.wiklander@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from mail-sor-f41.google.com (mail-sor-f41.google.com. [209.85.220.41]) by mx.google.com with SMTPS id k18sor3983811ljc.6.2021.07.23.02.44.36 for (Google Transport Security); Fri, 23 Jul 2021 02:44:36 -0700 (PDT) Received-SPF: pass (google.com: domain of jens.wiklander@linaro.org designates 209.85.220.41 as permitted sender) client-ip=209.85.220.41; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=vkmRmMqI; spf=pass (google.com: domain of jens.wiklander@linaro.org designates 209.85.220.41 as permitted sender) smtp.mailfrom=jens.wiklander@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=FdRv9iNdXE4gJIWcq1jF51m1svA1oer9OapZtgMeh2g=; b=vkmRmMqIf6j+FwgOrZKGutAMO2mm2hRfM3ij0B7+LecU6cneRqbwgww6dCFF+Bj8YC EOa9pZy8McwFr4wiuECc2f32f481FS4/Z75l0z/UHJ7/knprfXr9Hb8oND2+GW+MiNaL hVHajCXlVeNknU1YxP7QCCVh3mOjb0eRwz/DtC91KlDu8c56/xU+AdGygG5Mt+lC4sEG HDhlXqWGFxtW7p6Ps5zT74nhW8zRyMxvUnWgekjhTSfWmX8PKryQpMqWvzNc5xlfiQDB 0mAWZ2CEOQXFrHVfiPPsetbvfkQ8UO5Y9OEj5pdXSFT/t3Fxm7hsphhUY452nclDhRal /o3A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=FdRv9iNdXE4gJIWcq1jF51m1svA1oer9OapZtgMeh2g=; b=ZB7unPNQXjmtGm08qlX8uqrxLQ05/n/oRwYZ+LAoVez0fYRntqD6768Bp1DEFw9ouD HpQ6zY+21esmT5f2QlknTH17l9K4A9KfpLNyfn3MEIq8UuP8TN6+O56+OHW+7twa9znM Oci/F26YHVm7JCWTO1bj8kPrhAxCN/brJaGMTXaOD5rqdEqy3TP1r8MoUfvBuiXpUx1Y 7yiaiplEA0Uf/N1NP5YYoglbDpTFX76izKJwVSj+BsTaDph1EJMGDK68O0CI2wzsA/YJ nuhZWilTU8v6tL2s/s6nq2VLVvJGzUsDbUg/z5Qq4AXb+lQgEhB1jYZpdOPzERWxsaUE rteg== X-Gm-Message-State: AOAM532loQIDsPxb5bRTZl+L03KlFUsIsxNVFsbPSwG3oQgg1WSjpJsw /hC29nfCfDCaGfU1Kd+0AZ0TEV0m X-Google-Smtp-Source: ABdhPJxNt79Ejc/I+X/HY73cm3ApMOyyefG3q1fYeQxHKpJNqbdxsAfLDbblc7iiBjB7JSyUBGdn1w== X-Received: by 2002:a05:651c:211d:: with SMTP id a29mr2820953ljq.78.1627033475707; Fri, 23 Jul 2021 02:44:35 -0700 (PDT) Return-Path: Received: from jade.urgonet (h-94-254-48-165.A175.priv.bahnhof.se. [94.254.48.165]) by smtp.gmail.com with ESMTPSA id f2sm403808ljq.131.2021.07.23.02.44.34 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 23 Jul 2021 02:44:35 -0700 (PDT) From: Jens Wiklander To: linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, op-tee@lists.trustedfirmware.org, devicetree@vger.kernel.org, linux-doc@vger.kernel.org Cc: Jerome Forissier , Etienne Carriere , Sumit Garg , Vincent Guittot , Rob Herring , Jonathan Corbet , Ard Biesheuvel , Marc Zyngier , Jens Wiklander Subject: [PATCH v3 5/6] optee: separate notification functions Date: Fri, 23 Jul 2021 11:44:21 +0200 Message-Id: <20210723094422.2150313-6-jens.wiklander@linaro.org> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210723094422.2150313-1-jens.wiklander@linaro.org> References: <20210723094422.2150313-1-jens.wiklander@linaro.org> MIME-Version: 1.0 Renames struct optee_wait_queue to struct optee_notif and all related functions to optee_notif_*(). The implementation is changed to allow sending a notification from an atomic state, that is from the top half of an interrupt handler. Waiting for keys is currently only used when secure world is waiting for a mutex or condition variable. The old implementation could handle any 32-bit key while this new implementation is restricted to only 8 bits or the maximum value 255. A upper value is needed since a bitmap is allocated to allow an interrupt handler to only set a bit in case the waiter hasn't had the time yet to allocate and register a completion. The keys are currently only representing secure world threads which number usually are never even close to 255 so it should be safe for now. In future ABI updates the maximum value of the key will be communicated while the driver is initializing. Signed-off-by: Jens Wiklander --- drivers/tee/optee/Makefile | 1 + drivers/tee/optee/core.c | 13 +++- drivers/tee/optee/notif.c | 125 ++++++++++++++++++++++++++++++ drivers/tee/optee/optee_private.h | 19 +++-- drivers/tee/optee/optee_rpc_cmd.h | 31 ++++---- drivers/tee/optee/rpc.c | 73 ++--------------- 6 files changed, 171 insertions(+), 91 deletions(-) create mode 100644 drivers/tee/optee/notif.c -- 2.31.1 diff --git a/drivers/tee/optee/Makefile b/drivers/tee/optee/Makefile index 3aa33ea9e6a6..df55e4ad5370 100644 --- a/drivers/tee/optee/Makefile +++ b/drivers/tee/optee/Makefile @@ -2,6 +2,7 @@ obj-$(CONFIG_OPTEE) += optee.o optee-objs += core.o optee-objs += call.o +optee-objs += notif.o optee-objs += rpc.o optee-objs += supp.o optee-objs += shm_pool.o diff --git a/drivers/tee/optee/core.c b/drivers/tee/optee/core.c index ddb8f9ecf307..2272696ac986 100644 --- a/drivers/tee/optee/core.c +++ b/drivers/tee/optee/core.c @@ -583,6 +583,7 @@ static int optee_remove(struct platform_device *pdev) */ optee_disable_shm_cache(optee); + optee_notif_uninit(optee); /* * The two devices have to be unregistered before we can free the * other resources. @@ -593,7 +594,6 @@ static int optee_remove(struct platform_device *pdev) tee_shm_pool_free(optee->pool); if (optee->memremaped_shm) memunmap(optee->memremaped_shm); - optee_wait_queue_exit(&optee->wait_queue); optee_supp_uninit(&optee->supp); mutex_destroy(&optee->call_queue.mutex); @@ -681,18 +681,23 @@ static int optee_probe(struct platform_device *pdev) mutex_init(&optee->call_queue.mutex); INIT_LIST_HEAD(&optee->call_queue.waiters); - optee_wait_queue_init(&optee->wait_queue); optee_supp_init(&optee->supp); optee->memremaped_shm = memremaped_shm; optee->pool = pool; + platform_set_drvdata(pdev, optee); + + rc = optee_notif_init(optee, 255); + if (rc) { + optee_remove(pdev); + return rc; + } + optee_enable_shm_cache(optee); if (optee->sec_caps & OPTEE_SMC_SEC_CAP_DYNAMIC_SHM) pr_info("dynamic shared memory is enabled\n"); - platform_set_drvdata(pdev, optee); - rc = optee_enumerate_devices(PTA_CMD_GET_DEVICES); if (rc) { optee_remove(pdev); diff --git a/drivers/tee/optee/notif.c b/drivers/tee/optee/notif.c new file mode 100644 index 000000000000..a28fa03dcd0e --- /dev/null +++ b/drivers/tee/optee/notif.c @@ -0,0 +1,125 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (c) 2015-2021, Linaro Limited + */ + +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include +#include +#include +#include +#include +#include "optee_private.h" + +struct notif_entry { + struct list_head link; + struct completion c; + u_int key; +}; + +static bool have_key(struct optee *optee, u_int key) +{ + struct notif_entry *entry; + + list_for_each_entry(entry, &optee->notif.db, link) + if (entry->key == key) + return true; + + return false; +} + +int optee_notif_wait(struct optee *optee, u_int key) +{ + unsigned long flags; + struct notif_entry *entry; + int rc = 0; + + if (key > optee->notif.max_key) + return -EINVAL; + + entry = kmalloc(sizeof(*entry), GFP_KERNEL); + if (!entry) + return -ENOMEM; + init_completion(&entry->c); + entry->key = key; + + spin_lock_irqsave(&optee->notif.lock, flags); + + /* + * If the bit is already set it means that the key has already + * been posted and we must not wait. + */ + if (test_bit(key, optee->notif.bitmap)) { + clear_bit(key, optee->notif.bitmap); + goto out; + } + + /* + * Check if someone is already waiting for this key. If there is + * it's a programming error. + */ + if (have_key(optee, key)) { + rc = -EBUSY; + goto out; + } + + list_add_tail(&entry->link, &optee->notif.db); + + /* + * Unlock temporarily and wait for completion. + */ + spin_unlock_irqrestore(&optee->notif.lock, flags); + wait_for_completion(&entry->c); + spin_lock_irqsave(&optee->notif.lock, flags); + + list_del(&entry->link); +out: + spin_unlock_irqrestore(&optee->notif.lock, flags); + + kfree(entry); + + return rc; +} + +int optee_notif_send(struct optee *optee, u_int key) +{ + unsigned long flags; + struct notif_entry *entry; + + if (key > optee->notif.max_key) + return -EINVAL; + + spin_lock_irqsave(&optee->notif.lock, flags); + + list_for_each_entry(entry, &optee->notif.db, link) + if (entry->key == key) { + complete(&entry->c); + goto out; + } + + /* Only set the bit in case there where nobody waiting */ + set_bit(key, optee->notif.bitmap); +out: + spin_unlock_irqrestore(&optee->notif.lock, flags); + + return 0; +} + +int optee_notif_init(struct optee *optee, u_int max_key) +{ + spin_lock_init(&optee->notif.lock); + INIT_LIST_HEAD(&optee->notif.db); + optee->notif.bitmap = bitmap_zalloc(max_key, GFP_KERNEL); + if (!optee->notif.bitmap) + return -ENOMEM; + + optee->notif.max_key = max_key; + + return 0; +} + +void optee_notif_uninit(struct optee *optee) +{ + kfree(optee->notif.bitmap); +} diff --git a/drivers/tee/optee/optee_private.h b/drivers/tee/optee/optee_private.h index e25b216a14ef..7dc058d008b2 100644 --- a/drivers/tee/optee/optee_private.h +++ b/drivers/tee/optee/optee_private.h @@ -35,10 +35,12 @@ struct optee_call_queue { struct list_head waiters; }; -struct optee_wait_queue { - /* Serializes access to this struct */ - struct mutex mu; +struct optee_notif { + u_int max_key; + /* Serializes access to the elements below in this struct */ + spinlock_t lock; struct list_head db; + u_long *bitmap; }; /** @@ -72,8 +74,7 @@ struct optee_supp { * @teedev: client device * @invoke_fn: function to issue smc or hvc * @call_queue: queue of threads waiting to call @invoke_fn - * @wait_queue: queue of threads from secure world waiting for a - * secure world sync object + * @notif: notification synchronization struct * @supp: supplicant synchronization struct for RPC to supplicant * @pool: shared memory pool * @memremaped_shm virtual address of memory in shared memory pool @@ -88,7 +89,7 @@ struct optee { struct tee_device *teedev; optee_invoke_fn *invoke_fn; struct optee_call_queue call_queue; - struct optee_wait_queue wait_queue; + struct optee_notif notif; struct optee_supp supp; struct tee_shm_pool *pool; void *memremaped_shm; @@ -131,8 +132,10 @@ void optee_handle_rpc(struct tee_context *ctx, struct optee_rpc_param *param, struct optee_call_ctx *call_ctx); void optee_rpc_finalize_call(struct optee_call_ctx *call_ctx); -void optee_wait_queue_init(struct optee_wait_queue *wq); -void optee_wait_queue_exit(struct optee_wait_queue *wq); +int optee_notif_init(struct optee *optee, u_int max_key); +void optee_notif_uninit(struct optee *optee); +int optee_notif_wait(struct optee *optee, u_int key); +int optee_notif_send(struct optee *optee, u_int key); u32 optee_supp_thrd_req(struct tee_context *ctx, u32 func, size_t num_params, struct tee_param *param); diff --git a/drivers/tee/optee/optee_rpc_cmd.h b/drivers/tee/optee/optee_rpc_cmd.h index b8275140cef8..f3f06e0994a7 100644 --- a/drivers/tee/optee/optee_rpc_cmd.h +++ b/drivers/tee/optee/optee_rpc_cmd.h @@ -28,24 +28,27 @@ #define OPTEE_RPC_CMD_GET_TIME 3 /* - * Wait queue primitive, helper for secure world to implement a wait queue. + * Notification from/to secure world. * - * If secure world needs to wait for a secure world mutex it issues a sleep - * request instead of spinning in secure world. Conversely is a wakeup - * request issued when a secure world mutex with a thread waiting thread is - * unlocked. + * If secure world needs to wait for something, for instance a mutex, it + * does a notification wait request instead of spinning in secure world. + * Conversely can a synchronous notification can be sent when a secure + * world mutex with a thread waiting thread is unlocked. * - * Waiting on a key - * [in] value[0].a OPTEE_RPC_WAIT_QUEUE_SLEEP - * [in] value[0].b Wait key + * This interface can also be used to wait for a asynchronous notification + * which instead is sent via a non-secure interrupt. * - * Waking up a key - * [in] value[0].a OPTEE_RPC_WAIT_QUEUE_WAKEUP - * [in] value[0].b Wakeup key + * Waiting on notification + * [in] value[0].a OPTEE_RPC_NOTIFICATION_WAIT + * [in] value[0].b notification value + * + * Sending a synchronous notification + * [in] value[0].a OPTEE_RPC_NOTIFICATION_SEND + * [in] value[0].b notification value */ -#define OPTEE_RPC_CMD_WAIT_QUEUE 4 -#define OPTEE_RPC_WAIT_QUEUE_SLEEP 0 -#define OPTEE_RPC_WAIT_QUEUE_WAKEUP 1 +#define OPTEE_RPC_CMD_NOTIFICATION 4 +#define OPTEE_RPC_NOTIFICATION_WAIT 0 +#define OPTEE_RPC_NOTIFICATION_SEND 1 /* * Suspend execution diff --git a/drivers/tee/optee/rpc.c b/drivers/tee/optee/rpc.c index 1849180b0278..e5b931f50db2 100644 --- a/drivers/tee/optee/rpc.c +++ b/drivers/tee/optee/rpc.c @@ -1,6 +1,6 @@ // SPDX-License-Identifier: GPL-2.0-only /* - * Copyright (c) 2015-2016, Linaro Limited + * Copyright (c) 2015-2021, Linaro Limited */ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt @@ -14,23 +14,6 @@ #include "optee_smc.h" #include "optee_rpc_cmd.h" -struct wq_entry { - struct list_head link; - struct completion c; - u32 key; -}; - -void optee_wait_queue_init(struct optee_wait_queue *priv) -{ - mutex_init(&priv->mu); - INIT_LIST_HEAD(&priv->db); -} - -void optee_wait_queue_exit(struct optee_wait_queue *priv) -{ - mutex_destroy(&priv->mu); -} - static void handle_rpc_func_cmd_get_time(struct optee_msg_arg *arg) { struct timespec64 ts; @@ -143,48 +126,6 @@ static void handle_rpc_func_cmd_i2c_transfer(struct tee_context *ctx, } #endif -static struct wq_entry *wq_entry_get(struct optee_wait_queue *wq, u32 key) -{ - struct wq_entry *w; - - mutex_lock(&wq->mu); - - list_for_each_entry(w, &wq->db, link) - if (w->key == key) - goto out; - - w = kmalloc(sizeof(*w), GFP_KERNEL); - if (w) { - init_completion(&w->c); - w->key = key; - list_add_tail(&w->link, &wq->db); - } -out: - mutex_unlock(&wq->mu); - return w; -} - -static void wq_sleep(struct optee_wait_queue *wq, u32 key) -{ - struct wq_entry *w = wq_entry_get(wq, key); - - if (w) { - wait_for_completion(&w->c); - mutex_lock(&wq->mu); - list_del(&w->link); - mutex_unlock(&wq->mu); - kfree(w); - } -} - -static void wq_wakeup(struct optee_wait_queue *wq, u32 key) -{ - struct wq_entry *w = wq_entry_get(wq, key); - - if (w) - complete(&w->c); -} - static void handle_rpc_func_cmd_wq(struct optee *optee, struct optee_msg_arg *arg) { @@ -196,11 +137,13 @@ static void handle_rpc_func_cmd_wq(struct optee *optee, goto bad; switch (arg->params[0].u.value.a) { - case OPTEE_RPC_WAIT_QUEUE_SLEEP: - wq_sleep(&optee->wait_queue, arg->params[0].u.value.b); + case OPTEE_RPC_NOTIFICATION_WAIT: + if (optee_notif_wait(optee, arg->params[0].u.value.b)) + goto bad; break; - case OPTEE_RPC_WAIT_QUEUE_WAKEUP: - wq_wakeup(&optee->wait_queue, arg->params[0].u.value.b); + case OPTEE_RPC_NOTIFICATION_SEND: + if (optee_notif_send(optee, arg->params[0].u.value.b)) + goto bad; break; default: goto bad; @@ -463,7 +406,7 @@ static void handle_rpc_func_cmd(struct tee_context *ctx, struct optee *optee, case OPTEE_RPC_CMD_GET_TIME: handle_rpc_func_cmd_get_time(arg); break; - case OPTEE_RPC_CMD_WAIT_QUEUE: + case OPTEE_RPC_CMD_NOTIFICATION: handle_rpc_func_cmd_wq(optee, arg); break; case OPTEE_RPC_CMD_SUSPEND: From patchwork Fri Jul 23 09:44:22 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jens Wiklander X-Patchwork-Id: 484598 Delivered-To: patches@linaro.org Received: by 2002:a02:c94a:0:0:0:0:0 with SMTP id u10csp1161726jao; Fri, 23 Jul 2021 02:44:37 -0700 (PDT) X-Received: by 2002:a2e:8046:: with SMTP id p6mr2848928ljg.19.1627033477039; Fri, 23 Jul 2021 02:44:37 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1627033477; cv=none; d=google.com; s=arc-20160816; b=eEeZBaB/UTSWSNAZuzRdQPM8TkNcNjn9l7FIOcVeOKM7o1l8Sl9rDMR9jxxmiItSVK soSf8NimCd44jG2M/D5+REbWwT1bOx5vgBlBxUv++i4EcLYhAH/wtmm7uI2pPVvwbCo4 pS9BIdtRYai3l/o1/YkZ2vI0/j+NCvwTNnL1wx8uNwXxerm9w+uUhhYZc8daeaDb1gUo FLaG8dkF9EhHNWF+FnRIAkFFOR2zDw6xcfNGczqQ/mTmCuFhU97tvsvkEZMu4/HvOG25 60pNqxKYYsQUh7haMA+Pvzn+pKmCLXcdcZkjtAh8bqnTJ2yma0YsoiZERNum7WtDDBSZ C6yA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:dkim-signature; bh=8jLggNSpTuehjLQg86NpwxQzrWSywZsK3BANcyj0HLA=; b=hnq7wrLdZaLG++9nZvwJnyhXwUPtTeA5yx+qj3pnG8oJxcmqxkeFZOg4WQUMXa1Cgt rjSTs5d2WXqZzMnFxhq2vmTMOtkTXcahAneBEzk7SpGh2pE2OliwPQUUM6yJPtGlOXp1 Q4SwB+QdsjbifcONa96ny4OXU9dqQPhVmQtu4Bxa6b4BVZog5Kkmtp5J4ceuYqd+QvT1 NJ2LHt0xSY0qxS1Pp10fJvqOekU97bF4BIAVg8HDjHAtcXl8Z9zpCAzYI4Aqey9TFmhR Cj1GNvwssriZVE09psAcQzZZuUUSxm1+9VmufkNJJujMCFwFK/z+PYyOP0MaI6Qv3iuW LxBQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=hcNeJ81F; spf=pass (google.com: domain of jens.wiklander@linaro.org designates 209.85.220.41 as permitted sender) smtp.mailfrom=jens.wiklander@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from mail-sor-f41.google.com (mail-sor-f41.google.com. [209.85.220.41]) by mx.google.com with SMTPS id s3sor2016138lfc.122.2021.07.23.02.44.36 for (Google Transport Security); Fri, 23 Jul 2021 02:44:37 -0700 (PDT) Received-SPF: pass (google.com: domain of jens.wiklander@linaro.org designates 209.85.220.41 as permitted sender) client-ip=209.85.220.41; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=hcNeJ81F; spf=pass (google.com: domain of jens.wiklander@linaro.org designates 209.85.220.41 as permitted sender) smtp.mailfrom=jens.wiklander@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=8jLggNSpTuehjLQg86NpwxQzrWSywZsK3BANcyj0HLA=; b=hcNeJ81FN1eGT1WdQAYJ9ywL/CJhI3RVKcD9GgKXS73XwG62NF5lHV9quB/5Oi16pm SGmoVecEZGcckpIH71mXa0nC6JXdzo3nhOl9XPNI71G4+861TF8jhrZFEuJWuxRrpL7z AxLp4fbnO6M7Ot9S3SQCULgfmwiKfXiBA6ptE7Y4DFLqmyqS2WexNQEQepJPZ0w1qFWX EqtGfbwfzmAU61gvA69m1TsB5L9nD6L30PeA3TBdoxAWJPTgdU6QcGiAtiA+7MqAX9wd yi0Qm0DkTG7utX8Q1UQ6916ozGhVCiRuS+8uG4wOkhyCpC6Cw3TqD3pwpC363Qrk64q+ R9XA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=8jLggNSpTuehjLQg86NpwxQzrWSywZsK3BANcyj0HLA=; b=JKxF9r55AzpeEh9nicsO8aT0cu3Gzou//zb70qeQIPJb1KAE0wK7220U/v7hJolqKH WYiXbsIRMTBnOeEpHRg6ZG1ug7Dy+XkpvFSiHxZ1WKNp33Ui0deJl5Q2D7YgRI9EX7oX QtH4xWIwShrnwzt3cCh6OWVWjKd55Weok7mPl2ep0JX0yX1SddQ00ZuvpPkhqxyLX5Vf D1uewkSFYVys6n2VapU0nVzwcGcuuPcyJptr02dtX8luNRPGAoqjaN8cyhTDV751gKwx kMRQ8sBKRdsNW7dbt+wxjNJ450tvbrkPR71XFEC5G64OVxIAvBCenJ9yAQakrObR7RgT v4Ig== X-Gm-Message-State: AOAM531z68G1SML0oAYrQzc35l4KsO+X4OXFRzFIYIVf8Ml6apCgbaKG qsa0tWNBKGycIezOLMFNnTsr96dy X-Google-Smtp-Source: ABdhPJz6Dy/dyCIcQqGYqSBHd3QK9x+9Zg0oobKPCjAjk1PAXUiOm9lS2cv0C9BViQn9ZY6vRp3vwA== X-Received: by 2002:ac2:5d22:: with SMTP id i2mr2468907lfb.371.1627033476560; Fri, 23 Jul 2021 02:44:36 -0700 (PDT) Return-Path: Received: from jade.urgonet (h-94-254-48-165.A175.priv.bahnhof.se. [94.254.48.165]) by smtp.gmail.com with ESMTPSA id f2sm403808ljq.131.2021.07.23.02.44.35 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 23 Jul 2021 02:44:36 -0700 (PDT) From: Jens Wiklander To: linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, op-tee@lists.trustedfirmware.org, devicetree@vger.kernel.org, linux-doc@vger.kernel.org Cc: Jerome Forissier , Etienne Carriere , Sumit Garg , Vincent Guittot , Rob Herring , Jonathan Corbet , Ard Biesheuvel , Marc Zyngier , Jens Wiklander Subject: [PATCH v3 6/6] optee: add asynchronous notifications Date: Fri, 23 Jul 2021 11:44:22 +0200 Message-Id: <20210723094422.2150313-7-jens.wiklander@linaro.org> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210723094422.2150313-1-jens.wiklander@linaro.org> References: <20210723094422.2150313-1-jens.wiklander@linaro.org> MIME-Version: 1.0 Adds support for asynchronous notifications from secure world to normal world. This allows a design with a top half and bottom half type of driver where the top half runs in secure interrupt context and a notifications tells normal world to schedule a yielding call to do the bottom half processing. The protocol is defined in optee_msg.h optee_rpc_cmd.h and optee_smc.h. A notification consists of a 32-bit value which normal world can retrieve using a fastcall into secure world. The value OPTEE_SMC_ASYNC_NOTIF_VALUE_DO_BOTTOM_HALF (0) has a special meaning. When this value is sent it means that normal world is supposed to make a yielding call OPTEE_MSG_CMD_DO_BOTTOM_HALF. Notification capability is negotiated while the driver is initialized. If both sides supports these notifications then they are enabled. An interrupt is used to notify the driver that there are asynchronous notifications pending. The maximum needed notification value is communicated at this stage. This allows scaling up when needed. Acked-by: Ard Biesheuvel Signed-off-by: Jens Wiklander --- drivers/tee/optee/call.c | 27 ++++++++ drivers/tee/optee/core.c | 82 +++++++++++++++------- drivers/tee/optee/notif.c | 109 ++++++++++++++++++++++++++++-- drivers/tee/optee/optee_msg.h | 9 +++ drivers/tee/optee/optee_private.h | 6 +- drivers/tee/optee/optee_smc.h | 75 +++++++++++++++++++- 6 files changed, 276 insertions(+), 32 deletions(-) -- 2.31.1 diff --git a/drivers/tee/optee/call.c b/drivers/tee/optee/call.c index 6e6eb836e9b6..3afd43b598f9 100644 --- a/drivers/tee/optee/call.c +++ b/drivers/tee/optee/call.c @@ -392,6 +392,33 @@ int optee_cancel_req(struct tee_context *ctx, u32 cancel_id, u32 session) return 0; } +static int simple_call_with_arg(struct tee_context *ctx, u32 cmd) +{ + struct optee_msg_arg *msg_arg; + phys_addr_t msg_parg; + struct tee_shm *shm; + + shm = get_msg_arg(ctx, 0, &msg_arg, &msg_parg); + if (IS_ERR(shm)) + return PTR_ERR(shm); + + msg_arg->cmd = cmd; + optee_do_call_with_arg(ctx, msg_parg); + + tee_shm_free(shm); + return 0; +} + +int optee_do_bottom_half(struct tee_context *ctx) +{ + return simple_call_with_arg(ctx, OPTEE_MSG_CMD_DO_BOTTOM_HALF); +} + +int optee_stop_async_notif(struct tee_context *ctx) +{ + return simple_call_with_arg(ctx, OPTEE_MSG_CMD_STOP_ASYNC_NOTIF); +} + /** * optee_enable_shm_cache() - Enables caching of some shared memory allocation * in OP-TEE diff --git a/drivers/tee/optee/core.c b/drivers/tee/optee/core.c index 2272696ac986..e3c80505cc88 100644 --- a/drivers/tee/optee/core.c +++ b/drivers/tee/optee/core.c @@ -7,9 +7,12 @@ #include #include +#include #include +#include #include #include +#include #include #include #include @@ -353,6 +356,17 @@ static const struct tee_desc optee_supp_desc = { .flags = TEE_DESC_PRIVILEGED, }; +static int enable_async_notif(optee_invoke_fn *invoke_fn) +{ + struct arm_smccc_res res; + + invoke_fn(OPTEE_SMC_ENABLE_ASYNC_NOTIF, 0, 0, 0, 0, 0, 0, 0, &res); + + if (res.a0) + return -EINVAL; + return 0; +} + static bool optee_msg_api_uid_is_optee_api(optee_invoke_fn *invoke_fn) { struct arm_smccc_res res; @@ -402,7 +416,7 @@ static bool optee_msg_api_revision_is_compatible(optee_invoke_fn *invoke_fn) } static bool optee_msg_exchange_capabilities(optee_invoke_fn *invoke_fn, - u32 *sec_caps) + u32 *sec_caps, u32 *max_notif_value) { union { struct arm_smccc_res smccc; @@ -425,6 +439,7 @@ static bool optee_msg_exchange_capabilities(optee_invoke_fn *invoke_fn, return false; *sec_caps = res.result.capabilities; + *max_notif_value = res.result.max_notif_value; return true; } @@ -609,6 +624,7 @@ static int optee_probe(struct platform_device *pdev) struct optee *optee = NULL; void *memremaped_shm = NULL; struct tee_device *teedev; + u32 max_notif_value; u32 sec_caps; int rc; @@ -628,7 +644,8 @@ static int optee_probe(struct platform_device *pdev) return -EINVAL; } - if (!optee_msg_exchange_capabilities(invoke_fn, &sec_caps)) { + if (!optee_msg_exchange_capabilities(invoke_fn, &sec_caps, + &max_notif_value)) { pr_warn("capabilities mismatch\n"); return -EINVAL; } @@ -651,7 +668,7 @@ static int optee_probe(struct platform_device *pdev) optee = kzalloc(sizeof(*optee), GFP_KERNEL); if (!optee) { rc = -ENOMEM; - goto err; + goto err_free_pool; } optee->invoke_fn = invoke_fn; @@ -660,24 +677,24 @@ static int optee_probe(struct platform_device *pdev) teedev = tee_device_alloc(&optee_desc, NULL, pool, optee); if (IS_ERR(teedev)) { rc = PTR_ERR(teedev); - goto err; + goto err_free_optee; } optee->teedev = teedev; teedev = tee_device_alloc(&optee_supp_desc, NULL, pool, optee); if (IS_ERR(teedev)) { rc = PTR_ERR(teedev); - goto err; + goto err_unreg_teedev; } optee->supp_teedev = teedev; rc = tee_device_register(optee->teedev); if (rc) - goto err; + goto err_unreg_supp_teedev; rc = tee_device_register(optee->supp_teedev); if (rc) - goto err; + goto err_unreg_supp_teedev; mutex_init(&optee->call_queue.mutex); INIT_LIST_HEAD(&optee->call_queue.waiters); @@ -687,10 +704,30 @@ static int optee_probe(struct platform_device *pdev) platform_set_drvdata(pdev, optee); - rc = optee_notif_init(optee, 255); - if (rc) { - optee_remove(pdev); - return rc; + if (sec_caps & OPTEE_SMC_SEC_CAP_ASYNC_NOTIF) { + unsigned int irq; + + rc = platform_get_irq(pdev, 0); + if (rc < 0) { + pr_err("platform_get_irq: ret %d\n", rc); + goto err_unreg_supp_teedev; + } + irq = rc; + + rc = optee_notif_init(optee, max_notif_value, irq); + if (rc) { + irq_dispose_mapping(irq); + optee_remove(pdev); + return rc; + } + enable_async_notif(optee->invoke_fn); + pr_info("Asynchronous notifications enabled\n"); + } else { + rc = optee_notif_init(optee, 255, 0); + if (rc) { + optee_remove(pdev); + return rc; + } } optee_enable_shm_cache(optee); @@ -706,20 +743,15 @@ static int optee_probe(struct platform_device *pdev) pr_info("initialized driver\n"); return 0; -err: - if (optee) { - /* - * tee_device_unregister() is safe to call even if the - * devices hasn't been registered with - * tee_device_register() yet. - */ - tee_device_unregister(optee->supp_teedev); - tee_device_unregister(optee->teedev); - kfree(optee); - } - if (pool) - tee_shm_pool_free(pool); - if (memremaped_shm) +err_unreg_supp_teedev: + tee_device_unregister(optee->supp_teedev); +err_unreg_teedev: + tee_device_unregister(optee->teedev); +err_free_optee: + kfree(optee); +err_free_pool: + tee_shm_pool_free(pool); + if (optee->memremaped_shm) memunmap(memremaped_shm); return rc; } diff --git a/drivers/tee/optee/notif.c b/drivers/tee/optee/notif.c index a28fa03dcd0e..ecfa82797695 100644 --- a/drivers/tee/optee/notif.c +++ b/drivers/tee/optee/notif.c @@ -7,10 +7,14 @@ #include #include +#include +#include #include #include #include #include "optee_private.h" +#include "optee_smc.h" +#include "optee_rpc_cmd.h" struct notif_entry { struct list_head link; @@ -18,6 +22,54 @@ struct notif_entry { u_int key; }; +static u32 get_async_notif_value(optee_invoke_fn *invoke_fn, bool *value_valid, + bool *value_pending) +{ + struct arm_smccc_res res; + + invoke_fn(OPTEE_SMC_GET_ASYNC_NOTIF_VALUE, 0, 0, 0, 0, 0, 0, 0, &res); + + if (res.a0) + return 0; + *value_valid = (res.a2 & OPTEE_SMC_ASYNC_NOTIF_VALUE_VALID); + *value_pending = (res.a2 & OPTEE_SMC_ASYNC_NOTIF_VALUE_PENDING); + return res.a1; +} + +static irqreturn_t notif_irq_handler(int irq, void *dev_id) +{ + struct optee *optee = dev_id; + bool do_bottom_half = false; + bool value_valid; + bool value_pending; + u32 value; + + do { + value = get_async_notif_value(optee->invoke_fn, &value_valid, + &value_pending); + if (!value_valid) + break; + + if (value == OPTEE_SMC_ASYNC_NOTIF_VALUE_DO_BOTTOM_HALF) + do_bottom_half = true; + else + optee_notif_send(optee, value); + } while (value_pending); + + if (do_bottom_half) + return IRQ_WAKE_THREAD; + return IRQ_HANDLED; +} + +static irqreturn_t notif_irq_thread_fn(int irq, void *dev_id) +{ + struct optee *optee = dev_id; + + optee_do_bottom_half(optee->notif.ctx); + + return IRQ_HANDLED; +} + static bool have_key(struct optee *optee, u_int key) { struct notif_entry *entry; @@ -106,20 +158,69 @@ int optee_notif_send(struct optee *optee, u_int key) return 0; } -int optee_notif_init(struct optee *optee, u_int max_key) +int optee_notif_init(struct optee *optee, u_int max_key, u_int irq) { + struct tee_context *ctx; + int rc; + + if (irq) { + ctx = tee_dev_open_helper(optee->teedev); + if (IS_ERR(ctx)) + return PTR_ERR(ctx); + + optee->notif.ctx = ctx; + } + spin_lock_init(&optee->notif.lock); INIT_LIST_HEAD(&optee->notif.db); optee->notif.bitmap = bitmap_zalloc(max_key, GFP_KERNEL); - if (!optee->notif.bitmap) - return -ENOMEM; - + if (!optee->notif.bitmap) { + rc = -ENOMEM; + goto err_put_ctx; + } optee->notif.max_key = max_key; + if (irq) { + rc = request_threaded_irq(irq, notif_irq_handler, + notif_irq_thread_fn, + 0, "optee_notification", optee); + if (rc) + goto err_free_bitmap; + + optee->notif.irq = irq; + } + return 0; + +err_free_bitmap: + kfree(optee->notif.bitmap); +err_put_ctx: + tee_dev_ctx_put(optee->notif.ctx); + optee->notif.ctx = NULL; + + return rc; } void optee_notif_uninit(struct optee *optee) { + if (optee->notif.ctx) { + optee_stop_async_notif(optee->notif.ctx); + if (optee->notif.irq) { + free_irq(optee->notif.irq, optee); + irq_dispose_mapping(optee->notif.irq); + } + + /* + * The thread normally working with optee->notif.ctx was + * stopped with free_irq() above. + * + * Note we're not using teedev_close_context() or + * tee_client_close_context() since we have already called + * tee_device_put() while initializing to avoid a circular + * reference counting. + */ + tee_dev_ctx_put(optee->notif.ctx); + } + kfree(optee->notif.bitmap); } diff --git a/drivers/tee/optee/optee_msg.h b/drivers/tee/optee/optee_msg.h index e3d72d09c484..3e09c8386e46 100644 --- a/drivers/tee/optee/optee_msg.h +++ b/drivers/tee/optee/optee_msg.h @@ -293,6 +293,13 @@ struct optee_msg_arg { * [in] param[0].u.rmem.shm_ref holds shared memory reference * [in] param[0].u.rmem.offs 0 * [in] param[0].u.rmem.size 0 + * + * OPTEE_MSG_CMD_DO_BOTTOM_HALF does the scheduled bottom half processing + * of a driver. + * + * OPTEE_MSG_CMD_STOP_ASYNC_NOTIF informs secure world that from now is + * normal world unable to process asynchronous notifications. Typically + * used when the driver is shut down. */ #define OPTEE_MSG_CMD_OPEN_SESSION 0 #define OPTEE_MSG_CMD_INVOKE_COMMAND 1 @@ -300,6 +307,8 @@ struct optee_msg_arg { #define OPTEE_MSG_CMD_CANCEL 3 #define OPTEE_MSG_CMD_REGISTER_SHM 4 #define OPTEE_MSG_CMD_UNREGISTER_SHM 5 +#define OPTEE_MSG_CMD_DO_BOTTOM_HALF 6 +#define OPTEE_MSG_CMD_STOP_ASYNC_NOTIF 7 #define OPTEE_MSG_FUNCID_CALL_WITH_ARG 0x0004 #endif /* _OPTEE_MSG_H */ diff --git a/drivers/tee/optee/optee_private.h b/drivers/tee/optee/optee_private.h index 7dc058d008b2..62365912a70b 100644 --- a/drivers/tee/optee/optee_private.h +++ b/drivers/tee/optee/optee_private.h @@ -37,6 +37,8 @@ struct optee_call_queue { struct optee_notif { u_int max_key; + unsigned int irq; + struct tee_context *ctx; /* Serializes access to the elements below in this struct */ spinlock_t lock; struct list_head db; @@ -132,7 +134,7 @@ void optee_handle_rpc(struct tee_context *ctx, struct optee_rpc_param *param, struct optee_call_ctx *call_ctx); void optee_rpc_finalize_call(struct optee_call_ctx *call_ctx); -int optee_notif_init(struct optee *optee, u_int max_key); +int optee_notif_init(struct optee *optee, u_int max_key, u_int irq); void optee_notif_uninit(struct optee *optee); int optee_notif_wait(struct optee *optee, u_int key); int optee_notif_send(struct optee *optee, u_int key); @@ -159,6 +161,8 @@ int optee_close_session(struct tee_context *ctx, u32 session); int optee_invoke_func(struct tee_context *ctx, struct tee_ioctl_invoke_arg *arg, struct tee_param *param); int optee_cancel_req(struct tee_context *ctx, u32 cancel_id, u32 session); +int optee_do_bottom_half(struct tee_context *ctx); +int optee_stop_async_notif(struct tee_context *ctx); void optee_enable_shm_cache(struct optee *optee); void optee_disable_shm_cache(struct optee *optee); diff --git a/drivers/tee/optee/optee_smc.h b/drivers/tee/optee/optee_smc.h index 80eb763a8a80..c6eec6b6febf 100644 --- a/drivers/tee/optee/optee_smc.h +++ b/drivers/tee/optee/optee_smc.h @@ -107,6 +107,12 @@ struct optee_smc_call_get_os_revision_result { /* * Call with struct optee_msg_arg as argument * + * When calling this function normal world has a few responsibilities: + * 1. It must be able to handle eventual RPCs + * 2. Non-secure interrupts should not be masked + * 3. If asynchronous notifications has be negotiated successfully, then + * asynchronous notifications should be unmasked during this call. + * * Call register usage: * a0 SMC Function ID, OPTEE_SMC*CALL_WITH_ARG * a1 Upper 32 bits of a 64-bit physical pointer to a struct optee_msg_arg @@ -195,7 +201,8 @@ struct optee_smc_get_shm_config_result { * Normal return register usage: * a0 OPTEE_SMC_RETURN_OK * a1 bitfield of secure world capabilities OPTEE_SMC_SEC_CAP_* - * a2-7 Preserved + * a2 The maximum secure world notification number + * a3-7 Preserved * * Error return register usage: * a0 OPTEE_SMC_RETURN_ENOTAVAIL, can't use the capabilities from normal world @@ -218,6 +225,8 @@ struct optee_smc_get_shm_config_result { #define OPTEE_SMC_SEC_CAP_VIRTUALIZATION BIT(3) /* Secure world supports Shared Memory with a NULL reference */ #define OPTEE_SMC_SEC_CAP_MEMREF_NULL BIT(4) +/* Secure world supports asynchronous notification of normal world */ +#define OPTEE_SMC_SEC_CAP_ASYNC_NOTIF BIT(5) #define OPTEE_SMC_FUNCID_EXCHANGE_CAPABILITIES 9 #define OPTEE_SMC_EXCHANGE_CAPABILITIES \ @@ -226,8 +235,8 @@ struct optee_smc_get_shm_config_result { struct optee_smc_exchange_capabilities_result { unsigned long status; unsigned long capabilities; + unsigned long max_notif_value; unsigned long reserved0; - unsigned long reserved1; }; /* @@ -319,6 +328,68 @@ struct optee_smc_disable_shm_cache_result { #define OPTEE_SMC_GET_THREAD_COUNT \ OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_GET_THREAD_COUNT) +/* + * Inform OP-TEE that normal world is able to receive asynchronous + * notifications. + * + * Call requests usage: + * a0 SMC Function ID, OPTEE_SMC_ENABLE_ASYNC_NOTIF + * a1-6 Not used + * a7 Hypervisor Client ID register + * + * Normal return register usage: + * a0 OPTEE_SMC_RETURN_OK + * a1-7 Preserved + * + * Not supported return register usage: + * a0 OPTEE_SMC_RETURN_ENOTAVAIL + * a1-7 Preserved + */ +#define OPTEE_SMC_FUNCID_ENABLE_ASYNC_NOTIF 16 +#define OPTEE_SMC_ENABLE_ASYNC_NOTIF \ + OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_ENABLE_ASYNC_NOTIF) + +/* + * Retrieve a value of notifications pended since the last call of this + * function. + * + * OP-TEE keeps a records of all posted values. When an interrupts is + * received which indicates that there are posed values this function + * should be called until all pended values has been retrieved. When a + * value is retrieved it's cleared from the record in secure world. + * + * Call requests usage: + * a0 SMC Function ID, OPTEE_SMC_GET_ASYNC_NOTIF_VALUE + * a1-6 Not used + * a7 Hypervisor Client ID register + * + * Normal return register usage: + * a0 OPTEE_SMC_RETURN_OK + * a1 value + * a2 Bit[0]: OPTEE_SMC_ASYNC_NOTIF_VALUE_VALID if the value in a1 is + * valid, else 0 if no values where pending + * a2 Bit[1]: OPTEE_SMC_ASYNC_NOTIF_VALUE_PENDING if another value is + * pending, else 0. + * Bit[31:2]: MBZ + * a3-7 Preserved + * + * Not supported return register usage: + * a0 OPTEE_SMC_RETURN_ENOTAVAIL + * a1-7 Preserved + */ +#define OPTEE_SMC_ASYNC_NOTIF_VALUE_VALID BIT(0) +#define OPTEE_SMC_ASYNC_NOTIF_VALUE_PENDING BIT(1) + +/* + * Notification that OP-TEE expects a yielding call to do some bottom half + * work in a driver. + */ +#define OPTEE_SMC_ASYNC_NOTIF_VALUE_DO_BOTTOM_HALF 0 + +#define OPTEE_SMC_FUNCID_GET_ASYNC_NOTIF_VALUE 17 +#define OPTEE_SMC_GET_ASYNC_NOTIF_VALUE \ + OPTEE_SMC_FAST_CALL_VAL(OPTEE_SMC_FUNCID_GET_ASYNC_NOTIF_VALUE) + /* * Resume from RPC (for example after processing a foreign interrupt) *