// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * vimc-core.c Virtual Media Controller Driver
 *
 * Copyright (C) 2015-2017 Helen Koike <helen.fornazier@gmail.com>
 */

#include <linux/dma-mapping.h>
#include <linux/font.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <media/media-device.h>
#include <media/tpg/v4l2-tpg.h>
#include <media/v4l2-device.h>

#include "vimc-common.h"

unsigned int vimc_allocator;
module_param_named(allocator, vimc_allocator, uint, 0444);
MODULE_PARM_DESC(allocator, " memory allocator selection, default is 0.\n"
                             "\t\t    0 == vmalloc\n"
                             "\t\t    1 == dma-contig");

#define VIMC_MDEV_MODEL_NAME "VIMC MDEV"

#define VIMC_DATA_LINK(src, srcpad, sink, sinkpad, link_flags) {        \
        .src_ent = src,                                         \
        .src_pad = srcpad,                                      \
        .sink_ent = sink,                                       \
        .sink_pad = sinkpad,                                    \
        .flags = link_flags,                                    \
}

#define VIMC_ANCILLARY_LINK(primary, ancillary) {       \
        .primary_ent = primary,                 \
        .ancillary_ent = ancillary              \
}

/* Structure which describes data links between entities */
struct vimc_data_link {
        unsigned int src_ent;
        u16 src_pad;
        unsigned int sink_ent;
        u16 sink_pad;
        u32 flags;
};

/* Enum to improve clarity when defining vimc_data_links */
enum vimc_data_link_ents {
        SENSOR_A,
        SENSOR_B,
        DEBAYER_A,
        DEBAYER_B,
        RAW_CAPTURE_0,
        RAW_CAPTURE_1,
        RGB_YUV_INPUT,
        SCALER,
        RGB_YUV_CAPTURE,
        LENS_A,
        LENS_B,
};

/* Structure which describes ancillary links between entities */
struct vimc_ancillary_link {
        unsigned int primary_ent;
        unsigned int ancillary_ent;
};

/* Structure which describes the whole topology */
struct vimc_pipeline_config {
        const struct vimc_ent_config *ents;
        size_t num_ents;
        const struct vimc_data_link *data_links;
        size_t num_data_links;
        const struct vimc_ancillary_link *ancillary_links;
        size_t num_ancillary_links;
};

/* --------------------------------------------------------------------------
 * Topology Configuration
 */

static const struct vimc_ent_config ent_config[] = {
        [SENSOR_A] = {
                .name = "Sensor A",
                .type = &vimc_sensor_type
        },
        [SENSOR_B] = {
                .name = "Sensor B",
                .type = &vimc_sensor_type
        },
        [DEBAYER_A] = {
                .name = "Debayer A",
                .type = &vimc_debayer_type
        },
        [DEBAYER_B] = {
                .name = "Debayer B",
                .type = &vimc_debayer_type
        },
        [RAW_CAPTURE_0] = {
                .name = "Raw Capture 0",
                .type = &vimc_capture_type
        },
        [RAW_CAPTURE_1] = {
                .name = "Raw Capture 1",
                .type = &vimc_capture_type
        },
        [RGB_YUV_INPUT] = {
                /* TODO: change this to vimc-input when it is implemented */
                .name = "RGB/YUV Input",
                .type = &vimc_sensor_type
        },
        [SCALER] = {
                .name = "Scaler",
                .type = &vimc_scaler_type
        },
        [RGB_YUV_CAPTURE] = {
                .name = "RGB/YUV Capture",
                .type = &vimc_capture_type
        },
        [LENS_A] = {
                .name = "Lens A",
                .type = &vimc_lens_type
        },
        [LENS_B] = {
                .name = "Lens B",
                .type = &vimc_lens_type
        },
};

static const struct vimc_data_link data_links[] = {
        /* Link: Sensor A (Pad 0)->(Pad 0) Debayer A */
        VIMC_DATA_LINK(SENSOR_A, 0, DEBAYER_A, 0,
                       MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE),
        /* Link: Sensor A (Pad 0)->(Pad 0) Raw Capture 0 */
        VIMC_DATA_LINK(SENSOR_A, 0, RAW_CAPTURE_0, 0,
                       MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE),
        /* Link: Sensor B (Pad 0)->(Pad 0) Debayer B */
        VIMC_DATA_LINK(SENSOR_B, 0, DEBAYER_B, 0,
                       MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE),
        /* Link: Sensor B (Pad 0)->(Pad 0) Raw Capture 1 */
        VIMC_DATA_LINK(SENSOR_B, 0, RAW_CAPTURE_1, 0,
                       MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE),
        /* Link: Debayer A (Pad 1)->(Pad 0) Scaler */
        VIMC_DATA_LINK(DEBAYER_A, 1, SCALER, 0, MEDIA_LNK_FL_ENABLED),
        /* Link: Debayer B (Pad 1)->(Pad 0) Scaler */
        VIMC_DATA_LINK(DEBAYER_B, 1, SCALER, 0, 0),
        /* Link: RGB/YUV Input (Pad 0)->(Pad 0) Scaler */
        VIMC_DATA_LINK(RGB_YUV_INPUT, 0, SCALER, 0, 0),
        /* Link: Scaler (Pad 1)->(Pad 0) RGB/YUV Capture */
        VIMC_DATA_LINK(SCALER, 1, RGB_YUV_CAPTURE, 0,
                       MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE),
};

