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