// SPDX-License-Identifier: GPL-2.0-only
/*
 * Common file system operations for devices with MCU support.
 *
 * Copyright (C) 2022 Google LLC
 */

#include <linux/bits.h>
#include <linux/dma-fence-array.h>
#include <linux/fs.h>
#include <linux/mm_types.h>
#include <linux/rwsem.h>
#include <linux/slab.h>

#include <gcip/gcip-fence-array.h>
#include <gcip/gcip-fence.h>
#include <gcip/gcip-telemetry.h>

#include "gxp-client.h"
#include "gxp-internal.h"
#include "gxp-mcu-fs.h"
#include "gxp-mcu-telemetry.h"
#include "gxp-mcu.h"
#include "gxp-uci.h"
#include "gxp.h"

static int gxp_ioctl_uci_command_compat(struct gxp_client *client,
					struct gxp_mailbox_uci_command_compat_ioctl __user *argp)
{
	struct gxp_mailbox_uci_command_compat_ioctl ibuf;
	struct gxp_dev *gxp = client->gxp;
	struct gxp_mcu *mcu = gxp_mcu_of(gxp);
	u64 cmd_seq;
	int ret;

	if (copy_from_user(&ibuf, argp, sizeof(ibuf)))
		return -EFAULT;

	cmd_seq = gcip_mailbox_inc_seq_num(mcu->uci.mbx->mbx_impl.gcip_mbx, 1);

	ret = gxp_uci_create_and_send_cmd(client, cmd_seq, 0, ibuf.opaque, 0, NULL, NULL);
	if (ret) {
		dev_err(gxp->dev, "Failed to request an UCI command (ret=%d)", ret);
		return ret;
	}

	ibuf.sequence_number = cmd_seq;

	if (copy_to_user(argp, &ibuf, sizeof(ibuf)))
		return -EFAULT;

	return 0;
}

/**
 * polled_dma_fence_get() - Generate a dma-fence to represent all the fan-in fences.
 * @in_fences: The pointer to the gcip_fence_array object containing fan-in fances.
 *
 * Use dma_fence_array to handle all the fan-in fences if @in_fences->size > 1.
 * The caller should hold the reference count of the fences in @in_fences to make sure they will not
 * be released during the process.
 * The output fence will acquired 1 reference count in this function either with dma_fence_get() or
 * dma_fence_array_create().
 *
 * Return: The pointer to the generated dma-fence or the error pointer on error.
 *         A NULL pointer is returned if no in-kernel fence is passed in.
 */
static struct dma_fence *polled_dma_fence_get(struct gcip_fence_array *in_fences)
{
	static int array_seq;
	const int size = in_fences->size;
	struct dma_fence_array *fence_array;
	struct dma_fence **in_dma_fences;
	int i;

	if (!in_fences->size || !in_fences->same_type || in_fences->type != GCIP_IN_KERNEL_FENCE)
		return NULL;

	/* TODO(b/320401031): Remove this constraint after dma-fence-unwrap adopted. */
	/* dma-fence-array as in-fences is currently not supported. */
	for (i = 0; i < size; i++) {
		if (dma_fence_is_array(in_fences->fences[i]->fence.ikf))
			return ERR_PTR(-EINVAL);
	}

	if (size == 1)
		return dma_fence_get(in_fences->fences[0]->fence.ikf);

	in_dma_fences = kcalloc(size, sizeof(*in_dma_fences), GFP_KERNEL);
	if (!in_dma_fences)
		return ERR_PTR(-ENOMEM);

	for (i = 0; i < size; i++)
		in_dma_fences[i] = dma_fence_get(in_fences->fences[i]->fence.ikf);

	/* fence_array will take care of the life cycle of in_dma_fences.*/
	fence_array = dma_fence_array_create(size, in_dma_fences, dma_fence_context_alloc(1),
					     array_seq++, false);
	if (!fence_array) {
		kfree(in_dma_fences);
		/* dma_fence_array_create only returns NULL on allocation failure. */
		return ERR_PTR(-ENOMEM);
	}

	return &fence_array->base;
}

/*
 * Returns the number of fences. If the runtime passed an invalid fence, returns an errno
 * accordingly.
 */
static int get_num_fences(const int *fences)
{
	int i;
	struct gcip_fence *fence;

	for (i = 0; i < GXP_MAX_FENCES_PER_UCI_COMMAND; i++) {
		if (fences[i] == GXP_FENCE_ARRAY_TERMINATION)
			break;
		fence = gcip_fence_fdget(fences[i]);
		/*
		 * TODO(b/312819593): once the runtime adopts `GXP_FENCE_ARRAY_TERMINATION` to
		 * indicate the end of array, always returns PTR_ERR(fence).
		 */
		if (IS_ERR(fence))
			return !fences[i] ? 0 : PTR_ERR(fence);
		gcip_fence_put(fence);
	}

	return i;
}

