// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2026 Intel Corporation
 * CVS driver - CSI/V4L2 subdev support
 */

#include <linux/cleanup.h>
#include <linux/device.h>
#include <linux/module.h>
#include <linux/pm_runtime.h>
#include <linux/property.h>

#include <media/v4l2-async.h>
#include <media/v4l2-common.h>
#include <media/v4l2-ctrls.h>
#include <media/v4l2-event.h>
#include <media/v4l2-fwnode.h>
#include <media/v4l2-mc.h>
#include <media/v4l2-subdev.h>

#include "icvs.h"

/*
 * Helpers
 */
static inline struct icvs *notifier_to_csi(struct v4l2_async_notifier *n)
{
        return container_of(n, struct icvs, notifier);
}

static inline struct icvs *sd_to_csi(struct v4l2_subdev *sd)
{
        return container_of(sd, struct icvs, subdev);
}

/*
 * Default formats
 */
static const struct v4l2_mbus_framefmt cvs_csi_format_mbus_default = {
        .width = 1,
        .height = 1,
        .code = MEDIA_BUS_FMT_Y8_1X8,
        .field = V4L2_FIELD_NONE,
};

/**
 * csi_set_link_cfg - Program default CSI-2 link parameters
 * @ctx: CVS device context
 *
 * Populates a HOST_SET_MIPI_CONFIG command using current lane count and
 * link frequency, then submits it to the device.
 * Rest of the link parameters are left at firmware defaults.
 *
 * Return: 0 on success or negative errno.
 */
static int csi_set_link_cfg(struct icvs *ctx)
{
        struct icvs_cmd cmd = {
                .cmd_id = cpu_to_be16(ICVS_HOST_SET_MIPI_CONFIG),
                .param.conf.nr_of_lanes = ctx->nr_of_lanes,
                .param.conf.link_freq = ctx->link_freq,
        };
        size_t cmd_size = sizeof(cmd.cmd_id) + sizeof(cmd.param.conf);

        guard(mutex)(&ctx->lock);
        return cvs_send(ctx, &cmd, cmd_size);
}

/*
 * Streaming
 */

/**
 * cvs_csi_enable_streams - Start streaming through the bridge
 * @sd: Sub-device pointer
 * @state: Active state
 * @pad: Pad identifier (must be ICVS_CSI_PAD_SOURCE)
 * @streams_mask: Streams to enable (bit 0 supported)
 *
 * Runtime-resumes the bridge (triggering cvs_runtime_resume() to claim CSI-2
 * link ownership), fetches the link frequency, programs the MIPI configuration,
 * and forwards the enable request downstream.
 *
 * Return: 0 on success or negative errno.
 */
static int cvs_csi_enable_streams(struct v4l2_subdev *sd,
                                  struct v4l2_subdev_state *state,
                                  u32 pad, u64 streams_mask)
{
        struct icvs *ctx = sd_to_csi(sd);
        struct v4l2_subdev *remote_sd =
                            media_entity_to_v4l2_subdev(ctx->remote->entity);
        struct device *dev = cvs_dev(ctx);
        s64 freq;
        int ret;

        /* cvs_set_link_owner(ICVS_CSI_LINK_HOST) */
        ret = pm_runtime_resume_and_get(dev);
        if (ret < 0)
                return ret;

        freq = v4l2_get_link_freq(ctx->remote, 0, 0);
        if (freq < 0) {
                ret = freq;
                goto err_rpm_put;
        }
        ctx->link_freq = freq;

        if (ctx->i2c_client) {
                ret = csi_set_link_cfg(ctx);
                if (ret < 0)
                        goto err_rpm_put_sync;
        }

        ret = v4l2_subdev_enable_streams(remote_sd,
                                         ctx->remote->index,
                                         streams_mask);
        if (ret)
                goto err_rpm_put_sync;

        return 0;

err_rpm_put_sync:
        /* Bypass autosuspend to immediately release ownership on error */
        pm_runtime_put_sync(dev);
        return ret;
err_rpm_put:
        pm_runtime_put_autosuspend(dev);
        return ret;
}