static const struct vimc_ancillary_link ancillary_links[] = {
        /* Link: Sensor A -> Lens A */
        VIMC_ANCILLARY_LINK(0, 9),
        /* Link: Sensor B -> Lens B */
        VIMC_ANCILLARY_LINK(1, 10),
};

static struct vimc_pipeline_config pipe_cfg = {
        .ents                = ent_config,
        .num_ents            = ARRAY_SIZE(ent_config),
        .data_links          = data_links,
        .num_data_links      = ARRAY_SIZE(data_links),
        .ancillary_links     = ancillary_links,
        .num_ancillary_links = ARRAY_SIZE(ancillary_links),
};

/* -------------------------------------------------------------------------- */

static void vimc_rm_links(struct vimc_device *vimc)
{
        unsigned int i;

        for (i = 0; i < vimc->pipe_cfg->num_ents; i++)
                media_entity_remove_links(vimc->ent_devs[i]->ent);
}

static int vimc_create_links(struct vimc_device *vimc)
{
        unsigned int i;
        int ret;

        /* Initialize the links between entities */
        for (i = 0; i < vimc->pipe_cfg->num_data_links; i++) {
                const struct vimc_data_link *link = &vimc->pipe_cfg->data_links[i];

                struct vimc_ent_device *ved_src =
                        vimc->ent_devs[link->src_ent];
                struct vimc_ent_device *ved_sink =
                        vimc->ent_devs[link->sink_ent];

                ret = media_create_pad_link(ved_src->ent, link->src_pad,
                                            ved_sink->ent, link->sink_pad,
                                            link->flags);
                if (ret)
                        goto err_rm_links;
        }

        for (i = 0; i < vimc->pipe_cfg->num_ancillary_links; i++) {
                const struct vimc_ancillary_link *link = &vimc->pipe_cfg->ancillary_links[i];

                struct vimc_ent_device *ved_primary =
                        vimc->ent_devs[link->primary_ent];
                struct vimc_ent_device *ved_ancillary =
                        vimc->ent_devs[link->ancillary_ent];
                struct media_link *ret_link =
                        media_create_ancillary_link(ved_primary->ent, ved_ancillary->ent);

                if (IS_ERR(ret_link)) {
                        ret = PTR_ERR(ret_link);
                        goto err_rm_links;
                }
        }

        return 0;

err_rm_links:
        vimc_rm_links(vimc);
        return ret;
}

static void vimc_release_subdevs(struct vimc_device *vimc)
{
        unsigned int i;

        for (i = 0; i < vimc->pipe_cfg->num_ents; i++)
                if (vimc->ent_devs[i])
                        vimc->pipe_cfg->ents[i].type->release(vimc->ent_devs[i]);
}

static void vimc_unregister_subdevs(struct vimc_device *vimc)
{
        unsigned int i;

        for (i = 0; i < vimc->pipe_cfg->num_ents; i++)
                if (vimc->ent_devs[i] && vimc->pipe_cfg->ents[i].type->unregister)
                        vimc->pipe_cfg->ents[i].type->unregister(vimc->ent_devs[i]);
}

static int vimc_add_subdevs(struct vimc_device *vimc)
{
        unsigned int i;

        for (i = 0; i < vimc->pipe_cfg->num_ents; i++) {
                dev_dbg(vimc->mdev.dev, "new entity for %s\n",
                        vimc->pipe_cfg->ents[i].name);
                vimc->ent_devs[i] = vimc->pipe_cfg->ents[i].type->add(vimc,
                                        vimc->pipe_cfg->ents[i].name);
                if (IS_ERR(vimc->ent_devs[i])) {
                        int err = PTR_ERR(vimc->ent_devs[i]);

                        dev_err(vimc->mdev.dev, "adding entity %s failed (%d)\n",
                                vimc->pipe_cfg->ents[i].name, err);
                        vimc->ent_devs[i] = NULL;
                        vimc_unregister_subdevs(vimc);
                        vimc_release_subdevs(vimc);
                        return err;
                }
        }
        return 0;
}

static void vimc_v4l2_dev_release(struct v4l2_device *v4l2_dev)
{
        struct vimc_device *vimc =
                container_of(v4l2_dev, struct vimc_device, v4l2_dev);

        vimc_release_subdevs(vimc);
        media_device_cleanup(&vimc->mdev);
        kfree(vimc->ent_devs);
        kfree(vimc);
}

