// SPDX-License-Identifier: GPL-2.0
/*
 * Renesas RZ/V2H(P) Input Video Control Block driver
 *
 * Copyright (C) 2025 Ideas on Board Oy
 */

#include "rzv2h-ivc.h"

#include <linux/media.h>
#include <linux/media-bus-format.h>
#include <linux/v4l2-mediabus.h>

#include <media/v4l2-async.h>
#include <media/v4l2-ctrls.h>
#include <media/v4l2-dev.h>
#include <media/v4l2-event.h>

#define RZV2H_IVC_N_INPUTS_PER_OUTPUT		6

/*
 * We support 8/10/12/14/16/20 bit input in any bayer order, but the output
 * format is fixed at 20-bits with the same order as the input.
 */
static const struct {
	u32 inputs[RZV2H_IVC_N_INPUTS_PER_OUTPUT];
	u32 output;
} rzv2h_ivc_formats[] = {
	{
		.inputs = {
			MEDIA_BUS_FMT_SBGGR8_1X8,
			MEDIA_BUS_FMT_SBGGR10_1X10,
			MEDIA_BUS_FMT_SBGGR12_1X12,
			MEDIA_BUS_FMT_SBGGR14_1X14,
			MEDIA_BUS_FMT_SBGGR16_1X16,
			MEDIA_BUS_FMT_SBGGR20_1X20,
		},
		.output = MEDIA_BUS_FMT_SBGGR20_1X20
	},
	{
		.inputs = {
			MEDIA_BUS_FMT_SGBRG8_1X8,
			MEDIA_BUS_FMT_SGBRG10_1X10,
			MEDIA_BUS_FMT_SGBRG12_1X12,
			MEDIA_BUS_FMT_SGBRG14_1X14,
			MEDIA_BUS_FMT_SGBRG16_1X16,
			MEDIA_BUS_FMT_SGBRG20_1X20,
		},
		.output = MEDIA_BUS_FMT_SGBRG20_1X20
	},
	{
		.inputs = {
			MEDIA_BUS_FMT_SGRBG8_1X8,
			MEDIA_BUS_FMT_SGRBG10_1X10,
			MEDIA_BUS_FMT_SGRBG12_1X12,
			MEDIA_BUS_FMT_SGRBG14_1X14,
			MEDIA_BUS_FMT_SGRBG16_1X16,
			MEDIA_BUS_FMT_SGRBG20_1X20,
		},
		.output = MEDIA_BUS_FMT_SGRBG20_1X20
	},
	{
		.inputs = {
			MEDIA_BUS_FMT_SRGGB8_1X8,
			MEDIA_BUS_FMT_SRGGB10_1X10,
			MEDIA_BUS_FMT_SRGGB12_1X12,
			MEDIA_BUS_FMT_SRGGB14_1X14,
			MEDIA_BUS_FMT_SRGGB16_1X16,
			MEDIA_BUS_FMT_SRGGB20_1X20,
		},
		.output = MEDIA_BUS_FMT_SRGGB20_1X20
	},
};

static u32 rzv2h_ivc_get_mbus_output_from_input(u32 mbus_code)
{
	unsigned int i, j;

	for (i = 0; i < ARRAY_SIZE(rzv2h_ivc_formats); i++) {
		for (j = 0; j < RZV2H_IVC_N_INPUTS_PER_OUTPUT; j++) {
			if (rzv2h_ivc_formats[i].inputs[j] == mbus_code)
				return rzv2h_ivc_formats[i].output;
		}
	}

	return 0;
}

static int rzv2h_ivc_enum_mbus_code(struct v4l2_subdev *sd,
				    struct v4l2_subdev_state *state,
				    struct v4l2_subdev_mbus_code_enum *code)
{
	const struct v4l2_mbus_framefmt *fmt;
	unsigned int order_index;
	unsigned int index;

	/*
	 * On the source pad, only the 20-bit format corresponding to the sink
	 * pad format's bayer order is supported.
	 */
	if (code->pad == RZV2H_IVC_SUBDEV_SOURCE_PAD) {
		if (code->index)
			return -EINVAL;

		fmt = v4l2_subdev_state_get_format(state,
						   RZV2H_IVC_SUBDEV_SINK_PAD);
		code->code = rzv2h_ivc_get_mbus_output_from_input(fmt->code);

		return 0;
	}

	if (code->index >= ARRAY_SIZE(rzv2h_ivc_formats) *
				      RZV2H_IVC_N_INPUTS_PER_OUTPUT)
		return -EINVAL;

	order_index = code->index / RZV2H_IVC_N_INPUTS_PER_OUTPUT;
	index = code->index % RZV2H_IVC_N_INPUTS_PER_OUTPUT;

	code->code = rzv2h_ivc_formats[order_index].inputs[index];

	return 0;
}

static int rzv2h_ivc_enum_frame_size(struct v4l2_subdev *sd,
				     struct v4l2_subdev_state *state,
				     struct v4l2_subdev_frame_size_enum *fse)
{
	const struct v4l2_mbus_framefmt *fmt;

	if (fse->index > 0)
		return -EINVAL;