/**
 * cvs_csi_disable_streams - Stop streaming through the bridge
 * @sd: Sub-device pointer
 * @state: Active state
 * @pad: Pad identifier (must be ICVS_CSI_PAD_SOURCE)
 * @streams_mask: Streams to disable (bit 0 supported)
 *
 * Disables the remote sensor stream then drops the PM reference acquired
 * during enable. After the autosuspend delay, cvs_runtime_suspend() will
 * return CSI-2 link ownership to CVS firmware.
 *
 * Return: 0 on success or negative errno.
 */
static int cvs_csi_disable_streams(struct v4l2_subdev *sd,
                                   struct v4l2_subdev_state *state,
                                   u32 pad, u64 streams_mask)
{
        struct icvs *ctx = sd_to_csi(sd);
        struct v4l2_subdev *remote_sd =
                            media_entity_to_v4l2_subdev(ctx->remote->entity);
        struct device *dev = cvs_dev(ctx);
        int ret;

        ret = v4l2_subdev_disable_streams(remote_sd,
                                          ctx->remote->index,
                                          streams_mask);
        if (ret)
                dev_err(dev, "disable streams failed: %d\n", ret);

        /* cvs_set_link_owner(ICVS_CSI_LINK_CVS) */
        pm_runtime_put_autosuspend(dev);

        return ret;
}

/*
 * Pad operations / formats
 */
/**
 * cvs_csi_init_state - Initialize pad formats in subdev state
 * @sd: Sub-device
 * @state: State container
 *
 * Sets all pad formats to a minimal 1x1 default.
 *
 * Return: 0.
 */
static int cvs_csi_init_state(struct v4l2_subdev *sd,
                              struct v4l2_subdev_state *state)
{
        for (unsigned int i = 0; i < sd->entity.num_pads; i++)
                *v4l2_subdev_state_get_format(state, i) =
                        cvs_csi_format_mbus_default;

        return 0;
}

/**
 * cvs_csi_set_fmt - Negotiate pad format
 * @sd: Sub-device
 * @state: State
 * @format: Desired / returned format
 *
 * Mirrors sink format onto source pad. Accepts many media bus codes, falling
 * back to Y8 if unsupported. Normalizes field setting.
 *
 * Return: 0.
 */
static int cvs_csi_set_fmt(struct v4l2_subdev *sd,
                           struct v4l2_subdev_state *state,
                           struct v4l2_subdev_format *format)
{
        struct v4l2_mbus_framefmt *src =
                v4l2_subdev_state_get_format(state, ICVS_CSI_PAD_SOURCE);
        struct v4l2_mbus_framefmt *sink =
                v4l2_subdev_state_get_format(state, ICVS_CSI_PAD_SINK);

        if (format->pad == ICVS_CSI_PAD_SOURCE) { /* source pad mirrors sink */
                *src = *sink;
                return 0;
        }

        v4l_bound_align_image(&format->format.width, 1, 65536, 0,
                              &format->format.height, 1, 65536, 0, 0);