static int gxp_ioctl_uci_command(struct gxp_client *client,
				 struct gxp_mailbox_uci_command_ioctl __user *argp)
{
	struct gxp_mcu *mcu = gxp_mcu_of(client->gxp);
	struct gxp_mailbox_uci_command_ioctl ibuf;
	struct gcip_fence_array *in_fences, *out_fences;
	struct dma_fence *polled_dma_fence;
	u64 cmd_seq;
	int ret, num_in_fences, num_out_fences;

	if (copy_from_user(&ibuf, argp, sizeof(ibuf)))
		return -EFAULT;

	cmd_seq = gcip_mailbox_inc_seq_num(mcu->uci.mbx->mbx_impl.gcip_mbx, 1);

	num_in_fences = get_num_fences(ibuf.in_fences);
	if (num_in_fences < 0)
		return num_in_fences;

	num_out_fences = get_num_fences(ibuf.out_fences);
	if (num_out_fences < 0)
		return num_out_fences;

	in_fences = gcip_fence_array_create(ibuf.in_fences, num_in_fences, true);
	if (IS_ERR(in_fences))
		return PTR_ERR(in_fences);

	out_fences = gcip_fence_array_create(ibuf.out_fences, num_out_fences, false);
	if (IS_ERR(out_fences)) {
		gcip_fence_array_put(in_fences);
		return PTR_ERR(out_fences);
	}

	polled_dma_fence = polled_dma_fence_get(in_fences);
	if (IS_ERR(polled_dma_fence)) {
		ret = PTR_ERR(polled_dma_fence);
		goto out;
	}

	ret = gxp_uci_cmd_work_create_and_schedule(polled_dma_fence, client, &ibuf, cmd_seq,
						   in_fences, out_fences);
	if (ret) {
		dev_err(client->gxp->dev, "Failed to request an UCI command (ret=%d)", ret);
		goto err_put_fence;
	}

	ibuf.sequence_number = cmd_seq;

	if (copy_to_user(argp, &ibuf, sizeof(ibuf)))
		ret = -EFAULT;

err_put_fence:
	/*
	 * Put the reference count of the fence acqurired in polled_dma_fence_get.
	 * If the fence is a dma_fence_array and the callback is failed to be added,
	 * the whole object and the array it holds will be freed.
	 * If it is a NULL pointer, it's still safe to call this function.
	 */
	dma_fence_put(polled_dma_fence);
out:
	gcip_fence_array_put(out_fences);
	gcip_fence_array_put(in_fences);
	return ret;
}

static int
gxp_ioctl_uci_response(struct gxp_client *client,
		       struct gxp_mailbox_uci_response_ioctl __user *argp)
{
	struct gxp_mailbox_uci_response_ioctl ibuf;
	int ret = 0;

	if (copy_from_user(&ibuf, argp, sizeof(ibuf)))
		return -EFAULT;

	down_read(&client->semaphore);

	if (!client->vd) {
		dev_err(client->gxp->dev,
			"GXP_MAILBOX_UCI_RESPONSE requires the client allocate a VIRTUAL_DEVICE\n");
		ret = -ENODEV;
		goto out;
	}

	/* Caller must hold BLOCK wakelock */
	if (!client->has_block_wakelock) {
		dev_err(client->gxp->dev,
			"GXP_MAILBOX_UCI_RESPONSE requires the client hold a BLOCK wakelock\n");
		ret = -ENODEV;
		goto out;
	}

	ret = gxp_uci_wait_async_response(
		&client->vd->mailbox_resp_queues[UCI_RESOURCE_ID],
		&ibuf.sequence_number, &ibuf.error_code, ibuf.opaque);
	if (ret == -ENOENT || ret == -EAGAIN)
		goto out;

	if (copy_to_user(argp, &ibuf, sizeof(ibuf)))
		ret = -EFAULT;

out:
	up_read(&client->semaphore);

	return ret;
}

static int gxp_ioctl_set_device_properties(
	struct gxp_dev *gxp,
	struct gxp_set_device_properties_ioctl __user *argp)
{
	struct gxp_dev_prop *device_prop = &gxp->device_prop;
	struct gxp_set_device_properties_ioctl ibuf;

	if (copy_from_user(&ibuf, argp, sizeof(ibuf)))
		return -EFAULT;

	mutex_lock(&device_prop->lock);

	memcpy(&device_prop->opaque, &ibuf.opaque, sizeof(device_prop->opaque));
	device_prop->initialized = true;

	mutex_unlock(&device_prop->lock);

	return 0;
}

static int gxp_ioctl_create_iif_fence(struct gxp_client *client,
				      struct gxp_create_iif_fence_ioctl __user *argp)
{
	struct gxp_create_iif_fence_ioctl ibuf;
	int fd;

	if (copy_from_user(&ibuf, argp, sizeof(ibuf)))
		return -EFAULT;

	fd = gcip_fence_create_iif(client->gxp->iif_mgr, ibuf.signaler_ip, ibuf.total_signalers);
	if (fd < 0)
		return fd;

	ibuf.fence = fd;

	if (copy_to_user(argp, &ibuf, sizeof(ibuf)))
		return -EFAULT;

	return 0;
}

