// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright 2024 NXP
 */

#include <linux/component.h>
#include <linux/mod_devicetable.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>

#include "dc-drv.h"
#include "dc-de.h"

#define TCON_CTRL       0x410
#define  CTRL_RST_VAL   0x01401408

/* red: MAPBIT 29-20, green: MAPBIT 19-10, blue: MAPBIT 9-0 */
#define MAPBIT3_0       0x418
#define MAPBIT7_4       0x41c
#define MAPBIT11_8      0x420
#define MAPBIT15_12     0x424
#define MAPBIT19_16     0x428
#define MAPBIT23_20     0x42c
#define MAPBIT27_24     0x430
#define MAPBIT31_28     0x434

static const struct dc_subdev_info dc_tc_info[] = {
        { .reg_start = 0x5618c800, .id = 0, },
        { .reg_start = 0x5618e400, .id = 1, },
};

static const struct regmap_range dc_tc_regmap_ranges[] = {
        regmap_reg_range(TCON_CTRL, TCON_CTRL),
        regmap_reg_range(MAPBIT3_0, MAPBIT31_28),
};

static const struct regmap_access_table dc_tc_regmap_access_table = {
        .yes_ranges = dc_tc_regmap_ranges,
        .n_yes_ranges = ARRAY_SIZE(dc_tc_regmap_ranges),
};

static const struct regmap_config dc_tc_regmap_config = {
        .reg_bits = 32,
        .reg_stride = 4,
        .val_bits = 32,
        .fast_io = true,
        .wr_table = &dc_tc_regmap_access_table,
        .rd_table = &dc_tc_regmap_access_table,
        .max_register = MAPBIT31_28,
};

/*
 * The pixels reach TCON are always in 30-bit BGR format.
 * The first bridge always receives pixels in 30-bit RGB format.
 * So, map the format to MEDIA_BUS_FMT_RGB101010_1X30.
 */
static const u32 dc_tc_mapbit[] = {
        0x17161514, 0x1b1a1918, 0x0b0a1d1c, 0x0f0e0d0c,
        0x13121110, 0x03020100, 0x07060504, 0x00000908,
};

void dc_tc_init(struct dc_tc *tc)
{
        /* reset TCON_CTRL to POR default so that TCON works in bypass mode */
        regmap_write(tc->reg, TCON_CTRL, CTRL_RST_VAL);

        /* set format */
        regmap_bulk_write(tc->reg, MAPBIT3_0, dc_tc_mapbit,
                          ARRAY_SIZE(dc_tc_mapbit));
}

static int dc_tc_bind(struct device *dev, struct device *master, void *data)
{
        struct platform_device *pdev = to_platform_device(dev);
        struct dc_drm_device *dc_drm = data;
        struct resource *res;
        void __iomem *base;
        struct dc_tc *tc;
        int id;

        tc = devm_kzalloc(dev, sizeof(*tc), GFP_KERNEL);
        if (!tc)
                return -ENOMEM;

        base = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
        if (IS_ERR(base))
                return PTR_ERR(base);

        tc->reg = devm_regmap_init_mmio(dev, base, &dc_tc_regmap_config);
        if (IS_ERR(tc->reg))
                return PTR_ERR(tc->reg);

        id = dc_subdev_get_id(dc_tc_info, ARRAY_SIZE(dc_tc_info), res);
        if (id < 0) {
                dev_err(dev, "failed to get instance number: %d\n", id);
                return id;
        }

        tc->dev = dev;
        dc_drm->tc[id] = tc;

        return 0;
}

static const struct component_ops dc_tc_ops = {
        .bind = dc_tc_bind,
};

static int dc_tc_probe(struct platform_device *pdev)
{
        int ret;

        ret = component_add(&pdev->dev, &dc_tc_ops);
        if (ret)
                return dev_err_probe(&pdev->dev, ret,
                                     "failed to add component\n");

        return 0;
}

static void dc_tc_remove(struct platform_device *pdev)
{
        component_del(&pdev->dev, &dc_tc_ops);
}

static const struct of_device_id dc_tc_dt_ids[] = {
        { .compatible = "fsl,imx8qxp-dc-tcon" },
        { /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, dc_tc_dt_ids);

struct platform_driver dc_tc_driver = {
        .probe = dc_tc_probe,
        .remove = dc_tc_remove,
        .driver = {
                .name = "imx8-dc-tcon",
                .suppress_bind_attrs = true,
                .of_match_table = dc_tc_dt_ids,
        },
};