static int vimc_register_devices(struct vimc_device *vimc)
{
        int ret;

        /* Register the v4l2 struct */
        ret = v4l2_device_register(vimc->mdev.dev, &vimc->v4l2_dev);
        if (ret) {
                dev_err(vimc->mdev.dev,
                        "v4l2 device register failed (err=%d)\n", ret);
                return ret;
        }
        /* allocate ent_devs */
        vimc->ent_devs = kzalloc_objs(*vimc->ent_devs, vimc->pipe_cfg->num_ents);
        if (!vimc->ent_devs) {
                ret = -ENOMEM;
                goto err_v4l2_unregister;
        }

        /* Invoke entity config hooks to initialize and register subdevs */
        ret = vimc_add_subdevs(vimc);
        if (ret)
                goto err_free_ent_devs;

        /* Initialize links */
        ret = vimc_create_links(vimc);
        if (ret)
                goto err_rm_subdevs;

        /* Register the media device */
        ret = media_device_register(&vimc->mdev);
        if (ret) {
                dev_err(vimc->mdev.dev,
                        "media device register failed (err=%d)\n", ret);
                goto err_rm_subdevs;
        }

        /* Expose all subdev's nodes*/
        ret = v4l2_device_register_subdev_nodes(&vimc->v4l2_dev);
        if (ret) {
                dev_err(vimc->mdev.dev,
                        "vimc subdev nodes registration failed (err=%d)\n",
                        ret);
                goto err_mdev_unregister;
        }

        return 0;

err_mdev_unregister:
        media_device_unregister(&vimc->mdev);
err_rm_subdevs:
        vimc_unregister_subdevs(vimc);
        vimc_release_subdevs(vimc);
err_free_ent_devs:
        kfree(vimc->ent_devs);
err_v4l2_unregister:
        v4l2_device_unregister(&vimc->v4l2_dev);

        return ret;
}

static int vimc_probe(struct platform_device *pdev)
{
        const struct font_desc *font = find_font("VGA8x16");
        struct vimc_device *vimc;
        int ret;

        dev_dbg(&pdev->dev, "probe");

        if (!font) {
                dev_err(&pdev->dev, "could not find font\n");
                return -ENODEV;
        }

        tpg_set_font(font->data);

        if (vimc_allocator == VIMC_ALLOCATOR_DMA_CONTIG)
                dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));

        vimc = kzalloc_obj(*vimc);
        if (!vimc)
                return -ENOMEM;

        vimc->pipe_cfg = &pipe_cfg;

        /* Link the media device within the v4l2_device */
        vimc->v4l2_dev.mdev = &vimc->mdev;

        /* Initialize media device */
        strscpy(vimc->mdev.model, VIMC_MDEV_MODEL_NAME,
                sizeof(vimc->mdev.model));
        vimc->mdev.dev = &pdev->dev;
        media_device_init(&vimc->mdev);

        ret = vimc_register_devices(vimc);
        if (ret) {
                media_device_cleanup(&vimc->mdev);
                kfree(vimc);
                return ret;
        }
        /*
         * the release cb is set only after successful registration.
         * if the registration fails, we release directly from probe
         */

        vimc->v4l2_dev.release = vimc_v4l2_dev_release;
        platform_set_drvdata(pdev, vimc);
        return 0;
}

static void vimc_remove(struct platform_device *pdev)
{
        struct vimc_device *vimc = platform_get_drvdata(pdev);

        dev_dbg(&pdev->dev, "remove");

        vimc_unregister_subdevs(vimc);
        media_device_unregister(&vimc->mdev);
        v4l2_device_unregister(&vimc->v4l2_dev);
        v4l2_device_put(&vimc->v4l2_dev);
}

static void vimc_dev_release(struct device *dev)
{
}

static struct platform_device vimc_pdev = {
        .name = VIMC_PDEV_NAME,
        .dev.release = vimc_dev_release,
};

static struct platform_driver vimc_pdrv = {
        .probe          = vimc_probe,
        .remove         = vimc_remove,
        .driver         = {
                .name   = VIMC_PDEV_NAME,
        },
};

static int __init vimc_init(void)
{
        int ret;

        ret = platform_device_register(&vimc_pdev);
        if (ret) {
                dev_err(&vimc_pdev.dev,
                        "platform device registration failed (err=%d)\n", ret);
                return ret;
        }

        ret = platform_driver_register(&vimc_pdrv);
        if (ret) {
                dev_err(&vimc_pdev.dev,
                        "platform driver registration failed (err=%d)\n", ret);
                platform_device_unregister(&vimc_pdev);
                return ret;
        }

        return 0;
}

static void __exit vimc_exit(void)
{
        platform_driver_unregister(&vimc_pdrv);

        platform_device_unregister(&vimc_pdev);
}

module_init(vimc_init);
module_exit(vimc_exit);

MODULE_DESCRIPTION("Virtual Media Controller Driver (VIMC)");
MODULE_AUTHOR("Helen Fornazier <helen.fornazier@gmail.com>");
MODULE_LICENSE("GPL");