	if (fse->pad == RZV2H_IVC_SUBDEV_SOURCE_PAD) {
		fmt = v4l2_subdev_state_get_format(state,
						   RZV2H_IVC_SUBDEV_SINK_PAD);

		if (fse->code != rzv2h_ivc_get_mbus_output_from_input(fmt->code))
			return -EINVAL;

		fse->min_width = fmt->width;
		fse->max_width = fmt->width;
		fse->min_height = fmt->height;
		fse->max_height = fmt->height;

		return 0;
	}

	if (!rzv2h_ivc_get_mbus_output_from_input(fse->code))
		return -EINVAL;

	fse->min_width = RZV2H_IVC_MIN_WIDTH;
	fse->max_width = RZV2H_IVC_MAX_WIDTH;
	fse->min_height = RZV2H_IVC_MIN_HEIGHT;
	fse->max_height = RZV2H_IVC_MAX_HEIGHT;

	return 0;
}

static int rzv2h_ivc_set_fmt(struct v4l2_subdev *sd,
			     struct v4l2_subdev_state *state,
			     struct v4l2_subdev_format *format)
{
	struct v4l2_mbus_framefmt *fmt = &format->format;
	struct v4l2_mbus_framefmt *src_fmt, *sink_fmt;

	if (format->pad == RZV2H_IVC_SUBDEV_SOURCE_PAD)
		return v4l2_subdev_get_fmt(sd, state, format);

	sink_fmt = v4l2_subdev_state_get_format(state,
						RZV2H_IVC_SUBDEV_SINK_PAD);

	sink_fmt->code = rzv2h_ivc_get_mbus_output_from_input(fmt->code) ?
			 fmt->code : rzv2h_ivc_formats[0].inputs[0];

	sink_fmt->width = clamp(fmt->width, RZV2H_IVC_MIN_WIDTH,
				RZV2H_IVC_MAX_WIDTH);
	sink_fmt->height = clamp(fmt->height, RZV2H_IVC_MIN_HEIGHT,
				 RZV2H_IVC_MAX_HEIGHT);

	*fmt = *sink_fmt;

	src_fmt = v4l2_subdev_state_get_format(state,
					       RZV2H_IVC_SUBDEV_SOURCE_PAD);
	*src_fmt = *sink_fmt;
	src_fmt->code = rzv2h_ivc_get_mbus_output_from_input(sink_fmt->code);

	return 0;
}

static int rzv2h_ivc_enable_streams(struct v4l2_subdev *sd,
				    struct v4l2_subdev_state *state, u32 pad,
				    u64 streams_mask)
{
	/*
	 * We have a single source pad, which has a single stream. V4L2 core has
	 * already validated those things. The actual power-on and programming
	 * of registers will be done through the video device's .vidioc_streamon
	 * so there's nothing to actually do here...
	 */

	return 0;
}

static int rzv2h_ivc_disable_streams(struct v4l2_subdev *sd,
				     struct v4l2_subdev_state *state, u32 pad,
				     u64 streams_mask)
{
	return 0;
}

static const struct v4l2_subdev_pad_ops rzv2h_ivc_pad_ops = {
	.enum_mbus_code		= rzv2h_ivc_enum_mbus_code,
	.enum_frame_size	= rzv2h_ivc_enum_frame_size,
	.get_fmt		= v4l2_subdev_get_fmt,
	.set_fmt		= rzv2h_ivc_set_fmt,
	.enable_streams		= rzv2h_ivc_enable_streams,
	.disable_streams	= rzv2h_ivc_disable_streams,
};

static const struct v4l2_subdev_core_ops rzv2h_ivc_core_ops = {
	.subscribe_event = v4l2_ctrl_subdev_subscribe_event,
	.unsubscribe_event = v4l2_event_subdev_unsubscribe,
};

static const struct v4l2_subdev_ops rzv2h_ivc_subdev_ops = {
	.core	= &rzv2h_ivc_core_ops,
	.pad	= &rzv2h_ivc_pad_ops,
};

static int rzv2h_ivc_init_state(struct v4l2_subdev *sd,
				struct v4l2_subdev_state *state)
{
	struct v4l2_mbus_framefmt *sink_fmt, *src_fmt;

	sink_fmt = v4l2_subdev_state_get_format(state,
						RZV2H_IVC_SUBDEV_SINK_PAD);
	sink_fmt->width = RZV2H_IVC_DEFAULT_WIDTH;
	sink_fmt->height = RZV2H_IVC_DEFAULT_HEIGHT;
	sink_fmt->field = V4L2_FIELD_NONE;
	sink_fmt->code = MEDIA_BUS_FMT_SRGGB16_1X16;
	sink_fmt->colorspace = V4L2_COLORSPACE_RAW;
	sink_fmt->xfer_func = V4L2_MAP_XFER_FUNC_DEFAULT(sink_fmt->colorspace);
	sink_fmt->ycbcr_enc = V4L2_MAP_YCBCR_ENC_DEFAULT(sink_fmt->colorspace);
	sink_fmt->quantization = V4L2_MAP_QUANTIZATION_DEFAULT(true,
							sink_fmt->colorspace,
							sink_fmt->ycbcr_enc);