        switch (format->format.code) {
        /* Accept a large list; default fallback to Y8 */
        case MEDIA_BUS_FMT_RGB444_1X12:
        case MEDIA_BUS_FMT_RGB444_2X8_PADHI_BE:
        case MEDIA_BUS_FMT_RGB444_2X8_PADHI_LE:
        case MEDIA_BUS_FMT_RGB555_2X8_PADHI_BE:
        case MEDIA_BUS_FMT_RGB555_2X8_PADHI_LE:
        case MEDIA_BUS_FMT_RGB565_1X16:
        case MEDIA_BUS_FMT_BGR565_2X8_BE:
        case MEDIA_BUS_FMT_BGR565_2X8_LE:
        case MEDIA_BUS_FMT_RGB565_2X8_BE:
        case MEDIA_BUS_FMT_RGB565_2X8_LE:
        case MEDIA_BUS_FMT_RGB666_1X18:
        case MEDIA_BUS_FMT_RBG888_1X24:
        case MEDIA_BUS_FMT_RGB666_1X24_CPADHI:
        case MEDIA_BUS_FMT_BGR888_1X24:
        case MEDIA_BUS_FMT_GBR888_1X24:
        case MEDIA_BUS_FMT_RGB888_1X24:
        case MEDIA_BUS_FMT_RGB888_2X12_BE:
        case MEDIA_BUS_FMT_RGB888_2X12_LE:
        case MEDIA_BUS_FMT_ARGB8888_1X32:
        case MEDIA_BUS_FMT_RGB888_1X32_PADHI:
        case MEDIA_BUS_FMT_RGB101010_1X30:
        case MEDIA_BUS_FMT_RGB121212_1X36:
        case MEDIA_BUS_FMT_RGB161616_1X48:
        case MEDIA_BUS_FMT_Y8_1X8:
        case MEDIA_BUS_FMT_UV8_1X8:
        case MEDIA_BUS_FMT_UYVY8_1_5X8:
        case MEDIA_BUS_FMT_VYUY8_1_5X8:
        case MEDIA_BUS_FMT_YUYV8_1_5X8:
        case MEDIA_BUS_FMT_YVYU8_1_5X8:
        case MEDIA_BUS_FMT_UYVY8_2X8:
        case MEDIA_BUS_FMT_VYUY8_2X8:
        case MEDIA_BUS_FMT_YUYV8_2X8:
        case MEDIA_BUS_FMT_YVYU8_2X8:
        case MEDIA_BUS_FMT_Y10_1X10:
        case MEDIA_BUS_FMT_UYVY10_2X10:
        case MEDIA_BUS_FMT_VYUY10_2X10:
        case MEDIA_BUS_FMT_YUYV10_2X10:
        case MEDIA_BUS_FMT_YVYU10_2X10:
        case MEDIA_BUS_FMT_Y12_1X12:
        case MEDIA_BUS_FMT_UYVY12_2X12:
        case MEDIA_BUS_FMT_VYUY12_2X12:
        case MEDIA_BUS_FMT_YUYV12_2X12:
        case MEDIA_BUS_FMT_YVYU12_2X12:
        case MEDIA_BUS_FMT_UYVY8_1X16:
        case MEDIA_BUS_FMT_VYUY8_1X16:
        case MEDIA_BUS_FMT_YUYV8_1X16:
        case MEDIA_BUS_FMT_YVYU8_1X16:
        case MEDIA_BUS_FMT_YDYUYDYV8_1X16:
        case MEDIA_BUS_FMT_UYVY10_1X20:
        case MEDIA_BUS_FMT_VYUY10_1X20:
        case MEDIA_BUS_FMT_YUYV10_1X20:
        case MEDIA_BUS_FMT_YVYU10_1X20:
        case MEDIA_BUS_FMT_VUY8_1X24:
        case MEDIA_BUS_FMT_YUV8_1X24:
        case MEDIA_BUS_FMT_UYYVYY8_0_5X24:
        case MEDIA_BUS_FMT_UYVY12_1X24:
        case MEDIA_BUS_FMT_VYUY12_1X24:
        case MEDIA_BUS_FMT_YUYV12_1X24:
        case MEDIA_BUS_FMT_YVYU12_1X24:
        case MEDIA_BUS_FMT_YUV10_1X30:
        case MEDIA_BUS_FMT_UYYVYY10_0_5X30:
        case MEDIA_BUS_FMT_AYUV8_1X32:
        case MEDIA_BUS_FMT_UYYVYY12_0_5X36:
        case MEDIA_BUS_FMT_YUV12_1X36:
        case MEDIA_BUS_FMT_YUV16_1X48:
        case MEDIA_BUS_FMT_UYYVYY16_0_5X48:
        case MEDIA_BUS_FMT_JPEG_1X8:
        case MEDIA_BUS_FMT_AHSV8888_1X32:
        case MEDIA_BUS_FMT_SBGGR8_1X8:
        case MEDIA_BUS_FMT_SGBRG8_1X8:
        case MEDIA_BUS_FMT_SGRBG8_1X8:
        case MEDIA_BUS_FMT_SRGGB8_1X8:
        case MEDIA_BUS_FMT_SBGGR10_1X10:
        case MEDIA_BUS_FMT_SGBRG10_1X10:
        case MEDIA_BUS_FMT_SGRBG10_1X10:
        case MEDIA_BUS_FMT_SRGGB10_1X10:
        case MEDIA_BUS_FMT_SBGGR12_1X12:
        case MEDIA_BUS_FMT_SGBRG12_1X12:
        case MEDIA_BUS_FMT_SGRBG12_1X12:
        case MEDIA_BUS_FMT_SRGGB12_1X12:
        case MEDIA_BUS_FMT_SBGGR14_1X14:
        case MEDIA_BUS_FMT_SGBRG14_1X14:
        case MEDIA_BUS_FMT_SGRBG14_1X14:
        case MEDIA_BUS_FMT_SRGGB14_1X14:
        case MEDIA_BUS_FMT_SBGGR16_1X16:
        case MEDIA_BUS_FMT_SGBRG16_1X16:
        case MEDIA_BUS_FMT_SGRBG16_1X16:
        case MEDIA_BUS_FMT_SRGGB16_1X16:
                break;
        default:
                format->format.code = MEDIA_BUS_FMT_Y8_1X8;
                break;
        }

