From patchwork Thu Aug 26 12:30:28 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jens Wiklander X-Patchwork-Id: 503010 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-18.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_CR_TRAILER, INCLUDES_PATCH, MAILING_LIST_MULTI, SPF_HELO_NONE, SPF_PASS, URIBL_BLOCKED, USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id D2856C00143 for ; Thu, 26 Aug 2021 12:30:46 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id BE57B610CD for ; Thu, 26 Aug 2021 12:30:46 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S241371AbhHZMbc (ORCPT ); Thu, 26 Aug 2021 08:31:32 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60136 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241093AbhHZMbb (ORCPT ); Thu, 26 Aug 2021 08:31:31 -0400 Received: from mail-lj1-x22f.google.com (mail-lj1-x22f.google.com [IPv6:2a00:1450:4864:20::22f]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 237C3C0613CF for ; Thu, 26 Aug 2021 05:30:44 -0700 (PDT) Received: by mail-lj1-x22f.google.com with SMTP id p15so4820990ljn.3 for ; Thu, 26 Aug 2021 05:30:44 -0700 (PDT) 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=iDycTN9yyDhhTwc3Srtfw/Rl+6JzgcjoQzGWlzOIGrY=; b=nlXC4jk7imssziF4BZGKjdqHB/e4Rwx+jmB/xJpnO+gQjFcrnSB9voLWQJ4SVgBZsR yStK/gYOR1npSKgWdsOLRVqHr9SjxNrqB3oV+U9xtDrB5Y69puy0TGH2igM3RzqPkfx5 AkuZR9phcFzVh5FDfJcC3HwtYUz4P7F+AEMVM7tlp3yyWiQjEzSSp+lsQdxB5SUd+HBM kCXOpRjX5V3ViBIl91HhYKoLJU+m+uUpq3Vsep8K1JY9rAINAZn2Fyxy/qX5Cc1TbPXa dSnKDyB1WRM5n0GLEJUcUBOqReTT4RksS3qMFHyjpkLzl9QUUUu1upn81OhRMba8/8JM W17A== 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=iDycTN9yyDhhTwc3Srtfw/Rl+6JzgcjoQzGWlzOIGrY=; b=KUuZOBI8UM3gRA+hCbwqg0agc68xBTs2bVhKShAxoFcyLIVHvUry6sKS1BUP7TQQvk KobyqKPSPjdcxsPJ336Of8NhHnNsFmpBWZKP2in6Ujx98YLety9+LdpSWYnQ5T0ynyj/ apTA3cQWpQzvNvYIS4o3tJh1o2+3LVKfCjufXzSnGtRzOlqOK/9xm1uf4rlIHc7El5i+ 7Q1RtezLytfiJWsni+5sWjumvaIaSdZniuch/X5dy7nKpI82w/y76D0/dJ+le7kmsOvi sIA/xh7xRf1hcTU5ilPHWx46mDr4gokiVWPbZ9W8F6uKddhm+nMh7qVFJJiktGnDyNQx MGDw== X-Gm-Message-State: AOAM531kv2o1lYV0HCMJ0u9FWN/EFIm/TjNfya2slYbEP51Ok8Ac8ncw q5DezLBDxqfo3NGb45JuhLruGQ== X-Google-Smtp-Source: ABdhPJwQarP4Db9P6Gby/P9D9O3LQjajC9XAwpMTb5ACajA13QjU8NsTAlw1UOTlR0tnGBNT0NFpHA== X-Received: by 2002:a2e:91d0:: with SMTP id u16mr2862869ljg.324.1629981041954; Thu, 26 Aug 2021 05:30:41 -0700 (PDT) Received: from jade.ideon.se ([85.235.10.227]) by smtp.gmail.com with ESMTPSA id j21sm332283ljh.87.2021.08.26.05.30.41 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 26 Aug 2021 05:30:41 -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 , Rob Herring Subject: [PATCH v5 2/6] dt-bindings: arm: optee: add interrupt property Date: Thu, 26 Aug 2021 14:30:28 +0200 Message-Id: <20210826123032.1732926-3-jens.wiklander@linaro.org> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210826123032.1732926-1-jens.wiklander@linaro.org> References: <20210826123032.1732926-1-jens.wiklander@linaro.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org Adds an optional interrupt property to the optee binding. Reviewed-by: Rob Herring Acked-by: Marc Zyngier Signed-off-by: Jens Wiklander --- .../devicetree/bindings/arm/firmware/linaro,optee-tz.yaml | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/Documentation/devicetree/bindings/arm/firmware/linaro,optee-tz.yaml b/Documentation/devicetree/bindings/arm/firmware/linaro,optee-tz.yaml index c24047c1fdd5..40c9f1901e3f 100644 --- a/Documentation/devicetree/bindings/arm/firmware/linaro,optee-tz.yaml +++ b/Documentation/devicetree/bindings/arm/firmware/linaro,optee-tz.yaml @@ -24,6 +24,12 @@ properties: compatible: const: linaro,optee-tz + interrupts: + maxItems: 1 + description: | + This interrupt which is used to signal an event by the secure world + software is expected to be edge-triggered. + method: enum: [smc, hvc] description: | @@ -46,6 +52,7 @@ examples: optee { compatible = "linaro,optee-tz"; method = "smc"; + interrupts = <0 187 1>; }; }; From patchwork Thu Aug 26 12:30:30 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jens Wiklander X-Patchwork-Id: 503009 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-18.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_CR_TRAILER, INCLUDES_PATCH, MAILING_LIST_MULTI, SPF_HELO_NONE, SPF_PASS, URIBL_BLOCKED, USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 81D62C4320A for ; Thu, 26 Aug 2021 12:30:50 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 608B5610C9 for ; Thu, 26 Aug 2021 12:30:50 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S241822AbhHZMbf (ORCPT ); Thu, 26 Aug 2021 08:31:35 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60164 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241514AbhHZMbd (ORCPT ); Thu, 26 Aug 2021 08:31:33 -0400 Received: from mail-lj1-x236.google.com (mail-lj1-x236.google.com [IPv6:2a00:1450:4864:20::236]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A0A3DC0617AE for ; Thu, 26 Aug 2021 05:30:45 -0700 (PDT) Received: by mail-lj1-x236.google.com with SMTP id p15so4821171ljn.3 for ; Thu, 26 Aug 2021 05:30:45 -0700 (PDT) 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=1nZh1D/vgfD/yG7MqBv8BFt2r+KBCfUf2rl9x11f65A=; b=kNBNiY4UKsmHZRbM99Vhd8h7GG/a9o6r1qngDP9tv1c2c7dYn161AjY9hvR9Wkg1xn B5RbLp9v662Oup9rkPC1iG6jTCQYctTlE+CP6c8SJWkudo6RgocexfxrpQOOczp3d36e iekhWD8PT/0u3JtFStgT83ARy+svf3XZWQYb6f3e+5xKNkRhkROtco7XdXzCnaaZRnCc pf12smkNjNNThPhq8hZq2e/WYQ5vu3MzeYNBhHsVf8VIpbjD6BBo1r37kplxKskrLyTK 1mPsykQL7M23aBamYB3QXlco98GP18j7T0+ed6iIq0biKyLckk5qNbFWiIr8BOGSWOfK upig== 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=1nZh1D/vgfD/yG7MqBv8BFt2r+KBCfUf2rl9x11f65A=; b=F5r5KwhPSBSJFzciNczFRy284shL/P9uC1Vc3WmweWJxVFOvdzk21dLxqwGxJC608O vXl1VB6qKmn63TI5AE3S+Hu19S91MqF+sVZjXI6s1hKWpduymSF1KvenGTUGfM/gnKRh ysqu5L5I/B31m+ZHR2oihD/dAb3s5ub8E05nDcpG52ulDMM4BitP23X6x2L7VDe5pytq HU8AGbzkNVSwq2ouO72oB5p9788DwGAuytzb8XPHSLLK8pIqM0rBm3ITCDjGlE0lS3sG Tk6AzOc2idNLygHeVOI/IrSpnFgtIC8+CfHYhFzm7weZRcm+Uf0b5Aba2daMCVlHPtHe 8jLQ== X-Gm-Message-State: AOAM531E6f7J5pG5uVWD2ZJxTXup4A3tsfR/6Gws7GK/rUJ2VNj/zV2x lS8QxsE9LwClQZxlWDrezTDRZw== X-Google-Smtp-Source: ABdhPJynXFjAEzvIhb7rgJmxnTlvzFE7/PKd9Xj72TVumnAIAtDL6snB6W6EV9yC3qBRMEbKSYXApQ== X-Received: by 2002:a2e:b042:: with SMTP id d2mr2881688ljl.279.1629981043906; Thu, 26 Aug 2021 05:30:43 -0700 (PDT) Received: from jade.ideon.se ([85.235.10.227]) by smtp.gmail.com with ESMTPSA id j21sm332283ljh.87.2021.08.26.05.30.43 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 26 Aug 2021 05:30:43 -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 v5 4/6] tee: add tee_dev_open_helper() primitive Date: Thu, 26 Aug 2021 14:30:30 +0200 Message-Id: <20210826123032.1732926-5-jens.wiklander@linaro.org> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210826123032.1732926-1-jens.wiklander@linaro.org> References: <20210826123032.1732926-1-jens.wiklander@linaro.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org 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(-) 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 3ebfea0781f1..00a31ff03049 100644 --- a/include/linux/tee_drv.h +++ b/include/linux/tee_drv.h @@ -458,6 +458,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 Thu Aug 26 12:30:32 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jens Wiklander X-Patchwork-Id: 503008 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-18.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_CR_TRAILER, INCLUDES_PATCH, MAILING_LIST_MULTI, SPF_HELO_NONE, SPF_PASS, URIBL_BLOCKED, USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 2CC86C4320A for ; Thu, 26 Aug 2021 12:30:55 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 167586109E for ; Thu, 26 Aug 2021 12:30:55 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S242092AbhHZMbl (ORCPT ); Thu, 26 Aug 2021 08:31:41 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60176 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241790AbhHZMbf (ORCPT ); Thu, 26 Aug 2021 08:31:35 -0400 Received: from mail-lf1-x12d.google.com (mail-lf1-x12d.google.com [IPv6:2a00:1450:4864:20::12d]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id BDAABC0613D9 for ; Thu, 26 Aug 2021 05:30:47 -0700 (PDT) Received: by mail-lf1-x12d.google.com with SMTP id k5so6501460lfu.4 for ; Thu, 26 Aug 2021 05:30:47 -0700 (PDT) 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=Ng8ZNid6/qrTsJuDagU8iZUEjhDRF9hEOQBfN3vPdJs=; b=JahS5rCx1uQ7m/4drH6TBGdVQew8ESL/dJcJ91gNrY6BX587bJTVCny9QzzjHOqkFy 1tMnQfZUn5oASGmpE4Hnn4rUBbwqnBt0VEcu0dDEoV802s0949CE9XCJgnNHxvqtrv5g C1wrjEFX+NB88MAkvxsc9N4zVNAcJY268extxMcGjqHK+VR5qKp5juLvhlrSkvYlKv5Q LK4cPxtayq1p4UO9D6qqERBlYfj4DBZF/UWvuZt0QSbwIPXg27B+j0LEIwWkAMDmtk+N WJhO4w4j6XBL4kZuIrSmvR0pGuevB41aLH6o7fzj4kZvFTnbX7d7QwNmO2N0RnDNNqAb 9/Fg== 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=Ng8ZNid6/qrTsJuDagU8iZUEjhDRF9hEOQBfN3vPdJs=; b=Qd1zWEmfCvA5JZ+iQ8r1JhYANqhtbjMdtCACDSUNJG3MotCfIAUO94cWRIu6qG2eVU nqkKuH/os8XL0c/RejhdiH8AHMK++X1y3zXbMrcNfJzuT/+glvEBV3cRNDAprAoz+oNA Xx1kcKNbWqjkoGEQwXfQvTB3u2MKDEPa8NqHi4mnDyxuWrNjkDJURo9+V7NyTbi8Utmq jCnxxu/0YwAcQJE4kmbjmswcdwg1OreaWIbijpFme2HWVMywnE+wvf2XxIhlwC592VL0 3tLuOz77xdMHhoFnbBpHxCjwWFTNsGXR0Wlyo2KpW31Rtf8oqq94NZHRiFo1AQRzyI3z YzBA== X-Gm-Message-State: AOAM533EzzQh3yWfvros2/rPtVt1gOu2lxpY6QMGez4hekWDR0gH1eh9 XThPNven8OctpHVuYLcUW5t8cg== X-Google-Smtp-Source: ABdhPJwFPs+YgX5zT2jIyicB0g9zeaGxRzvkatx9ilxVybXco/fEosRQjJ3TPEBRY4WtNprJJHpVhA== X-Received: by 2002:a05:6512:45b:: with SMTP id y27mr2521450lfk.619.1629981046048; Thu, 26 Aug 2021 05:30:46 -0700 (PDT) Received: from jade.ideon.se ([85.235.10.227]) by smtp.gmail.com with ESMTPSA id j21sm332283ljh.87.2021.08.26.05.30.45 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 26 Aug 2021 05:30:45 -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 v5 6/6] optee: add asynchronous notifications Date: Thu, 26 Aug 2021 14:30:32 +0200 Message-Id: <20210826123032.1732926-7-jens.wiklander@linaro.org> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210826123032.1732926-1-jens.wiklander@linaro.org> References: <20210826123032.1732926-1-jens.wiklander@linaro.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org 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 | 83 ++++++++++++++++------- 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, 277 insertions(+), 32 deletions(-) diff --git a/drivers/tee/optee/call.c b/drivers/tee/optee/call.c index 945f03da0223..e428e0e9a3af 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 8531184f98f4..ccafd7151b45 100644 --- a/drivers/tee/optee/core.c +++ b/drivers/tee/optee/core.c @@ -8,9 +8,12 @@ #include #include #include +#include #include +#include #include #include +#include #include #include #include @@ -355,6 +358,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; @@ -404,7 +418,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; @@ -427,6 +441,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; } @@ -630,6 +645,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; @@ -659,7 +675,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; } @@ -682,7 +699,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; @@ -691,24 +708,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); @@ -717,10 +734,31 @@ static int optee_probe(struct platform_device *pdev) optee->pool = pool; 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; + } } /* @@ -745,20 +783,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 76a16d9b6cf4..f62a16935c49 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) *