mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/netfilter/nf.git
synced 2026-04-18 06:34:27 -04:00
tee: add Qualcomm TEE driver
Introduce qcomtee_object, which represents an object in both QTEE and the kernel. QTEE clients can invoke an instance of qcomtee_object to access QTEE services. If this invocation produces a new object in QTEE, an instance of qcomtee_object will be returned. Similarly, QTEE can request services from by issuing a callback request, which invokes an instance of qcomtee_object. Implement initial support for exporting qcomtee_object to userspace and QTEE, enabling the invocation of objects hosted in QTEE and userspace through the TEE subsystem. Tested-by: Neil Armstrong <neil.armstrong@linaro.org> Tested-by: Harshal Dev <quic_hdev@quicinc.com> Acked-by: Sumit Garg <sumit.garg@oss.qualcomm.com> Signed-off-by: Amirreza Zarrabi <amirreza.zarrabi@oss.qualcomm.com> Signed-off-by: Jens Wiklander <jens.wiklander@linaro.org>
This commit is contained in:
Amirreza Zarrabi
committed by
Jens Wiklander
Jens Wiklander
parent
bd51393068
commit
d6e290837e
316
drivers/tee/qcomtee/qcomtee_object.h
Normal file
316
drivers/tee/qcomtee/qcomtee_object.h
Normal file
@@ -0,0 +1,316 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0-only */
|
||||
/*
|
||||
* Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
|
||||
*/
|
||||
|
||||
#ifndef QCOMTEE_OBJECT_H
|
||||
#define QCOMTEE_OBJECT_H
|
||||
|
||||
#include <linux/completion.h>
|
||||
#include <linux/kref.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/workqueue.h>
|
||||
|
||||
struct qcomtee_object;
|
||||
|
||||
/**
|
||||
* DOC: Overview
|
||||
*
|
||||
* qcomtee_object provides object refcounting, ID allocation for objects hosted
|
||||
* in the kernel, and necessary message marshaling for Qualcomm TEE (QTEE).
|
||||
*
|
||||
* To invoke an object in QTEE, the user calls qcomtee_object_do_invoke()
|
||||
* while passing an instance of &struct qcomtee_object and the requested
|
||||
* operation + arguments.
|
||||
*
|
||||
* After boot, QTEE provides a static object %ROOT_QCOMTEE_OBJECT (type of
|
||||
* %QCOMTEE_OBJECT_TYPE_ROOT). The root object is invoked to pass the user's
|
||||
* credentials and obtain other instances of &struct qcomtee_object (type of
|
||||
* %QCOMTEE_OBJECT_TYPE_TEE) that represent services and TAs in QTEE;
|
||||
* see &enum qcomtee_object_type.
|
||||
*
|
||||
* The objects received from QTEE are refcounted. So the owner of these objects
|
||||
* can issue qcomtee_object_get() to increase the refcount and pass objects
|
||||
* to other clients, or issue qcomtee_object_put() to decrease the refcount
|
||||
* and release the resources in QTEE.
|
||||
*
|
||||
* The kernel can host services accessible to QTEE. A driver should embed
|
||||
* an instance of &struct qcomtee_object in the struct it wants to export to
|
||||
* QTEE (this is called a callback object). It issues qcomtee_object_user_init()
|
||||
* to set the dispatch() operation for the callback object and set its type
|
||||
* to %QCOMTEE_OBJECT_TYPE_CB.
|
||||
*
|
||||
* core.c holds an object table for callback objects. An object ID is assigned
|
||||
* to each callback object, which is an index to the object table. QTEE uses
|
||||
* these IDs to reference or invoke callback objects.
|
||||
*
|
||||
* If QTEE invokes a callback object in the kernel, the dispatch() operation is
|
||||
* called in the context of the thread that originally called
|
||||
* qcomtee_object_do_invoke().
|
||||
*/
|
||||
|
||||
/**
|
||||
* enum qcomtee_object_type - Object types.
|
||||
* @QCOMTEE_OBJECT_TYPE_TEE: object hosted on QTEE.
|
||||
* @QCOMTEE_OBJECT_TYPE_CB: object hosted on kernel.
|
||||
* @QCOMTEE_OBJECT_TYPE_ROOT: 'primordial' object.
|
||||
* @QCOMTEE_OBJECT_TYPE_NULL: NULL object.
|
||||
*
|
||||
* The primordial object is used for bootstrapping the IPC connection between
|
||||
* the kernel and QTEE. It is invoked by the kernel when it wants to get a
|
||||
* 'client env'.
|
||||
*/
|
||||
enum qcomtee_object_type {
|
||||
QCOMTEE_OBJECT_TYPE_TEE,
|
||||
QCOMTEE_OBJECT_TYPE_CB,
|
||||
QCOMTEE_OBJECT_TYPE_ROOT,
|
||||
QCOMTEE_OBJECT_TYPE_NULL,
|
||||
};
|
||||
|
||||
/**
|
||||
* enum qcomtee_arg_type - Type of QTEE argument.
|
||||
* @QCOMTEE_ARG_TYPE_INV: invalid type.
|
||||
* @QCOMTEE_ARG_TYPE_OB: output buffer (OB).
|
||||
* @QCOMTEE_ARG_TYPE_OO: output object (OO).
|
||||
* @QCOMTEE_ARG_TYPE_IB: input buffer (IB).
|
||||
* @QCOMTEE_ARG_TYPE_IO: input object (IO).
|
||||
*
|
||||
* Use the invalid type to specify the end of the argument array.
|
||||
*/
|
||||
enum qcomtee_arg_type {
|
||||
QCOMTEE_ARG_TYPE_INV = 0,
|
||||
QCOMTEE_ARG_TYPE_OB,
|
||||
QCOMTEE_ARG_TYPE_OO,
|
||||
QCOMTEE_ARG_TYPE_IB,
|
||||
QCOMTEE_ARG_TYPE_IO,
|
||||
QCOMTEE_ARG_TYPE_NR,
|
||||
};
|
||||
|
||||
/**
|
||||
* define QCOMTEE_ARGS_PER_TYPE - Maximum arguments of a specific type.
|
||||
*
|
||||
* The QTEE transport protocol limits the maximum number of arguments of
|
||||
* a specific type (i.e., IB, OB, IO, and OO).
|
||||
*/
|
||||
#define QCOMTEE_ARGS_PER_TYPE 16
|
||||
|
||||
/* Maximum arguments that can fit in a QTEE message, ignoring the type. */
|
||||
#define QCOMTEE_ARGS_MAX (QCOMTEE_ARGS_PER_TYPE * (QCOMTEE_ARG_TYPE_NR - 1))
|
||||
|
||||
struct qcomtee_buffer {
|
||||
union {
|
||||
void *addr;
|
||||
void __user *uaddr;
|
||||
};
|
||||
size_t size;
|
||||
};
|
||||
|
||||
/**
|
||||
* struct qcomtee_arg - Argument for QTEE object invocation.
|
||||
* @type: type of argument as &enum qcomtee_arg_type.
|
||||
* @flags: extra flags.
|
||||
* @b: address and size if the type of argument is a buffer.
|
||||
* @o: object instance if the type of argument is an object.
|
||||
*
|
||||
* &qcomtee_arg.flags only accepts %QCOMTEE_ARG_FLAGS_UADDR for now, which
|
||||
* states that &qcomtee_arg.b contains a userspace address in uaddr.
|
||||
*/
|
||||
struct qcomtee_arg {
|
||||
enum qcomtee_arg_type type;
|
||||
/* 'b.uaddr' holds a __user address. */
|
||||
#define QCOMTEE_ARG_FLAGS_UADDR BIT(0)
|
||||
unsigned int flags;
|
||||
union {
|
||||
struct qcomtee_buffer b;
|
||||
struct qcomtee_object *o;
|
||||
};
|
||||
};
|
||||
|
||||
static inline int qcomtee_args_len(struct qcomtee_arg *args)
|
||||
{
|
||||
int i = 0;
|
||||
|
||||
while (args[i].type != QCOMTEE_ARG_TYPE_INV)
|
||||
i++;
|
||||
return i;
|
||||
}
|
||||
|
||||
/* Context is busy (callback is in progress). */
|
||||
#define QCOMTEE_OIC_FLAG_BUSY BIT(1)
|
||||
/* Context needs to notify the current object. */
|
||||
#define QCOMTEE_OIC_FLAG_NOTIFY BIT(2)
|
||||
/* Context has shared state with QTEE. */
|
||||
#define QCOMTEE_OIC_FLAG_SHARED BIT(3)
|
||||
|
||||
/**
|
||||
* struct qcomtee_object_invoke_ctx - QTEE context for object invocation.
|
||||
* @ctx: TEE context for this invocation.
|
||||
* @flags: flags for the invocation context.
|
||||
* @errno: error code for the invocation.
|
||||
* @object: current object invoked in this callback context.
|
||||
* @u: array of arguments for the current invocation (+1 for ending arg).
|
||||
* @in_msg: inbound buffer shared with QTEE.
|
||||
* @out_msg: outbound buffer shared with QTEE.
|
||||
* @in_shm: TEE shm allocated for inbound buffer.
|
||||
* @out_shm: TEE shm allocated for outbound buffer.
|
||||
* @data: extra data attached to this context.
|
||||
*/
|
||||
struct qcomtee_object_invoke_ctx {
|
||||
struct tee_context *ctx;
|
||||
unsigned long flags;
|
||||
int errno;
|
||||
|
||||
struct qcomtee_object *object;
|
||||
struct qcomtee_arg u[QCOMTEE_ARGS_MAX + 1];
|
||||
|
||||
struct qcomtee_buffer in_msg;
|
||||
struct qcomtee_buffer out_msg;
|
||||
struct tee_shm *in_shm;
|
||||
struct tee_shm *out_shm;
|
||||
|
||||
void *data;
|
||||
};
|
||||
|
||||
static inline struct qcomtee_object_invoke_ctx *
|
||||
qcomtee_object_invoke_ctx_alloc(struct tee_context *ctx)
|
||||
{
|
||||
struct qcomtee_object_invoke_ctx *oic;
|
||||
|
||||
oic = kzalloc(sizeof(*oic), GFP_KERNEL);
|
||||
if (oic)
|
||||
oic->ctx = ctx;
|
||||
return oic;
|
||||
}
|
||||
|
||||
/**
|
||||
* qcomtee_object_do_invoke() - Submit an invocation for an object.
|
||||
* @oic: context to use for the current invocation.
|
||||
* @object: object being invoked.
|
||||
* @op: requested operation on the object.
|
||||
* @u: array of arguments for the current invocation.
|
||||
* @result: result returned from QTEE.
|
||||
*
|
||||
* The caller is responsible for keeping track of the refcount for each object,
|
||||
* including @object. On return, the caller loses ownership of all input
|
||||
* objects of type %QCOMTEE_OBJECT_TYPE_CB.
|
||||
*
|
||||
* @object can be of %QCOMTEE_OBJECT_TYPE_ROOT or %QCOMTEE_OBJECT_TYPE_TEE.
|
||||
*
|
||||
* Return: On success, returns 0; on failure, returns < 0.
|
||||
*/
|
||||
int qcomtee_object_do_invoke(struct qcomtee_object_invoke_ctx *oic,
|
||||
struct qcomtee_object *object, u32 op,
|
||||
struct qcomtee_arg *u, int *result);
|
||||
|
||||
/**
|
||||
* struct qcomtee_object_operations - Callback object operations.
|
||||
* @release: release the object if QTEE is not using it.
|
||||
* @dispatch: dispatch the operation requested by QTEE.
|
||||
* @notify: report the status of any pending response submitted by @dispatch.
|
||||
*/
|
||||
struct qcomtee_object_operations {
|
||||
void (*release)(struct qcomtee_object *object);
|
||||
int (*dispatch)(struct qcomtee_object_invoke_ctx *oic,
|
||||
struct qcomtee_object *object, u32 op,
|
||||
struct qcomtee_arg *args);
|
||||
void (*notify)(struct qcomtee_object_invoke_ctx *oic,
|
||||
struct qcomtee_object *object, int err);
|
||||
};
|
||||
|
||||
/**
|
||||
* struct qcomtee_object - QTEE or kernel object.
|
||||
* @name: object name.
|
||||
* @refcount: reference counter.
|
||||
* @object_type: object type as &enum qcomtee_object_type.
|
||||
* @info: extra information for the object.
|
||||
* @ops: callback operations for objects of type %QCOMTEE_OBJECT_TYPE_CB.
|
||||
* @work: work for async operations on the object.
|
||||
*
|
||||
* @work is used for releasing objects of %QCOMTEE_OBJECT_TYPE_TEE type.
|
||||
*/
|
||||
struct qcomtee_object {
|
||||
const char *name;
|
||||
struct kref refcount;
|
||||
|
||||
enum qcomtee_object_type object_type;
|
||||
struct object_info {
|
||||
unsigned long qtee_id;
|
||||
/* TEE context for QTEE object async requests. */
|
||||
struct tee_context *qcomtee_async_ctx;
|
||||
} info;
|
||||
|
||||
struct qcomtee_object_operations *ops;
|
||||
struct work_struct work;
|
||||
};
|
||||
|
||||
/* Static instances of qcomtee_object objects. */
|
||||
#define NULL_QCOMTEE_OBJECT ((struct qcomtee_object *)(0))
|
||||
extern struct qcomtee_object qcomtee_object_root;
|
||||
#define ROOT_QCOMTEE_OBJECT (&qcomtee_object_root)
|
||||
|
||||
static inline enum qcomtee_object_type
|
||||
typeof_qcomtee_object(struct qcomtee_object *object)
|
||||
{
|
||||
if (object == NULL_QCOMTEE_OBJECT)
|
||||
return QCOMTEE_OBJECT_TYPE_NULL;
|
||||
return object->object_type;
|
||||
}
|
||||
|
||||
static inline const char *qcomtee_object_name(struct qcomtee_object *object)
|
||||
{
|
||||
if (object == NULL_QCOMTEE_OBJECT)
|
||||
return "null";
|
||||
|
||||
if (!object->name)
|
||||
return "no-name";
|
||||
return object->name;
|
||||
}
|
||||
|
||||
/**
|
||||
* qcomtee_object_user_init() - Initialize an object for the user.
|
||||
* @object: object to initialize.
|
||||
* @ot: type of object as &enum qcomtee_object_type.
|
||||
* @ops: instance of callbacks.
|
||||
* @fmt: name assigned to the object.
|
||||
*
|
||||
* Return: On success, returns 0; on failure, returns < 0.
|
||||
*/
|
||||
int qcomtee_object_user_init(struct qcomtee_object *object,
|
||||
enum qcomtee_object_type ot,
|
||||
struct qcomtee_object_operations *ops,
|
||||
const char *fmt, ...) __printf(4, 5);
|
||||
|
||||
/* Object release is RCU protected. */
|
||||
int qcomtee_object_get(struct qcomtee_object *object);
|
||||
void qcomtee_object_put(struct qcomtee_object *object);
|
||||
|
||||
#define qcomtee_arg_for_each(i, args) \
|
||||
for (i = 0; args[i].type != QCOMTEE_ARG_TYPE_INV; i++)
|
||||
|
||||
/* Next argument of type @type after index @i. */
|
||||
int qcomtee_next_arg_type(struct qcomtee_arg *u, int i,
|
||||
enum qcomtee_arg_type type);
|
||||
|
||||
/* Iterate over argument of given type. */
|
||||
#define qcomtee_arg_for_each_type(i, args, at) \
|
||||
for (i = qcomtee_next_arg_type(args, 0, at); \
|
||||
args[i].type != QCOMTEE_ARG_TYPE_INV; \
|
||||
i = qcomtee_next_arg_type(args, i + 1, at))
|
||||
|
||||
#define qcomtee_arg_for_each_input_buffer(i, args) \
|
||||
qcomtee_arg_for_each_type(i, args, QCOMTEE_ARG_TYPE_IB)
|
||||
#define qcomtee_arg_for_each_output_buffer(i, args) \
|
||||
qcomtee_arg_for_each_type(i, args, QCOMTEE_ARG_TYPE_OB)
|
||||
#define qcomtee_arg_for_each_input_object(i, args) \
|
||||
qcomtee_arg_for_each_type(i, args, QCOMTEE_ARG_TYPE_IO)
|
||||
#define qcomtee_arg_for_each_output_object(i, args) \
|
||||
qcomtee_arg_for_each_type(i, args, QCOMTEE_ARG_TYPE_OO)
|
||||
|
||||
struct qcomtee_object *
|
||||
qcomtee_object_get_client_env(struct qcomtee_object_invoke_ctx *oic);
|
||||
|
||||
struct qcomtee_object *
|
||||
qcomtee_object_get_service(struct qcomtee_object_invoke_ctx *oic,
|
||||
struct qcomtee_object *client_env, u32 uid);
|
||||
|
||||
#endif /* QCOMTEE_OBJECT_H */
|
||||
Reference in New Issue
Block a user