        if (format->format.field == V4L2_FIELD_ANY)
                format->format.field = V4L2_FIELD_NONE;

        *sink = format->format;
        *src = *sink;

        return 0;
}

/**
 * cvs_csi_get_mbus_config - Provide current CSI-2 bus configuration
 * @sd: Sub-device
 * @pad: Pad index
 * @cfg: Returned bus config
 *
 * Fills lane ordering and number of lanes; retrieves link frequency from
 * remote entity.
 *
 * Return: 0 on success or negative errno.
 */
static int cvs_csi_get_mbus_config(struct v4l2_subdev *sd, unsigned int pad,
                                   struct v4l2_mbus_config *cfg)
{
        struct icvs *ctx = sd_to_csi(sd);
        s64 freq;

        cfg->type = V4L2_MBUS_CSI2_DPHY;
        for (unsigned int i = 0; i < V4L2_MBUS_CSI2_MAX_DATA_LANES; i++)
                cfg->bus.mipi_csi2.data_lanes[i] = i + 1;
        cfg->bus.mipi_csi2.num_data_lanes = ctx->nr_of_lanes;

        freq = v4l2_get_link_freq(ctx->remote, 0, 0);
        if (freq < 0)
                return -EINVAL;

        ctx->link_freq = freq;
        cfg->link_freq = freq;

        return 0;
}

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

static const struct v4l2_subdev_video_ops cvs_csi_video_ops = {
        .s_stream = v4l2_subdev_s_stream_helper,
};

static const struct v4l2_subdev_pad_ops cvs_csi_pad_ops = {
        .get_fmt = v4l2_subdev_get_fmt,
        .set_fmt = cvs_csi_set_fmt,
        .get_mbus_config = cvs_csi_get_mbus_config,
        .enable_streams = cvs_csi_enable_streams,
        .disable_streams = cvs_csi_disable_streams,
};

static const struct v4l2_subdev_ops cvs_csi_subdev_ops = {
        .core = &cvs_csi_subdev_core_ops,
        .video = &cvs_csi_video_ops,
        .pad = &cvs_csi_pad_ops,
};

static const struct v4l2_subdev_internal_ops cvs_csi_internal_ops = {
        .init_state = cvs_csi_init_state,
};

static const struct media_entity_operations cvs_csi_entity_ops = {
        .link_validate = v4l2_subdev_link_validate,
};

/*
 * Async notifier
 */
/**
 * cvs_csi_notify_bound - Remote sensor bound callback
 * @notifier: Async notifier
 * @sd: Remote subdev
 * @asc: Async match connection
 *
 * Locates the source pad of the remote sensor and creates a media link to
 * the CVS bridge sink pad enabling it by default.
 *
 * Return: 0 on success or negative errno.
 */
