Commit 787c80cc authored by Jens Wiklander's avatar Jens Wiklander
Browse files

optee: separate notification functions 



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.

Reviewed-by: default avatarSumit Garg <sumit.garg@linaro.org>
Signed-off-by: default avatarJens Wiklander <jens.wiklander@linaro.org>
parent 1e2c3ef0

drivers/tee/optee/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -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 += device.o

drivers/tee/optee/core.c

+1 −1
Original line number Diff line number Diff line
@@ -159,6 +159,7 @@ void optee_remove_common(struct optee *optee) 
	/* Unregister OP-TEE specific client devices on TEE bus */

	optee_unregister_devices();



	optee_notif_uninit(optee);

	/*

	 * The two devices have to be unregistered before we can free the

	 * other resources.
@@ -167,7 +168,6 @@ void optee_remove_common(struct optee *optee) 
	tee_device_unregister(optee->teedev);



	tee_shm_pool_free(optee->pool);

	optee_wait_queue_exit(&optee->wait_queue);

	optee_supp_uninit(&optee->supp);

	mutex_destroy(&optee->call_queue.mutex);

}

drivers/tee/optee/ffa_abi.c

+5 −1
Original line number Diff line number Diff line
@@ -856,9 +856,13 @@ static int optee_ffa_probe(struct ffa_device *ffa_dev) 
	mutex_init(&optee->ffa.mutex);

	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);

	ffa_dev_set_drvdata(ffa_dev, optee);

	rc = optee_notif_init(optee, OPTEE_DEFAULT_MAX_NOTIF_VALUE);

	if (rc) {

		optee_ffa_remove(ffa_dev);

		return rc;

	}



	rc = optee_enumerate_devices(PTA_CMD_GET_DEVICES);

	if (rc) {

drivers/tee/optee/notif.c

0 → 100644
+125 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

/*

 * Copyright (c) 2015-2021, Linaro Limited

 */



#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt



#include <linux/arm-smccc.h>

#include <linux/errno.h>

#include <linux/slab.h>

#include <linux/spinlock.h>

#include <linux/tee_drv.h>

#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);

}

drivers/tee/optee/optee_private.h

+18 −8
Original line number Diff line number Diff line
@@ -28,6 +28,13 @@ 


#define TEEC_ORIGIN_COMMS		0x00000002



/*

 * This value should be larger than the number threads in secure world to

 * meet the need from secure world. The number of threads in secure world

 * are usually not even close to 255 so we should be safe for now.

 */

#define OPTEE_DEFAULT_MAX_NOTIF_VALUE	255



typedef void (optee_invoke_fn)(unsigned long, unsigned long, unsigned long,

				unsigned long, unsigned long, unsigned long,

				unsigned long, unsigned long,
@@ -44,10 +51,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;

};



/**
@@ -129,8 +138,7 @@ struct optee_ops { 
 * @smc:		specific to SMC ABI

 * @ffa:		specific to FF-A ABI

 * @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

 * @rpc_arg_count:	If > 0 number of RPC parameters to make room for
@@ -147,7 +155,7 @@ struct optee { 
		struct optee_ffa ffa;

	};

	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;

	unsigned int rpc_arg_count;
@@ -185,8 +193,10 @@ struct optee_call_ctx { 
	size_t num_entries;

};



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);