static int
gxp_ioctl_fence_remaining_signalers(struct gxp_client *client,
				    struct gxp_fence_remaining_signalers_ioctl __user *argp)
{
	struct gxp_fence_remaining_signalers_ioctl ibuf;
	struct gcip_fence_array *fences;
	int ret, num_fences;

	if (copy_from_user(&ibuf, argp, sizeof(ibuf)))
		return -EFAULT;

	num_fences = get_num_fences(ibuf.fences);
	if (num_fences < 0)
		return num_fences;

	fences = gcip_fence_array_create(ibuf.fences, num_fences, true);
	if (IS_ERR(fences))
		return PTR_ERR(fences);

	ret = gcip_fence_array_wait_signaler_submission(fences, ibuf.eventfd,
							ibuf.remaining_signalers);
	if (ret)
		goto out;

	if (copy_to_user(argp, &ibuf, sizeof(ibuf)))
		ret = -EFAULT;

out:
	gcip_fence_array_put(fences);
	return ret;
}

static inline enum gcip_telemetry_type to_gcip_telemetry_type(u8 type)
{
	if (type == GXP_TELEMETRY_TYPE_LOGGING)
		return GCIP_TELEMETRY_LOG;
	else
		return GCIP_TELEMETRY_TRACE;
}

static int
gxp_ioctl_register_mcu_telemetry_eventfd(struct gxp_client *client,
					 struct gxp_register_telemetry_eventfd_ioctl __user *argp)
{
	struct gxp_mcu *mcu = gxp_mcu_of(client->gxp);
	struct gxp_register_telemetry_eventfd_ioctl ibuf;

	if (copy_from_user(&ibuf, argp, sizeof(ibuf)))
		return -EFAULT;

	return gxp_mcu_telemetry_register_eventfd(
		mcu, to_gcip_telemetry_type(ibuf.type), ibuf.eventfd);
}

static int
gxp_ioctl_unregister_mcu_telemetry_eventfd(struct gxp_client *client,
					   struct gxp_register_telemetry_eventfd_ioctl __user *argp)
{
	struct gxp_mcu *mcu = gxp_mcu_of(client->gxp);
	struct gxp_register_telemetry_eventfd_ioctl ibuf;

	if (copy_from_user(&ibuf, argp, sizeof(ibuf)))
		return -EFAULT;

	return gxp_mcu_telemetry_unregister_eventfd(
		mcu, to_gcip_telemetry_type(ibuf.type));
}

long gxp_mcu_ioctl(struct file *file, uint cmd, ulong arg)
{
	struct gxp_client *client = file->private_data;
	void __user *argp = (void __user *)arg;
	long ret;

	if (gxp_is_direct_mode(client->gxp))
		return -ENOTTY;
	switch (cmd) {
	case GXP_MAILBOX_COMMAND:
		ret = -EOPNOTSUPP;
		break;
	case GXP_MAILBOX_RESPONSE:
		ret = -EOPNOTSUPP;
		break;
	case GXP_REGISTER_MCU_TELEMETRY_EVENTFD:
		ret = gxp_ioctl_register_mcu_telemetry_eventfd(client, argp);
		break;
	case GXP_UNREGISTER_MCU_TELEMETRY_EVENTFD:
		ret = gxp_ioctl_unregister_mcu_telemetry_eventfd(client, argp);
		break;
	case GXP_MAILBOX_UCI_COMMAND_COMPAT:
		ret = gxp_ioctl_uci_command_compat(client, argp);
		break;
	case GXP_MAILBOX_UCI_COMMAND:
		ret = gxp_ioctl_uci_command(client, argp);
		break;
	case GXP_MAILBOX_UCI_RESPONSE:
		ret = gxp_ioctl_uci_response(client, argp);
		break;
	case GXP_SET_DEVICE_PROPERTIES:
		ret = gxp_ioctl_set_device_properties(client->gxp, argp);
		break;
	case GXP_CREATE_IIF_FENCE:
		ret = gxp_ioctl_create_iif_fence(client, argp);
		break;
	case GXP_FENCE_REMAINING_SIGNALERS:
		ret = gxp_ioctl_fence_remaining_signalers(client, argp);
		break;
	default:
		ret = -ENOTTY; /* unknown command */
	}

	return ret;
}

int gxp_mcu_mmap(struct file *file, struct vm_area_struct *vma)
{
	struct gxp_client *client = file->private_data;
	struct gxp_mcu *mcu = gxp_mcu_of(client->gxp);
	int ret;

	if (gxp_is_direct_mode(client->gxp))
		return -EOPNOTSUPP;

	switch (vma->vm_pgoff << PAGE_SHIFT) {
	case GXP_MMAP_MCU_LOG_BUFFER_OFFSET:
		ret = gxp_mcu_telemetry_mmap_buffer(mcu, GCIP_TELEMETRY_LOG,
						    vma);
		break;
	case GXP_MMAP_MCU_TRACE_BUFFER_OFFSET:
		ret = gxp_mcu_telemetry_mmap_buffer(mcu, GCIP_TELEMETRY_TRACE,
						    vma);
		break;
	default:
		ret = -EOPNOTSUPP; /* unknown offset */
	}

	return ret;
}