static int cvs_csi_notify_bound(struct v4l2_async_notifier *notifier,
                                struct v4l2_subdev *sd,
                                struct v4l2_async_connection *asc)
{
        struct icvs *ctx = notifier_to_csi(notifier);
        int pad;

        pad = media_entity_get_fwnode_pad(&sd->entity, asc->match.fwnode,
                                          MEDIA_PAD_FL_SOURCE);
        if (pad < 0)
                return pad;

        ctx->remote = &sd->entity.pads[pad];

        return media_create_pad_link(&sd->entity, pad, &ctx->subdev.entity,
                                     ICVS_CSI_PAD_SINK, MEDIA_LNK_FL_ENABLED |
                                     MEDIA_LNK_FL_IMMUTABLE);
}

/**
 * cvs_csi_notify_unbind - Remote sensor unbind callback
 * @notifier: Notifier
 * @sd: Remote subdev
 * @asc: Connection
 */
static void cvs_csi_notify_unbind(struct v4l2_async_notifier *notifier,
                                  struct v4l2_subdev *sd,
                                  struct v4l2_async_connection *asc)
{
        struct icvs *ctx = notifier_to_csi(notifier);

        ctx->remote = NULL;
}

static const struct v4l2_async_notifier_operations cvs_csi_notify_ops = {
        .bound = cvs_csi_notify_bound,
        .unbind = cvs_csi_notify_unbind,
};

/*
 * Controls
 */
/**
 * cvs_csi_init_controls - Initialize V4L2 controls
 * @ctx: CVS context
 *
 * Currently sets up a read-only privacy control placeholder.
 *
 * Return: 0 on success or negative errno.
 */
static int cvs_csi_init_controls(struct icvs *ctx)
{
        struct v4l2_ctrl *privacy_ctrl;

        v4l2_ctrl_handler_init(&ctx->ctrl_handler, 1);

        privacy_ctrl = v4l2_ctrl_new_std(&ctx->ctrl_handler, NULL,
                                         V4L2_CID_PRIVACY, 0, 1, 1, 0);
        if (privacy_ctrl)
                privacy_ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
        if (ctx->ctrl_handler.error) {
                v4l2_ctrl_handler_free(&ctx->ctrl_handler);
                return ctx->ctrl_handler.error;
        }

        ctx->subdev.ctrl_handler = &ctx->ctrl_handler;

        return 0;
}

/*
 * Firmware (graph) parsing
 */
/**
 * cvs_csi_parse_firmware - Parse firmware (ACPI graph) endpoints
 * @ctx: CVS context
 *
 * Discovers sink and remote source endpoints, validates lane counts and
 * registers an async notifier for the remote sensor.
 *
 * Return: 0 on success or negative errno.
 */
static int cvs_csi_parse_firmware(struct icvs *ctx)
{
        struct v4l2_fwnode_endpoint ep = { .bus_type = V4L2_MBUS_CSI2_DPHY };
        struct device *dev = cvs_dev(ctx);
        struct fwnode_handle *sink_ep, *source_ep;
        struct v4l2_async_connection *asc;
        int ret;

        sink_ep = fwnode_graph_get_endpoint_by_id(dev_fwnode(dev), 0, 0, 0);
        v4l2_async_subdev_nf_init(&ctx->notifier, &ctx->subdev);
        ctx->notifier.ops = &cvs_csi_notify_ops;

        ret = v4l2_fwnode_endpoint_parse(sink_ep, &ep);
        if (ret)
                goto err_nf_cleanup;

        ctx->nr_of_lanes = ep.bus.mipi_csi2.num_data_lanes;
        source_ep = fwnode_graph_get_endpoint_by_id(dev_fwnode(dev), 1, 0, 0);
        ret = v4l2_fwnode_endpoint_parse(source_ep, &ep);
        fwnode_handle_put(source_ep);
        if (ret)
                goto err_nf_cleanup;

        if (ctx->nr_of_lanes != ep.bus.mipi_csi2.num_data_lanes) {
                ret = -EINVAL;
                goto err_nf_cleanup;
        }

        asc = v4l2_async_nf_add_fwnode_remote(&ctx->notifier, sink_ep,
                                              struct v4l2_async_connection);
        if (IS_ERR(asc)) {
                ret = PTR_ERR(asc);
                goto err_nf_cleanup;
        }

        ret = v4l2_async_nf_register(&ctx->notifier);
        if (ret)
                goto err_nf_cleanup;

        fwnode_handle_put(sink_ep);

        return 0;

err_nf_cleanup:
        v4l2_async_nf_cleanup(&ctx->notifier);
        fwnode_handle_put(sink_ep);

        return ret;
}