	src_fmt = v4l2_subdev_state_get_format(state,
					       RZV2H_IVC_SUBDEV_SOURCE_PAD);

	*src_fmt = *sink_fmt;
	src_fmt->code = MEDIA_BUS_FMT_SRGGB20_1X20;

	return 0;
}

static int rzv2h_ivc_registered(struct v4l2_subdev *sd)
{
	struct rzv2h_ivc *ivc = container_of(sd, struct rzv2h_ivc, subdev.sd);

	return rzv2h_ivc_init_vdev(ivc, sd->v4l2_dev);
}

static const struct v4l2_subdev_internal_ops rzv2h_ivc_subdev_internal_ops = {
	.init_state = rzv2h_ivc_init_state,
	.registered = rzv2h_ivc_registered,
};

static int rzv2h_ivc_link_validate(struct media_link *link)
{
	struct video_device *vdev =
		media_entity_to_video_device(link->source->entity);
	struct rzv2h_ivc *ivc = video_get_drvdata(vdev);
	struct v4l2_subdev *sd =
		media_entity_to_v4l2_subdev(link->sink->entity);
	const struct rzv2h_ivc_format *fmt;
	const struct v4l2_pix_format_mplane *pix;
	struct v4l2_subdev_state *state;
	struct v4l2_mbus_framefmt *mf;
	unsigned int i;
	int ret = 0;

	state = v4l2_subdev_lock_and_get_active_state(sd);
	mf = v4l2_subdev_state_get_format(state, link->sink->index);

	pix = &ivc->format.pix;
	fmt = ivc->format.fmt;

	if (mf->width != pix->width || mf->height != pix->height) {
		dev_dbg(ivc->dev,
			"link '%s':%u -> '%s':%u not valid: %ux%u != %ux%u\n",
			link->source->entity->name, link->source->index,
			link->sink->entity->name, link->sink->index,
			mf->width, mf->height, pix->width, pix->height);
		ret = -EPIPE;
	}

	for (i = 0; i < ARRAY_SIZE(fmt->mbus_codes); i++)
		if (mf->code == fmt->mbus_codes[i])
			break;

	if (i == ARRAY_SIZE(fmt->mbus_codes)) {
		dev_dbg(ivc->dev,
			"link '%s':%u -> '%s':%u not valid: pixel format %p4cc cannot produce mbus_code 0x%04x\n",
			link->source->entity->name, link->source->index,
			link->sink->entity->name, link->sink->index,
			&pix->pixelformat, mf->code);
		ret = -EPIPE;
	}

	v4l2_subdev_unlock_state(state);

	return ret;
}

static const struct media_entity_operations rzv2h_ivc_media_ops = {
	.link_validate = rzv2h_ivc_link_validate,
};

int rzv2h_ivc_initialise_subdevice(struct rzv2h_ivc *ivc)
{
	struct v4l2_subdev *sd;
	int ret;

	/* Initialise subdevice */
	sd = &ivc->subdev.sd;
	sd->dev = ivc->dev;
	v4l2_subdev_init(sd, &rzv2h_ivc_subdev_ops);
	sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE | V4L2_SUBDEV_FL_HAS_EVENTS;
	sd->entity.function = MEDIA_ENT_F_PROC_VIDEO_PIXEL_FORMATTER;
	sd->internal_ops = &rzv2h_ivc_subdev_internal_ops;
	sd->entity.ops = &rzv2h_ivc_media_ops;

	ivc->subdev.pads[RZV2H_IVC_SUBDEV_SINK_PAD].flags = MEDIA_PAD_FL_SINK;
	ivc->subdev.pads[RZV2H_IVC_SUBDEV_SOURCE_PAD].flags = MEDIA_PAD_FL_SOURCE;

	snprintf(sd->name, sizeof(sd->name), "rzv2h ivc block");

	ret = media_entity_pads_init(&sd->entity, RZV2H_IVC_NUM_SUBDEV_PADS,
				     ivc->subdev.pads);
	if (ret) {
		dev_err(ivc->dev, "failed to initialise media entity\n");
		return ret;
	}

	ret = v4l2_subdev_init_finalize(sd);
	if (ret) {
		dev_err(ivc->dev, "failed to finalize subdev init\n");
		goto err_cleanup_subdev_entity;
	}

	ret = v4l2_async_register_subdev(sd);
	if (ret) {
		dev_err(ivc->dev, "failed to register subdevice\n");
		goto err_cleanup_subdev;
	}

	return 0;

err_cleanup_subdev:
	v4l2_subdev_cleanup(sd);
err_cleanup_subdev_entity:
	media_entity_cleanup(&sd->entity);

	return ret;
}

void rzv2h_ivc_deinit_subdevice(struct rzv2h_ivc *ivc)
{
	struct v4l2_subdev *sd = &ivc->subdev.sd;

	v4l2_subdev_cleanup(sd);
	media_entity_remove_links(&sd->entity);
	v4l2_async_unregister_subdev(sd);
	media_entity_cleanup(&sd->entity);
}