// SPDX-License-Identifier: GPL-2.0-only/* * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries. */ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #include "qcomtee.h" #define QCOMTEE_ASYNC_VERSION_1_0 0x00010000U /* Maj: 0x0001, Min: 0x0000. */#define QCOMTEE_ASYNC_VERSION_1_1 0x00010001U /* Maj: 0x0001, Min: 0x0001. */#define QCOMTEE_ASYNC_VERSION_1_2 0x00010002U /* Maj: 0x0001, Min: 0x0002. */#define QCOMTEE_ASYNC_VERSION_CURRENT QCOMTEE_ASYNC_VERSION_1_2 #define QCOMTEE_ASYNC_VERSION_MAJOR(n) upper_16_bits(n)#define QCOMTEE_ASYNC_VERSION_MINOR(n) lower_16_bits(n) #define QCOMTEE_ASYNC_VERSION_CURRENT_MAJOR \	QCOMTEE_ASYNC_VERSION_MAJOR(QCOMTEE_ASYNC_VERSION_CURRENT)#define QCOMTEE_ASYNC_VERSION_CURRENT_MINOR \	QCOMTEE_ASYNC_VERSION_MINOR(QCOMTEE_ASYNC_VERSION_CURRENT) /** * struct qcomtee_async_msg_hdr - Asynchronous message header format. * @version: current async protocol version of the remote endpoint. * @op: async operation. * * @version specifies the endpoint's (QTEE or driver) supported async protocol. * For example, if QTEE sets @version to %QCOMTEE_ASYNC_VERSION_1_1, QTEE * handles operations supported in %QCOMTEE_ASYNC_VERSION_1_1 or * %QCOMTEE_ASYNC_VERSION_1_0. @op determines the message format. */struct qcomtee_async_msg_hdr {	u32 version;	u32 op;}; /* Size of an empty async message. */#define QCOMTEE_ASYNC_MSG_ZERO sizeof(struct qcomtee_async_msg_hdr) /** * struct qcomtee_async_release_msg - Release asynchronous message. * @hdr: message header as &struct qcomtee_async_msg_hdr. * @counts: number of objects in @object_ids. * @object_ids: array of object IDs that should be released. * * Available in Maj = 0x0001, Min >= 0x0000. */struct qcomtee_async_release_msg {	struct qcomtee_async_msg_hdr hdr;	u32 counts;	u32 object_ids[] __counted_by(counts);}; /** * qcomtee_get_async_buffer() - Get the start of the asynchronous message. * @oic: context used for the current invocation. * @async_buffer: return buffer to extract from or fill in async messages. * * If @oic is used for direct object invocation, the whole outbound buffer * is available for the async message. If @oic is used for a callback request, * the tail of the outbound buffer (after the callback request message) is * available for the async message. * * The start of the async buffer is aligned, see qcomtee_msg_offset_align(). */static void qcomtee_get_async_buffer(struct qcomtee_object_invoke_ctx *oic,				     struct qcomtee_buffer *async_buffer){	struct qcomtee_msg_callback *msg;	unsigned int offset;	int i; 	if (!(oic->flags & QCOMTEE_OIC_FLAG_BUSY)) {		/* The outbound buffer is empty. Using the whole buffer. */		offset = 0;	} else {		msg = (struct qcomtee_msg_callback *)oic->out_msg.addr; 		/* Start offset in a message for buffer arguments. */		offset = qcomtee_msg_buffer_args(struct qcomtee_msg_callback,						 qcomtee_msg_args(msg)); 		/* Add size of IB arguments. */		qcomtee_msg_for_each_input_buffer(i, msg)			offset += qcomtee_msg_offset_align(msg->args[i].b.size); 		/* Add size of OB arguments. */		qcomtee_msg_for_each_output_buffer(i, msg)			offset += qcomtee_msg_offset_align(msg->args[i].b.size);	} 	async_buffer->addr = oic->out_msg.addr + offset;	async_buffer->size = oic->out_msg.size - offset;} /** * async_release() - Process QTEE async release requests. * @oic: context used for the current invocation. * @msg: async message for object release. * @size: size of the async buffer available. * * Return: Size of the outbound buffer used when processing @msg. */static size_t async_release(struct qcomtee_object_invoke_ctx *oic,			    struct qcomtee_async_msg_hdr *async_msg,			    size_t size){	struct qcomtee_async_release_msg *msg;	struct qcomtee_object *object;	int i; 	msg = (struct qcomtee_async_release_msg *)async_msg; 	for (i = 0; i < msg->counts; i++) {		object = qcomtee_idx_erase(oic, msg->object_ids[i]);		qcomtee_object_put(object);	} 	return struct_size(msg, object_ids, msg->counts);} /** * qcomtee_fetch_async_reqs() - Fetch and process asynchronous messages. * @oic: context used for the current invocation. * * Calls handlers to process the requested operations in the async message. * Currently, only supports async release requests. */void qcomtee_fetch_async_reqs(struct qcomtee_object_invoke_ctx *oic){	struct qcomtee_async_msg_hdr *async_msg;	struct qcomtee_buffer async_buffer;	size_t consumed, used = 0;	u16 major_ver; 	qcomtee_get_async_buffer(oic, &async_buffer); 	while (async_buffer.size - used > QCOMTEE_ASYNC_MSG_ZERO) {		async_msg = (struct qcomtee_async_msg_hdr *)(async_buffer.addr +							     used);		/*		 * QTEE assumes that the unused space of the async buffer is		 * zeroed; so if version is zero, the buffer is unused.		 */		if (async_msg->version == 0)			goto out; 		major_ver = QCOMTEE_ASYNC_VERSION_MAJOR(async_msg->version);		/* Major version mismatch is a compatibility break. */		if (major_ver != QCOMTEE_ASYNC_VERSION_CURRENT_MAJOR) {			pr_err("Async message version mismatch (%u != %u)\n",			       major_ver, QCOMTEE_ASYNC_VERSION_CURRENT_MAJOR); 			goto out;		} 		switch (async_msg->op) {		case QCOMTEE_MSG_OBJECT_OP_RELEASE:			consumed = async_release(oic, async_msg,						 async_buffer.size - used);			break;		default:			pr_err("Unsupported async message %u\n", async_msg->op);			goto out;		} 		/* Supported operation but unable to parse the message. */		if (!consumed) {			pr_err("Unable to parse async message for op %u\n",			       async_msg->op);			goto out;		} 		/* Next async message. */		used += qcomtee_msg_offset_align(consumed);	} out:	/* Reset the async buffer so async requests do not loop to QTEE. */	memzero_explicit(async_buffer.addr, async_buffer.size);}