/*
 * Public CSI init/cleanup used by core probe/remove
 */
/**
 * cvs_csi_init - Initialize CSI/V4L2 sub-device side of bridge
 * @ctx: CVS context
 * @dev: Parent device
 * @i2c: I2C client (may be NULL for platform mode)
 *
 * Sets up sub-device, media entity pads, async notifier, controls and
 * registers with the V4L2 framework.
 *
 * Return: 0 on success or negative errno.
 */
int cvs_csi_init(struct icvs *ctx, struct device *dev, struct i2c_client *i2c)
{
        int ret;

        if (i2c) {
                v4l2_i2c_subdev_init(&ctx->subdev, i2c, &cvs_csi_subdev_ops);
        } else {
                v4l2_subdev_init(&ctx->subdev, &cvs_csi_subdev_ops);
                ctx->subdev.dev = dev;
        }

        ctx->subdev.internal_ops = &cvs_csi_internal_ops;
        v4l2_set_subdevdata(&ctx->subdev, ctx);
        ctx->subdev.flags = V4L2_SUBDEV_FL_HAS_DEVNODE;
        ctx->subdev.entity.function = MEDIA_ENT_F_VID_IF_BRIDGE;
        ctx->subdev.entity.ops = &cvs_csi_entity_ops;
        snprintf(ctx->subdev.name, sizeof(ctx->subdev.name), "Intel CVS");

        ret = cvs_csi_parse_firmware(ctx);
        if (ret)
                return ret;

        ret = cvs_csi_init_controls(ctx);
        if (ret)
                goto err_nf_unreg;

        ctx->pads[ICVS_CSI_PAD_SOURCE].flags = MEDIA_PAD_FL_SOURCE;
        ctx->pads[ICVS_CSI_PAD_SINK].flags = MEDIA_PAD_FL_SINK;
        ret = media_entity_pads_init(&ctx->subdev.entity, ICVS_CSI_NUM_PADS,
                                     ctx->pads);
        if (ret)
                goto err_ctrl_cleanup;

        ctx->subdev.state_lock = ctx->ctrl_handler.lock;
        ret = v4l2_subdev_init_finalize(&ctx->subdev);
        if (ret)
                goto err_entity_cleanup;

        ret = v4l2_async_register_subdev(&ctx->subdev);
        if (ret)
                goto err_entity_cleanup;

        return 0;

err_entity_cleanup:
        media_entity_cleanup(&ctx->subdev.entity);

err_ctrl_cleanup:
        v4l2_ctrl_handler_free(&ctx->ctrl_handler);

err_nf_unreg:
        v4l2_async_nf_unregister(&ctx->notifier);
        v4l2_async_nf_cleanup(&ctx->notifier);

        return ret;
}

/**
 * cvs_csi_remove - Cleanup CSI/V4L2 sub-device
 * @ctx: CVS context
 */
void cvs_csi_remove(struct icvs *ctx)
{
        v4l2_async_nf_unregister(&ctx->notifier);
        v4l2_async_nf_cleanup(&ctx->notifier);
        v4l2_ctrl_handler_free(&ctx->ctrl_handler);
        v4l2_async_unregister_subdev(&ctx->subdev);
        v4l2_subdev_cleanup(&ctx->subdev);
        media_entity_cleanup(&ctx->subdev.entity);
}

MODULE_AUTHOR("Miguel Vadillo <miguel.vadillo@intel.com>");
MODULE_DESCRIPTION("CSI/V4L2 support for Intel Vision Sensing Controller");
MODULE_LICENSE("GPL");