From patchwork Wed Jun 16 10:36:43 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jens Wiklander X-Patchwork-Id: 461385 Delivered-To: patches@linaro.org Received: by 2002:a02:735a:0:0:0:0:0 with SMTP id a26csp487118jae; Wed, 16 Jun 2021 03:37:10 -0700 (PDT) X-Received: by 2002:ac2:5d69:: with SMTP id h9mr3046461lft.603.1623839830808; Wed, 16 Jun 2021 03:37:10 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1623839830; cv=none; d=google.com; s=arc-20160816; b=GiJX7Ua+ByD0YM9eeQXRAdQ89RM5/kMkwc/PUtv5oRX6IGHO2r9qLx2z73PVG4bb58 Uc3e1W6RIqDOAYhqK1fD6qcppKC0KpnaLr0lyH7MmH3B+z4WYmlGPaNC80rde+mGnHlp nH2lhYq8DeCAcD+CElwji1mXAybSv1g6TElIeOhwujrY2KQdxuws4L2vMU+1T9uv/REK ayQej+n5JYQqgDalKd67LS0nnHyo25KbUSeo/5kwEiOw6YbIrZS71D+yurswEUyev/lo Fou1yFHfvYLlSMXNt5bq6ImK87Wsomirc2IIM0t++LUnjrjL+ZHMhCgLWsaJlQeUn6Ff qMUQ== 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=tDnEYkiUQYy+54S27ZN5C7AsAUr3hb3el7+oB1Z0KbLz6Jz9GBGMTzWNk0hLKdldm+ m2t+ldlm9jN0VXUkrHid9sGFAfPxTWMJk830YnTlUE3eLteGamU/axmQ0fhq6N/hN0EW sIWFytAYgN5HuK2Ff3RoUnkM4QAIiVs6VhyaEI1k1AUba/mksYOBCCiufugItDgn5Ure KOEeuX96H9IDMPmb7WBtBQMlmVQiG+TPPUifeKtVgdaPeAN0hQ7ufeid2TU18ubC/QQ3 iAs/6kKpjgLzslztrxSshf+krcWUtHmB76cd3uThcqZGE91USduQRiWiYHjWVGvp4k1e xX4A== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=Wu0BlJMG; 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 i3sor799814lji.70.2021.06.16.03.37.10 for (Google Transport Security); Wed, 16 Jun 2021 03:37:10 -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=Wu0BlJMG; 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=Wu0BlJMGLIrf/wOevRIS+XR+4dQDCMwD8EDfGBMUGP9eS4FoIpWnzRXM1+nWTx/PpE zToRutj8hVoI0s2/HTDsJbO4QPRiQw7Yorz6tX63dgDzXwiKiqqilSNNMbMbI3v7GIL+ tdA2noUiH+fRxWUksAcFbOfRxQu+zO4B3uIfdND97u00fe4zT6R5E1c4iYEhrjRIZbP5 Ou2w5IOhBBxFnuwUqANSnElUDnjy3dZkBJPQJ8qk32ysCSkFhOvYi3MnfhyNnyBXB3Kj lkYkpOfFxOyT+YgKH03rlUjQH5qZd4DNdQVdIeK5Kt64i6oq0XQKdxnyC9O1/vkH+JxH B3Rg== 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=BRHZNmLGMNtfvJWbcqs7pu6AEFk7U3uH4lqwKA5XLJxr9CxbOpVrog3zFFM1py1mnc ye8yhw+LOQ47LGG63r+78CZZBdPMuYGNCAQ8tOuNUYKt5CGhU3RqE22G8bc4FL61EcNH Vpji3apL/A3wRc4kUObjz9jUsJ3ZMFaqHCtozI6GmJ+Yn/YMI+mTTag+3aipTBvUKnO6 fIRoF6FsTsmh0GB4REO4MG/Fc+3QWovkSP5k0VlqnrNJroUaQndR3vxo/rEZgAJ8lcZG Z/16urI0Lh3O5eOPAAleKs1UTRjgMo1hLTDSmrRxLj2TN5UOI1yxE8WfsiWQrqy2xdcU IpGw== X-Gm-Message-State: AOAM532TxeVKvhqVu67Q0HKdfhfWA1QE6DJzN8YazH6+Sils81gclstm OfBeQo9foizKf0mVQwUmVqD1uZoN X-Google-Smtp-Source: ABdhPJxUQQnMedGG2WIOuUWHj2MtSIPkky3Mq4+PSdmzlf6IblLKi4pAsrlJngyW2WCidlJrTITXsA== X-Received: by 2002:a2e:a314:: with SMTP id l20mr3865559lje.361.1623839830434; Wed, 16 Jun 2021 03:37:10 -0700 (PDT) Return-Path: Received: from jade.urgonet (h-79-136-85-3.A175.priv.bahnhof.se. [79.136.85.3]) by smtp.gmail.com with ESMTPSA id m17sm205621lfh.288.2021.06.16.03.37.09 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 16 Jun 2021 03:37:10 -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 v2 1/7] docs: staging/tee.rst: add a section on OP-TEE notifications Date: Wed, 16 Jun 2021 12:36:43 +0200 Message-Id: <20210616103649.2662395-2-jens.wiklander@linaro.org> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210616103649.2662395-1-jens.wiklander@linaro.org> References: <20210616103649.2662395-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 Wed Jun 16 10:36:44 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jens Wiklander X-Patchwork-Id: 461386 Delivered-To: patches@linaro.org Received: by 2002:a02:735a:0:0:0:0:0 with SMTP id a26csp487129jae; Wed, 16 Jun 2021 03:37:11 -0700 (PDT) X-Received: by 2002:ac2:5084:: with SMTP id f4mr3224407lfm.466.1623839831622; Wed, 16 Jun 2021 03:37:11 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1623839831; cv=none; d=google.com; s=arc-20160816; b=oFq+zdLL9dcNqrQXPO09tR3DGsBjz5F43XcXZD/9QdH62Xfmd/Wc0q5vsP2JM6g5i4 JrnAX3+RPc3kc0VFjb3bsfnpf65lQS8fkfwS0THHFt13eGwgGRcfQp3W1FELSUDqLcpd s/L2uLSZTtTiqoOg2Iij/Zv017J2BlJOftJJoMdNAUUZxeBKZW055vfafHoXirvRU0wR 9ibWAK7lcBsyRSOF7HCXHY67QX8M5TlJZq8igYUTeBo+LnQwgzEH3QqnI8YWr7UaZ2yg aGai/i34yiNXhWBmhz4jzVM0CFKQrAHnvoGGop43VpyChW8hFC4xNkRDCPyU4jGZPOhC mcyQ== 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=Umz7aYzmYhwqEEP8hnC/zZgdzJV3Msj9S6v5a9aoDDg=; b=lnwZGJfFfGhIUDGHxyVimI4PME0YEvUpQQGcbZ6pYzdcm93wU+P9kHT12F7NjUU5TO nY8mDN5ADAm8MlJzfbWfu8E/gFLJjxWyRmVwTwEpJr+8+wdFsK0tMhc3Vo9rMHF7N4/8 S38OKZMWJiGZNxy8RNpbEzhyNplQ1notFSjs7Ujl+IUCLqI0xaXzxwSxNlXt1K2atyaC VkDqkHVALt3jDBZXjHOA7DrVX/dHs8gJjI9aWpnP8Z4i6Ld32//9uCXVsHSL8ZL9hyHw hd1RdiNebL/bJ3/TszH0CetlIfMNL/2teaM9D7tOwkHleJ+5pKtiPfLeSSJv+lck9tJ5 MpjQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=VwI8KJq4; 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 j11sor390497lfu.114.2021.06.16.03.37.11 for (Google Transport Security); Wed, 16 Jun 2021 03:37:11 -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=VwI8KJq4; 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=Umz7aYzmYhwqEEP8hnC/zZgdzJV3Msj9S6v5a9aoDDg=; b=VwI8KJq4r2miZYI4zo45kPqtcT9PQcZDZi7EgbrJ/dLYSxlekJGyMM3Oti5eB4RYqm ZHkdL8OBpSXPl+meGhQlfIMnqqcHTC7yVre4XK0+jTOmwGE/KtfDIgl7kl62+7B4whGc Gozv6cVsNkCcosBjkQinf1GZ6gacq4m5oZMs0IWWETLe1TonQXVhWz5yyAHMfW3hfmvD mEBFhdd6wX5G+dpX66LrSBBCjLIn+NxD8bmZB4zYM8YZd1n5rXzg+fbgOKRuTh2HehVz GnBbVrUoOm04x49Zk3S+rFgnps7nAsgsnzlXkCAcEBwRzSQsdEIJA9BIDfERUhaqiNMp J+EA== 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=Umz7aYzmYhwqEEP8hnC/zZgdzJV3Msj9S6v5a9aoDDg=; b=Bq7U1TO7yQ4fT6UTskAGTmiM0RAB1kqq/UgP2CkNReOjsmpYjCsFgfU7nMzstJtrYY 6Dmn4djI0eddHMfkyVxcnKk1L+I+8hn1sf6Hl0+IHmaLzaGD8u44H+NUCEuTLvecTG/G n8qjH81TyzFHzPHWrCr6zwSn8SgRAfq8RmmnwEOfAxS+9fdh8YPkkDot358DV02QrExk 6dWTYkfjMdSLwPNUx2FOCLaK7ILIL+v+2e73eFdQrqmnl8ZcUmwLE23h2kEDKnvcnbpd JErBqH++jdwY6F9wfkI7xr+M8i02tgjiMs3e2Kxb8kyoLVuga/6kKPBSLgwgVL/o44ln UiIg== X-Gm-Message-State: AOAM533060lusL9oD2SOC9im2e0rivOb3RiO1zR7MkFjoqcg37iJH560 W9ro2tAuRLd7/g7f/jiJuHztOyWF X-Google-Smtp-Source: ABdhPJwusF0Hwl0KFVC3f7/9aSUBQG2V+qpIxjgLKtQ37eXDUOU8OQTd23w0a+s/4F+jqEb90knm+g== X-Received: by 2002:a05:6512:344e:: with SMTP id j14mr3261852lfr.468.1623839831236; Wed, 16 Jun 2021 03:37:11 -0700 (PDT) Return-Path: Received: from jade.urgonet (h-79-136-85-3.A175.priv.bahnhof.se. [79.136.85.3]) by smtp.gmail.com with ESMTPSA id m17sm205621lfh.288.2021.06.16.03.37.10 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 16 Jun 2021 03:37:11 -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 v2 2/7] dt-bindings: arm: Convert optee binding to json-schema Date: Wed, 16 Jun 2021 12:36:44 +0200 Message-Id: <20210616103649.2662395-3-jens.wiklander@linaro.org> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210616103649.2662395-1-jens.wiklander@linaro.org> References: <20210616103649.2662395-1-jens.wiklander@linaro.org> MIME-Version: 1.0 Converts the optee binding to use DT schema format. Signed-off-by: Jens Wiklander --- .../bindings/arm/firmware/linaro,optee-tz.txt | 31 ------------ .../arm/firmware/linaro,optee-tz.yaml | 49 +++++++++++++++++++ 2 files changed, 49 insertions(+), 31 deletions(-) delete mode 100644 Documentation/devicetree/bindings/arm/firmware/linaro,optee-tz.txt create mode 100644 Documentation/devicetree/bindings/arm/firmware/linaro,optee-tz.yaml -- 2.31.1 diff --git a/Documentation/devicetree/bindings/arm/firmware/linaro,optee-tz.txt b/Documentation/devicetree/bindings/arm/firmware/linaro,optee-tz.txt deleted file mode 100644 index d38834c67dff..000000000000 --- a/Documentation/devicetree/bindings/arm/firmware/linaro,optee-tz.txt +++ /dev/null @@ -1,31 +0,0 @@ -OP-TEE Device Tree Bindings - -OP-TEE is a piece of software using hardware features to provide a Trusted -Execution Environment. The security can be provided with ARM TrustZone, but -also by virtualization or a separate chip. - -We're using "linaro" as the first part of the compatible property for -the reference implementation maintained by Linaro. - -* OP-TEE based on ARM TrustZone required properties: - -- compatible : should contain "linaro,optee-tz" - -- method : The method of calling the OP-TEE Trusted OS. Permitted - values are: - - "smc" : SMC #0, with the register assignments specified - in drivers/tee/optee/optee_smc.h - - "hvc" : HVC #0, with the register assignments specified - in drivers/tee/optee/optee_smc.h - - - -Example: - firmware { - optee { - compatible = "linaro,optee-tz"; - method = "smc"; - }; - }; diff --git a/Documentation/devicetree/bindings/arm/firmware/linaro,optee-tz.yaml b/Documentation/devicetree/bindings/arm/firmware/linaro,optee-tz.yaml new file mode 100644 index 000000000000..c931b030057f --- /dev/null +++ b/Documentation/devicetree/bindings/arm/firmware/linaro,optee-tz.yaml @@ -0,0 +1,49 @@ +# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/arm/firmware/linaro,optee-tz.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: OP-TEE Device Tree Bindings + +maintainers: + - Jens Wiklander + +description: | + OP-TEE is a piece of software using hardware features to provide a Trusted + Execution Environment. The security can be provided with ARM TrustZone, but + also by virtualization or a separate chip. + +properties: + $nodename: + const: optee + compatible: + oneOf: + - description: + We're using "linaro" as the first part of the compatible property + for the reference implementation maintained by Linaro. + const: linaro,optee-tz + + method: + description: The method of calling the OP-TEE Trusted OS. + $ref: /schemas/types.yaml#/definitions/string-array + oneOf: + - description: | + SMC #0, with the register assignments specified in + in drivers/tee/optee/optee_smc.h + const: smc + - description: | + HVC #0, with the register assignments specified in + in drivers/tee/optee/optee_smc.h + const: hvc + +additionalProperties: false + +examples: + - | + firmware { + optee { + compatible = "linaro,optee-tz"; + method = "smc"; + }; + }; From patchwork Wed Jun 16 10:36:45 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jens Wiklander X-Patchwork-Id: 461387 Delivered-To: patches@linaro.org Received: by 2002:a02:735a:0:0:0:0:0 with SMTP id a26csp487143jae; Wed, 16 Jun 2021 03:37:13 -0700 (PDT) X-Received: by 2002:a05:6512:507:: with SMTP id o7mr3286127lfb.453.1623839832808; Wed, 16 Jun 2021 03:37:12 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1623839832; cv=none; d=google.com; s=arc-20160816; b=SuhFB22IZesYr06g+pdmZ0uV2uIbZJumZc1+1tryK/yfuWM0c3N8OnyZ6tqljGS6AF badrzDEAX5gN3j84zjg+J7mZQFZ9TUr+sxn9CluOC6cqObzX4JMJMnYPFbGgq3XUkgJR m7kE6CgfXFfOV76Dwk3+wtoJKMbSuiViOfb634yRa0IRCjGxdc3Vzih80JoK2LQH771f oO1LOEIvBthtA1LvsKBpi6/9itrRFLIVdfWk7F7bdRZhR/KhQ8MZZRci+D8TDLghyEGy +XBwaCCeXpq6qDLo2XzovzYKUuA7dN28qk2YXjNrwGbzrogaMHzyaYv7vJZ/hA1zmAYe mowg== 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=K9rTCswFDcSx/xadpaa8S03K2mvlJRdx5LDwjr8plho=; b=yiHUdAu007Ps6UYMI7p1CKSAz/2jqNXf3cYBiQ7hyngvXY8H2nW8Tx1yBxQ9cIuDjm fFpWVnseQiXlDElxh+OtEAxx4+LETcR7qHPdJS1uPYwv96axGLLNG8w4pyqmJJG8DF2v /oveGFOL6Oelvp1H0fgo/lFxK/EhL/DXoE6q3Fx39FvqFuxQD8l4Jiobdke+eBpmpIcy huCBQ2kLb06tjrrBL0yu+aNqRCuiZ6Mpk/H/Iq4sfv8hp++bIMg+TBG+FbJQBwMLVkXu pzB4zcxhPz7nlEssZ0w78DC3jxbuKkT6hztSXwG3PAqxH8WLwxN22qVZPyyXjKGIMjP4 Ah3g== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=I5t43eIZ; 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 c7sor369664lft.6.2021.06.16.03.37.12 for (Google Transport Security); Wed, 16 Jun 2021 03:37:12 -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=I5t43eIZ; 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=K9rTCswFDcSx/xadpaa8S03K2mvlJRdx5LDwjr8plho=; b=I5t43eIZCnjyPa+pKdyMqKnMr/EQajUpEvuogScKNI+ErMEJmin3AHBzvsqi3F7Ved 49qQwy0hURavSmoJCaIwZ8dVmjdLqfsi2jRYXP+/C8l5fy09a/kHDWT7UE11u5sLMj8C h0GQzuVeB4zGiuGdGPjZHgvzy28JGggJE+s7yMliKSGCW/h09IjRdygF5eVc7n66S4xH Z9kbx6w+CsSJx2cbAL+nCv0c0V8djUMkZfwg4IdiHJoNQ4YW8Uz0dXDx5qE1p5n1tHCa 66Oc3U2PfmFdFTGUVZdSzhc/W7suK+3/79px/ibN3lyI2Z5eo5mEdoU/d6O+U/z9FuIM O2Yw== 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=K9rTCswFDcSx/xadpaa8S03K2mvlJRdx5LDwjr8plho=; b=Jt3BzCQsof0qHn01SMhsTTMscK7oT6xsbh/pdW+e1B/tsD1if5vgrZ6j6mQA4Pxu1w 0xjLb/3Khr58p96t/lDQfZNDveklE7P+zJIPRpIqA4u3B2IRvUq0UNejZvXM1SrN0WJS EkEqYD24sGFNXoesPnRbndumrDYyfju5WWJ9razUEaQO0NTLun913JnrZBGHtnxOVab3 AdR5AsnTwUrjXSXsCKc5HMrci0UMFsdhMEN6tSYdGLuLwVXSre5KP3yjQVTpCl8tBPz5 O62JOAoxRRV6+UWpuwup01KsCa5loQqbRmkzVsJLOYyp6bLUh9RcKS8r/JobAuOZ6QZL VlkQ== X-Gm-Message-State: AOAM530i0ChOZtPpWTBZdDXxEg2tpCoUGsfMJCwXpJxQozMEeYxqusUn Rt+SljYUwS8+vq4pJ/Z+WejPxYNP X-Google-Smtp-Source: ABdhPJyRRh0Pb8kvyCXq/Lr9lQOLxI0JWINcPh9CvxE5rvjcyHijONeFGS2Ue+Juc03F1Wjspl6pIw== X-Received: by 2002:ac2:4c0e:: with SMTP id t14mr3228126lfq.555.1623839832447; Wed, 16 Jun 2021 03:37:12 -0700 (PDT) Return-Path: Received: from jade.urgonet (h-79-136-85-3.A175.priv.bahnhof.se. [79.136.85.3]) by smtp.gmail.com with ESMTPSA id m17sm205621lfh.288.2021.06.16.03.37.11 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 16 Jun 2021 03:37:12 -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 v2 3/7] dt-bindings: arm: optee: add interrupt property Date: Wed, 16 Jun 2021 12:36:45 +0200 Message-Id: <20210616103649.2662395-4-jens.wiklander@linaro.org> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210616103649.2662395-1-jens.wiklander@linaro.org> References: <20210616103649.2662395-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 | 8 ++++++++ 1 file changed, 8 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 c931b030057f..3efbe11b637d 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: for the reference implementation maintained by Linaro. const: linaro,optee-tz + interrupts: + maxItems: 1 + method: description: The method of calling the OP-TEE Trusted OS. $ref: /schemas/types.yaml#/definitions/string-array @@ -37,6 +40,10 @@ properties: in drivers/tee/optee/optee_smc.h const: hvc +required: + - compatible + - method + additionalProperties: false examples: @@ -45,5 +52,6 @@ examples: optee { compatible = "linaro,optee-tz"; method = "smc"; + interrupts = <0 187 4>; }; }; From patchwork Wed Jun 16 10:36:46 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jens Wiklander X-Patchwork-Id: 461388 Delivered-To: patches@linaro.org Received: by 2002:a02:735a:0:0:0:0:0 with SMTP id a26csp487158jae; Wed, 16 Jun 2021 03:37:13 -0700 (PDT) X-Received: by 2002:ac2:5396:: with SMTP id g22mr3238486lfh.84.1623839833559; Wed, 16 Jun 2021 03:37:13 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1623839833; cv=none; d=google.com; s=arc-20160816; b=X8OChfW8AYUAi1DVzpF8yTZpKyvNkqY7p6sgxD0OGGSb2DHscLs5F+0xQrqLirir1t hcKELbS5L3LX94jl7ETskmsonx0g6nB3fZsEkScoispL7D9U3scJHANc6NEC0h6UQHh/ uKYaKlfhGg6RtLK0mjScYIrlckeZqL+JtwJunThBaYW7hsp9lOOdBB6ZwMKFtjH+KzoL tjSP3UrvzyyIWn6upOE8XzeYQ1qT8rNJxXON8yjju5gt8+y5M9D1FMKDrOoYSqvZdT9T fit227ps5+GfdoQ541B2jNx6pZxKFCWxpw0Vrh1CPGByNR/JA9lV6NnYvggISA4Yjmnr I53Q== 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=/f1rY0k6EQWoltoVI239rx9YFVi0YDoyX+ARCpEzBL8=; b=OvWoYFROxmNgyHmyAIM4cO2ReFWevFmUtj7nI8JOSEnPd2tcHMF4iCGmhotoo6KVzY yptO6Un9LcvBo2zgRPOTgnjDRxJAGE+eiW380M7vwa26RiENvQIHzfES7C/NgEWKK7fo ewX+LG4MSKeMn/lVDBOpH85QUf2WPhMaJfTNz+XEPszzUsyPB1HxtY6HuVqUt6hrV7tp jo5+gkYB3IRI0v4KAowKxoiDFnPorhg6J2aMgJmzL/51rYLLk2AFthWNRpS2r8Mt+R/A u/PdmM1tZsaIOnyJtElWJuUHDGvPhAWL+weIhHfo2serNcJBVu3YpVuL7O2b8UOKpZIc ZNog== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=llG26ISb; 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 q11sor383854lfk.84.2021.06.16.03.37.13 for (Google Transport Security); Wed, 16 Jun 2021 03:37:13 -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=llG26ISb; 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=/f1rY0k6EQWoltoVI239rx9YFVi0YDoyX+ARCpEzBL8=; b=llG26ISbSHMQx9SAWWK0Ew5GahaWNLFUKYF3eJzC4p33bRd9Be60A93cKFvJyK4UOz zPO06ptAc1p3sQr86nkEQV8CU+83twF95m4ySOp2qgCoovEzCa6CV7PO8ZkWDLhgPps1 A+GHdG9jn2/J9PtUYjwcKSxCrFrp6ThpBnl0N9E2qlo00n53XZvUbugI9hIpCRlDBDg7 12rNUWk/l1v9+geVlXECny1yce1nLA1zjK/tyvFZ/dspVr+VBcfQmO7KIxe/fc/iVTeq 672zro9XoKRvv8/Q6nwkbWoNctEryLJwZW+t5S1qaS/IzciywYhp/zMpyQ4aduoFdfbc VQJw== 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=/f1rY0k6EQWoltoVI239rx9YFVi0YDoyX+ARCpEzBL8=; b=hW+foAxllyk3zsS5OU9GldYykC6RaTMxVM4OD5o3CrYAzwPKqPImgs6nVv6mQa7sRb T+u/1ZhYr2QEts+2uaPZ1QOg6sD/whEEJgtJtUkFKaj79XhGgpNygMFlprsa2Pb4Ar2/ 1mmZP+q1KxWEYNKG5w4+Aw9nkKUSh0qCivyfgsQk/OUVwy7onX1uWuUQWS44iu+PCEXG EUygrhGAfQAS5bLaY8Hi6tNzUnBi0XdZinXrcoeVE7DSOYNVsVfmhul/fJdHVEcL3rr3 Oa4QHRaQRhGBJlLUm4LcGq5hka/CLew4DK+CsV5BT/a60K9iVTgaOxHT0dYBgY+B4NpT h25A== X-Gm-Message-State: AOAM532lgneT1yoN6Od7Cg+eV4CBOBvgxGfQjxiayn6ubeXehmnh3uDK v9MRxXOy1QRle8IALgWfzRQWuJa5 X-Google-Smtp-Source: ABdhPJysfxzlZ2ZCBCeU6Y2xQDldKhQEt20KJ5s961GMZJdmsWDBpqHYUiF3UpWheyplkOkqFfgg8Q== X-Received: by 2002:a19:550f:: with SMTP id n15mr3209225lfe.660.1623839833192; Wed, 16 Jun 2021 03:37:13 -0700 (PDT) Return-Path: Received: from jade.urgonet (h-79-136-85-3.A175.priv.bahnhof.se. [79.136.85.3]) by smtp.gmail.com with ESMTPSA id m17sm205621lfh.288.2021.06.16.03.37.12 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 16 Jun 2021 03:37:12 -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 v2 4/7] tee: fix put order in teedev_close_context() Date: Wed, 16 Jun 2021 12:36:46 +0200 Message-Id: <20210616103649.2662395-5-jens.wiklander@linaro.org> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210616103649.2662395-1-jens.wiklander@linaro.org> References: <20210616103649.2662395-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 480d294a23ab..f97d95b50773 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 Wed Jun 16 10:36:47 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jens Wiklander X-Patchwork-Id: 461389 Delivered-To: patches@linaro.org Received: by 2002:a02:735a:0:0:0:0:0 with SMTP id a26csp487169jae; Wed, 16 Jun 2021 03:37:14 -0700 (PDT) X-Received: by 2002:a2e:8816:: with SMTP id x22mr3901661ljh.181.1623839834322; Wed, 16 Jun 2021 03:37:14 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1623839834; cv=none; d=google.com; s=arc-20160816; b=OlT5UZ0rzv7+QEslsCl79o38H8cuV9KCxX+iL/JR/eItZ+f4Jc8uSu80ugrvuPFZUD +AwfJIGusUT9B7Qhi2X/KffEUUoBTPFeXclb8ffiAQMnsUgIb0hWA8P2LuVQn5avvVzc tgB3mJ1D46ljVtt4qsksw+krCtUOjt56xdpDluIU3bp542BsGFCKqYqubs/eP5V4Vb8X qwY2CJTXvuODop8nETl5iwfowzBcO+rKsaVlUC5SXUO99OwHhY3rODSekJabGgFhf1cX oFJ4mVz0oaWMvoLp/s4rq2ZCnDAVUvbI30SSNXBaAS8SuQFYnbOvdBPslWghQgRXPhZP oTZw== 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=nE0O5cQU8hO3PBDLKhrY8XOB0KUsBuVPprzerF6bl2k=; b=O8oK0toEAtknfj/Dhtwoq/qY6hOJm72lB2oPBKVRYWHG/hBJZWos4FPDFa3mR40FPt Ry5hBLixVwg57NnIlaPqeaDbghmKuzsuNT7F3JWghzJ5pxYldypmS2CyC6uTeNYcjh1c dZY/56tiWO2ZnM6rXsEXRrHC7sSuT07graSxJ+iMlg/rfoyJVfQUpd02NKA8AYJmTXT/ CNeifw1Gzu07YjtsFPm297mRAW6oT/8nNtUhEPVRWDNc2oCrHs5CtV9j1wHhDwyEqLVC GMmHVdFl0c9b+NY5r3Y/Cr4gqjXfpkgGcaaeuPxL0UZ7dNklbwZ25LT6hBgc8Df2Npbl Q2eg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=k16li5nO; 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 j21sor370917lfh.92.2021.06.16.03.37.14 for (Google Transport Security); Wed, 16 Jun 2021 03:37:14 -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=k16li5nO; 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=nE0O5cQU8hO3PBDLKhrY8XOB0KUsBuVPprzerF6bl2k=; b=k16li5nOZGgYY0nec0s+jmVsg38V+i0m8AtY6nYedCt27GjPhEsBpnVbd9cbUDHXcX RgX6oEC4IuT9Rgr3PuKZNLnxbGM6FxMxao0YZ/fUkR21YsElDbdQat2DKYAH3abWsIuM aDM26qrvxIYFyR24WBmg7RMTl6CtQY/aIGnViMFbjYPK6Q7vlfInTOg2AZ0MtSzSHPYB s7rQvHakK/3luLxJshDNc+SP7AlT1iFj14HqUoszeAWZJEgGE06H7NDjNuuH/9oXomTA mCxYwXXCGq/q/ZlU5zG9OKEK/oQpUpvGcKaJrdu5T6T+b2kyqAZu+W6zdkkCdMHCr/v2 iDyg== 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=nE0O5cQU8hO3PBDLKhrY8XOB0KUsBuVPprzerF6bl2k=; b=ljpHChH5KqlvIHETGvEvY+4Ns4NEPiN5Lr8RWKMaVOpfbBGQpbgx5sNMWktQu9IlxT MMA2A7JC2EYxk/Hvz0JB+p2gqgKE3emr+3tPfp5DRCK8wR18/3j8cZWf5nONeFYhG51F sBSm1t3vpYoqFOT8TbLkoi2FqTsfxGxD2S24wiqiydHwPOSzRO+s/xUFdumD+A6J2isk lnM18j7BSAzIkq1cwuQG0Gx5pg+m8Zs7Pug1+7q8Suny8RERmbMgAPsKQ4WZqOLDZ+z1 CBU69YQ5SM7JwOgAAusZTAHQ+qyGazABJblI4UMsVPrBBp5hqkCFvdInPzADdIlg91B5 gHIQ== X-Gm-Message-State: AOAM5317HtqUchLm6kX4WaE8Xg5wAPMK5BaEPlFTMbItxG3wa2yZ/oPC P5gHAzQaU9K7itd6jkbiZzKe2k8q X-Google-Smtp-Source: ABdhPJxlGQxPkzYmAgnMySBW3P/4sn8vf4auEa0rSVlvSI7dwnCv9fks3Osl+2ntItuO2whQVGbO5g== X-Received: by 2002:a19:7711:: with SMTP id s17mr3308348lfc.430.1623839833963; Wed, 16 Jun 2021 03:37:13 -0700 (PDT) Return-Path: Received: from jade.urgonet (h-79-136-85-3.A175.priv.bahnhof.se. [79.136.85.3]) by smtp.gmail.com with ESMTPSA id m17sm205621lfh.288.2021.06.16.03.37.13 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 16 Jun 2021 03:37:13 -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 v2 5/7] tee: add tee_dev_open_helper() primitive Date: Wed, 16 Jun 2021 12:36:47 +0200 Message-Id: <20210616103649.2662395-6-jens.wiklander@linaro.org> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210616103649.2662395-1-jens.wiklander@linaro.org> References: <20210616103649.2662395-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 f97d95b50773..6d81f6268b99 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 Wed Jun 16 10:36:48 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jens Wiklander X-Patchwork-Id: 461390 Delivered-To: patches@linaro.org Received: by 2002:a02:735a:0:0:0:0:0 with SMTP id a26csp487178jae; Wed, 16 Jun 2021 03:37:15 -0700 (PDT) X-Received: by 2002:a05:6512:2110:: with SMTP id q16mr3077050lfr.526.1623839835189; Wed, 16 Jun 2021 03:37:15 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1623839835; cv=none; d=google.com; s=arc-20160816; b=YB+uh6McedmVyHMin4yJA8jGeOEN0LkkPOjcXwtkuTu5PxjIf4YutTNynZ2ccsA7X5 g/U+aPkoNxXF8TxxR8Lfw2mmbkaF8Qi/5qvajA17KEiLjBaBjsKbiFJiMJgOTLXO0L0p UFwfR32d7AjX39lquQBcWivJxi0Jcee2HXWY0MKZ5Q5Ng4qT7W1tBrIdE8/0gcPKPXi7 H+pmpCzXaVo8LPAPv9Oc/XEDJJn11mQttgnIX5xjuEHjjvxfdQgvPzQ6JSSKLVTDKamn uZvmHtBiFB9N3PtumgQjlYEY9y0tzXVNINR9wggJewZlX8pmO1/3n/2daH8/GlR6r2k1 7ZdA== 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=Ho2nXJC9Qr09AVnIVgeBhJfR5JWdqKD4LpLqzjAsfofiB5xPq9x0jV73BUZgy2HPYd CO6iF7kpwr5eitV0Ls8ST8SHjxN8A+vbMU8nCojhOn9/U0SpZDPwBJdYQlnvwj6vDHYM TyDTEUq1EVn2YxM+J2XfvO5yAipVgz61GZZUIcrFmVOCvPEUIzIf48vzwL65aFHxNlS6 +5ocU9qMBjtgqCVGJ1phg98MHQIac9mgt+b+/2rTc6nLxJIgK1rECnBYXe41w1Lw2aCi KXq3iOpqiGWkEqU/nvlt88zS8lBdvf1QZyquyoKg/SEtGDyNWahq1t+Mhb/kCF0EA3CY xLdA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b="wipB/Jbj"; 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 y24sor367678lfl.182.2021.06.16.03.37.15 for (Google Transport Security); Wed, 16 Jun 2021 03:37:15 -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="wipB/Jbj"; 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=wipB/JbjELJxzVH9FmaefDw5Qpb2ICTrnBmhdbC30Z5///ALfSOxhow3EEAUIsjEL0 /antU4lxT56Qskyw8KSi75erRKG23+g0eV98pM656bFa69qREpzn42Z+xAKY9E164lue C+MzYzL6h+Wgo8i6JA4A1HT8jBHFBtrQ41vOdN3ZZHEmz5sokhzWpEE1pd2wfnzW9C0R T1fusOkjbTB0QimPtrTpWSYO61LGkebt4eE21+EjrgoJw/cn8k7FGY7G5Abeg3QpHjrJ UMxOLPIotSjy7s/sJGHRb5unxCUt9n+9do8Lb0JjySZcdaU5WvhpzIaGoJkR566Ymn+G jEnw== 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=MAqFAU7n3BNxtZ1isAVsFYOwAyIS0BejipCPxhWMFah8o3c1opQxb33ZFB9UOniBHC AnnWmUkE/uoDu8aqnBQmOF61zTKiBIgjU6WpQiRhbFgK0Uft18ZVmEC4UdWZeyW2yEGL SUHWX1QytMqQgtrrEYD/mIbdHAaADu/mBQUwOp9xcYLMVdFRM+eAHhiS6ZS22iBvsm8q tWpAxHk5O4XyujuctG4Cv5mjZFaHBZlT6xUdqywQaIbHhtRBCNCMcSQO7kkN0nIP1iTe iqsMOKLT98p5cSNg7L2xgMA59PUJts3SajJcSsshWYQy4XNsZTfdsZExM/8bahLomBeu pgrQ== X-Gm-Message-State: AOAM533KSBOMXAv/34DZb4x4YmcTOuO69kBhScCd59N+JhtxmGSYPR4p KyRHvBUyLDtK5oVl1+Y4A0wKQ20d X-Google-Smtp-Source: ABdhPJxNr0ELEcnEGHK5cgQ9BY0z38SR2BRGizAKQ7NavBa8/4UQ8W0rlKIO2vNBqhSTbzxcXRIPDw== X-Received: by 2002:a19:4f09:: with SMTP id d9mr3119208lfb.501.1623839834749; Wed, 16 Jun 2021 03:37:14 -0700 (PDT) Return-Path: Received: from jade.urgonet (h-79-136-85-3.A175.priv.bahnhof.se. [79.136.85.3]) by smtp.gmail.com with ESMTPSA id m17sm205621lfh.288.2021.06.16.03.37.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 16 Jun 2021 03:37:14 -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 v2 6/7] optee: separate notification functions Date: Wed, 16 Jun 2021 12:36:48 +0200 Message-Id: <20210616103649.2662395-7-jens.wiklander@linaro.org> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210616103649.2662395-1-jens.wiklander@linaro.org> References: <20210616103649.2662395-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 Wed Jun 16 10:36:49 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jens Wiklander X-Patchwork-Id: 461391 Delivered-To: patches@linaro.org Received: by 2002:a02:735a:0:0:0:0:0 with SMTP id a26csp487195jae; Wed, 16 Jun 2021 03:37:16 -0700 (PDT) X-Received: by 2002:a2e:2416:: with SMTP id k22mr3769465ljk.135.1623839836111; Wed, 16 Jun 2021 03:37:16 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1623839836; cv=none; d=google.com; s=arc-20160816; b=PCbtj0Ml/j/JlOQBCNBQ2Mh1GmQpUGid0QSY27e73m8VxhODzmqvhc0cbyEru/4Hpw KeXkgm9KSdGFKcPHLqmYfRXpEI5iAy4glMQNlOpkNwICU4F7oOSj7gMlqCbN9CIvEvUK hjrRkXCl1ofH4Z2HNN8L7+mU9LkpQ7W7G4fMMpPbMWRxE4kxH2vLfsvh2pwUCmjM115u pde1uGR76gJbLEPaDa6T9lQydYq2VVwTTL8jaOy3xBEEwq9O/zmuLHN+OJx0de7PGn+7 7SyKGXPCziLOUnUio0DuMbXtKSlNOzi8ZZ9inHx8fHlpup2AvOuGnBHVR7P/CUl8WerY zjgg== 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=YMJpHNuGP5QLSqJHgwC7TvzwjmCtLXU1dC7TEiaTZFA=; b=FBmiUAsg3uXf50uTMBStILiC5DLlLMG/FgL8dTsynrh0vdnb58GOFA2GOk53d5CPBo F0f5rYMICuFqUDkhbvDOwNfucEgQpJZoUBBm+ZDJmFmYcwUHuYYh5OcBZclgaFE0dpD8 4kE+JmuEDQIXrA4QQ+LD7z+XJn8jGkvY3FmPZ14YGViDxg0JF8ZaTYdwR+0u5mOV5PB9 hmPmAMhCjm5TExKfjycUTS6zzdqRZ/S2qzgYN/l9U0XnijDYRczQ6SerxRV1GhsCkgPO ktUAys2Ap247mA14nXGTZbstZ8ZR0F02UrIl79MwAYbbTAEVtMuWBL/50ywChO9G6FQ0 Y9cQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=lFE9Uo92; 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 f1sor373927lfs.165.2021.06.16.03.37.15 for (Google Transport Security); Wed, 16 Jun 2021 03:37:16 -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=lFE9Uo92; 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=YMJpHNuGP5QLSqJHgwC7TvzwjmCtLXU1dC7TEiaTZFA=; b=lFE9Uo92KFnD3o4AzvLfixpuk8+qH5Tv9p3xBi8JqDGTyVaxXXB81dEm3pWjztxcn7 x1vd3FFBfFPL8dyMsTGTOZWttRzwVw5QeZ5m64VWrMX3JaKPzj0V/oan96vtRg7O95gp yGeRRWuP9q/FyFkaARdDQvfdLtsn6G03T/87/ApuPpxtcvFZc/ebpJNWbavsCzyohRNs B83fUhxPcBM/7DQnJX8XFepGx6N/yVeZSk6tmy1Dy5QsZ4Kgkzl2hgCxwFmmA65f+FBc JfKwkU2ctgVZBD3DxkJBLl4pdt1pDT+QVFDlJK4f7H3/fizzckD9iIVV9pFrNBE6AV90 PDXQ== 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=YMJpHNuGP5QLSqJHgwC7TvzwjmCtLXU1dC7TEiaTZFA=; b=gEY+5bV1rCHi/5vs27DuXQhzai1T7QB/BuRWGVUoEcOmdUozh/hnXCS0WJdVyDuDfI VggIDjcm5e9peIr/Ueg1FCNvS5d6dG6sP4RNem9o9lJdVo6lIrWZJuknHO21uvKRmEVP Ro1+nTIgk1Q0bXceFJev8WqeYe+mUQrJtA6e75qst7TnMg2cgoAbWy7ON7vNrKdl5rll lxz0HAptpXIXgako7lN0qb9C/mqSVRJreXdcPqskE/bJnz30nO+VMaBgRZQ7Wg/fra74 AaQ+JDGlz2D3G5dDR8T9sNkt6Zq2fq1wwJrM4Iq6n7gxD9NYWDZnuxAhAGa6fabCIRyz 689Q== X-Gm-Message-State: AOAM531gOh3MbUKCBiT3CP/vwNj6vboT6Rr8aj/kDLI1bmhK80ghrtAO CpQQYHvGKmGGfZk+jcDBQbvlFTVc X-Google-Smtp-Source: ABdhPJyrprQa5kq10xVxR7zeQJe5m0gDJI4bwauvL8bdQvahp1N0/PraAbc2B5xfJbjdEWO00Q6rFg== X-Received: by 2002:a19:783:: with SMTP id 125mr3291676lfh.296.1623839835651; Wed, 16 Jun 2021 03:37:15 -0700 (PDT) Return-Path: Received: from jade.urgonet (h-79-136-85-3.A175.priv.bahnhof.se. [79.136.85.3]) by smtp.gmail.com with ESMTPSA id m17sm205621lfh.288.2021.06.16.03.37.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 16 Jun 2021 03:37:15 -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 v2 7/7] optee: add asynchronous notifications Date: Wed, 16 Jun 2021 12:36:49 +0200 Message-Id: <20210616103649.2662395-8-jens.wiklander@linaro.org> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210616103649.2662395-1-jens.wiklander@linaro.org> References: <20210616103649.2662395-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. 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 6132cc8d014c..9da66acac828 100644 --- a/drivers/tee/optee/call.c +++ b/drivers/tee/optee/call.c @@ -390,6 +390,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 81ff593ac4ec..35970932de34 100644 --- a/drivers/tee/optee/optee_msg.h +++ b/drivers/tee/optee/optee_msg.h @@ -291,6 +291,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 @@ -298,6 +305,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) *