// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2020 Rockchip Electronics Co., Ltd.
 *
 * Author: Algea Cao <algea.cao@rock-chips.com>
 */

#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/mfd/rk630.h>
#include <linux/mfd/syscon.h>

#include <drm/drm_atomic_helper.h>
#include <drm/drm_crtc_helper.h>
#include <drm/drm_of.h>
#include <drm/drm_probe_helper.h>

#include "../rockchip/rockchip_drm_drv.h"

static const struct drm_display_mode rk630_tve_mode[2] = {
	{ DRM_MODE("720x576i", DRM_MODE_TYPE_DRIVER, 13500, 720, 753,
		   816, 864, 0, 576, 580, 586, 625, 0,
		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
		   DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
		   0, },
	{ DRM_MODE("720x480i", DRM_MODE_TYPE_DRIVER, 13500, 720, 753,
		   815, 858, 0, 480, 483, 489, 525, 0,
		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC |
		   DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
		   0, },
};

struct rk630_tve {
	struct device *dev;
	struct drm_connector connector;
	struct drm_bridge bridge;
	struct drm_encoder *encoder;

	struct regmap *grf;
	struct regmap *cru;
	struct regmap *tvemap;
	struct rk630 *parent;

	int mode;
	int is_4x;
	struct rockchip_drm_sub_dev sub_dev;
};

enum {
	CVBS_NTSC = 0,
	CVBS_PAL,
};

struct env_config {
	u32 offset;
	u32 value;
};

static struct env_config ntsc_bt656_config[] = {
	{ BT656_DECODER_CTRL, 0x00000001 },
	{ BT656_DECODER_CROP, 0x00000000 },
	{ BT656_DECODER_SIZE, 0x01e002d0 },
	{ BT656_DECODER_HTOTAL_HS_END, 0x035a003e },
	{ BT656_DECODER_VACT_ST_HACT_ST, 0x00150069 },
	{ BT656_DECODER_VTOTAL_VS_END, 0x020d0003 },
	{ BT656_DECODER_VS_ST_END_F1, 0x01060109 },
	{ BT656_DECODER_DBG_REG, 0x024002d0 },
};

static struct env_config ntsc_tve_config[] = {
	{ TVE_MODE_CTRL, 0x000af906 },
	{ TVE_HOR_TIMING1, 0x00c07a81 },
	{ TVE_HOR_TIMING2, 0x169810fc },
	{ TVE_HOR_TIMING3, 0x96b40000 },
	{ TVE_SUB_CAR_FRQ, 0x21f07bd7 },
	{ TVE_LUMA_FILTER1, 0x000a0ffa },
	{ TVE_LUMA_FILTER2, 0x0ff4001a },
	{ TVE_LUMA_FILTER3, 0x00110fd2 },
	{ TVE_LUMA_FILTER4, 0x0fe80051 },
	{ TVE_LUMA_FILTER5, 0x001a0f74 },
	{ TVE_LUMA_FILTER6, 0x0fe600ec },
	{ TVE_LUMA_FILTER7, 0x0ffa0e43 },
	{ TVE_LUMA_FILTER8, 0x08200527 },
	{ TVE_IMAGE_POSITION, 0x001500d6 },
	{ TVE_ROUTING, 0x10088880 },
	{ TVE_SYNC_ADJUST, 0x00000000 },
	{ TVE_STATUS, 0x00000000 },
	{ TVE_CTRL, 0x00000000 },
	{ TVE_INTR_STATUS, 0x00000000 },
	{ TVE_INTR_EN, 0x00000000 },
	{ TVE_INTR_CLR, 0x00000000 },
	{ TVE_COLOR_BUSRT_SAT, 0x0052543c },
	{ TVE_CHROMA_BANDWIDTH, 0x00000002 },
	{ TVE_BRIGHTNESS_CONTRAST, 0x00008300 },
	{ TVE_ID, 0x0a010000 },
	{ TVE_REVISION, 0x00010108 },
	{ TVE_CLAMP, 0x00000000 },
};

static struct env_config pal_bt656_config[] = {
	{ BT656_DECODER_CTRL, 0x00000001 },
	{ BT656_DECODER_CROP, 0x00000000 },
	{ BT656_DECODER_SIZE, 0x024002d0 },
	{ BT656_DECODER_HTOTAL_HS_END, 0x0360003f },
	{ BT656_DECODER_VACT_ST_HACT_ST, 0x0016006f },
	{ BT656_DECODER_VTOTAL_VS_END, 0x02710003 },
	{ BT656_DECODER_VS_ST_END_F1, 0x0138013b },
	{ BT656_DECODER_DBG_REG, 0x024002d0 },
};

static struct env_config pal_tve_config[] = {
	{ TVE_MODE_CTRL, 0x010ab906 },
	{ TVE_HOR_TIMING1, 0x00c28381 },
	{ TVE_HOR_TIMING2, 0x267d111d },
	{ TVE_HOR_TIMING3, 0x76c00880 },
	{ TVE_SUB_CAR_FRQ, 0x2a098acb },
	{ TVE_LUMA_FILTER1, 0x000a0ffa },
	{ TVE_LUMA_FILTER2, 0x0ff4001a },
	{ TVE_LUMA_FILTER3, 0x00110fd2 },
	{ TVE_LUMA_FILTER4, 0x0fe80051 },
	{ TVE_LUMA_FILTER5, 0x001a0f74 },
	{ TVE_LUMA_FILTER6, 0x0fe600ec },
	{ TVE_LUMA_FILTER7, 0x0ffa0e43 },
	{ TVE_LUMA_FILTER8, 0x08200527 },
	{ TVE_IMAGE_POSITION, 0x001500f6 },
	{ TVE_ROUTING, 0x1000088a },
	{ TVE_SYNC_ADJUST, 0x00000000 },
	{ TVE_STATUS, 0x000000b0 },
	{ TVE_CTRL, 0x00000000 },
	{ TVE_INTR_STATUS, 0x00000000 },
	{ TVE_INTR_EN, 0x00000000 },
	{ TVE_INTR_CLR, 0x00000000 },
	{ TVE_COLOR_BUSRT_SAT, 0x002e553c },
	{ TVE_CHROMA_BANDWIDTH, 0x00000022 },
	{ TVE_BRIGHTNESS_CONTRAST, 0x00008900 },
	{ TVE_ID, 0x0a010000 },
	{ TVE_REVISION, 0x00010108 },
	{ TVE_CLAMP, 0x00000000 },
};

static const struct regmap_range rk630_tve_readable_ranges[] = {
	regmap_reg_range(BT656_DECODER_CTRL, BT656_DECODER_DBG_REG),
	regmap_reg_range(TVE_MODE_CTRL, TVE_ROUTING),
	regmap_reg_range(TVE_SYNC_ADJUST, TVE_STATUS),
	regmap_reg_range(TVE_CTRL, TVE_COLOR_BUSRT_SAT),
	regmap_reg_range(TVE_CHROMA_BANDWIDTH, TVE_BRIGHTNESS_CONTRAST),
	regmap_reg_range(TVE_ID, TVE_CLAMP),
};

static const struct regmap_access_table rk630_tve_readable_table = {
	.yes_ranges = rk630_tve_readable_ranges,
	.n_yes_ranges = ARRAY_SIZE(rk630_tve_readable_ranges),
};

const struct regmap_config rk630_tve_regmap_config = {
	.name = "tve",
	.reg_bits = 32,
	.val_bits = 32,
	.reg_stride = 4,
	.max_register = TVE_MAX_REGISTER,
	.reg_format_endian = REGMAP_ENDIAN_NATIVE,
	.val_format_endian = REGMAP_ENDIAN_NATIVE,
	.rd_table = &rk630_tve_readable_table,
};
EXPORT_SYMBOL_GPL(rk630_tve_regmap_config);

static struct rk630_tve *bridge_to_tve(struct drm_bridge *bridge)
{
	return container_of(bridge, struct rk630_tve, bridge);
}

static struct rk630_tve *connector_to_tve(struct drm_connector *connector)
{
	return container_of(connector, struct rk630_tve, connector);
}

static int rk630_tve_write_block(struct rk630_tve *tve,
				 struct env_config *config, int len)
{
	int i, ret = 0;

	for (i = 0; i < len; i++) {
		ret = regmap_write(tve->tvemap, config[i].offset,
				   config[i].value);
		if (ret)
			break;
	}

	return ret;
}

static int rk630_tve_cfg_set(struct rk630_tve *tve)
{
	int ret;
	struct env_config *bt656_cfg, *tve_cfg;

	switch (tve->mode) {
	case CVBS_PAL:
		dev_dbg(tve->dev, "rk630 PAL\n");
		bt656_cfg = pal_bt656_config;
		tve_cfg = pal_tve_config;
		break;
	case CVBS_NTSC:
		dev_dbg(tve->dev, "rk630 NTSC\n");
		bt656_cfg = ntsc_bt656_config;
		tve_cfg = ntsc_tve_config;
		break;
	default:
		dev_dbg(tve->dev, "mode select err\n");
		return -EINVAL;
	}

	ret = rk630_tve_write_block(tve, bt656_cfg, 8);
	if (ret) {
		dev_err(tve->dev, "rk630 bt656 write err!\n");
		return ret;
	}

	if (tve->mode == CVBS_PAL)
		regmap_update_bits(tve->grf, PLUMAGE_GRF_SOC_CON0,
				   SW_TVE_DCLK_POL_MASK |
				   SW_TVE_DCLK_EN_MASK |
				   SW_DCLK_UPSAMPLE_EN_MASK |
				   SW_TVE_MODE_MASK | SW_TVE_EN_MASK,
				   SW_TVE_DCLK_POL(0) | SW_TVE_DCLK_EN(1) |
				   SW_DCLK_UPSAMPLE_EN(tve->is_4x) |
				   SW_TVE_MODE(1) | SW_TVE_EN(1));
	else
		regmap_update_bits(tve->grf, PLUMAGE_GRF_SOC_CON0,
				   SW_TVE_DCLK_POL_MASK |
				   SW_TVE_DCLK_EN_MASK |
				   SW_DCLK_UPSAMPLE_EN_MASK |
				   SW_TVE_MODE_MASK | SW_TVE_EN_MASK,
				   SW_TVE_DCLK_POL(0) | SW_TVE_DCLK_EN(1) |
				   SW_DCLK_UPSAMPLE_EN(tve->is_4x) |
				   SW_TVE_MODE(0) | SW_TVE_EN(1));

	ret = rk630_tve_write_block(tve, tve_cfg, 27);
	if (ret < 0) {
		dev_err(tve->dev, "rk630 tve write err\n");
		return ret;
	}

	return ret;
}

static int rk630_tve_disable(struct rk630_tve *tve)
{
	regmap_update_bits(tve->grf, PLUMAGE_GRF_SOC_CON3, VDAC_ENDAC0_MASK,
			   VDAC_ENDAC0(0));

	return 0;
}

static int rk630_tve_enable(struct rk630_tve *tve)
{
	int ret, i;
	u32 val = 0;

	dev_dbg(tve->dev, "%s\n", __func__);

	/* config bt656 input gpio*/
	regmap_write(tve->grf, PLUMAGE_GRF_GPIO0A_IOMUX, 0x55555555);

	regmap_update_bits(tve->grf, PLUMAGE_GRF_GPIO0B_IOMUX, GPIO0B0_SEL_MASK,
			   GPIO0B0_SEL(1));

	regmap_update_bits(tve->grf, PLUMAGE_GRF_SOC_CON3, VDAC_ENDAC0_MASK,
			   VDAC_ENDAC0(0));

	ret = rk630_tve_cfg_set(tve);
	if (ret)
		return ret;

	/*config clk*/
	if (!tve->is_4x) {
		regmap_update_bits(tve->cru, CRU_MODE_CON, CLK_SPLL_MODE_MASK,
				   CLK_SPLL_MODE(2));
	} else {
		regmap_update_bits(tve->cru, CRU_SPLL_CON1, PLLPD0_MASK,
				   PLLPD0(1));

		regmap_update_bits(tve->cru, CRU_MODE_CON, CLK_SPLL_MODE_MASK,
				   CLK_SPLL_MODE(1));

		regmap_update_bits(tve->cru, CRU_SPLL_CON1, PLLPD0_MASK,
				   PLLPD0(0));

		for (i = 0; i < 10; i++) {
			usleep_range(1000, 2000);
			regmap_read(tve->cru, CRU_SPLL_CON1, &val);
			if (val & PLL_LOCK) {
				dev_dbg(tve->dev, "rk630 pll locked\n");
				break;
			}
		}
		if (!(val & PLL_LOCK)) {
			dev_err(tve->dev, "rk630 pll unlock\n");
			return -EINVAL;
		}
	}

	/* enable vdac */
	regmap_update_bits(tve->grf, PLUMAGE_GRF_SOC_CON3,
			   VDAC_ENVBG_MASK | VDAC_ENDAC0_MASK,
			   VDAC_ENVBG(1) | VDAC_ENDAC0(1));

	return 0;
}

static enum drm_mode_status
rk630_tve_mode_valid(struct drm_connector *connector,
		  struct drm_display_mode *mode)
{
	return MODE_OK;
}

static int
rk630_tve_get_modes(struct drm_connector *connector)
{
	int count;
	u32 bus_format = MEDIA_BUS_FMT_UYVY8_2X8;
	struct rk630_tve *tve = connector_to_tve(connector);

	for (count = 0; count < ARRAY_SIZE(rk630_tve_mode); count++) {
		struct drm_display_mode *mode_ptr;

		mode_ptr = drm_mode_duplicate(connector->dev,
					      &rk630_tve_mode[count]);
		if (!mode_ptr) {
			dev_err(tve->dev, "mode duplicate failed\n");
			return -ENOMEM;
		}

		if (!count)
			mode_ptr->type |= DRM_MODE_TYPE_PREFERRED;
		drm_mode_probed_add(connector, mode_ptr);
	}
	drm_display_info_set_bus_formats(&connector->display_info,
					 &bus_format, 1);

	return count;
}

static enum drm_connector_status
rk630_tve_connector_detect(struct drm_connector *connector,
			bool force)
{
	return connector_status_connected;
}

static struct drm_encoder *rk630_tve_best_encoder(struct drm_connector *connector)
{
	struct rk630_tve *tve = connector_to_tve(connector);

	return tve->encoder;
}

static
const struct drm_connector_helper_funcs rk630_tve_connector_helper_funcs = {
	.get_modes = rk630_tve_get_modes,
	.mode_valid = rk630_tve_mode_valid,
	.best_encoder = rk630_tve_best_encoder,
};

static const struct drm_connector_funcs rk630_tve_connector_funcs = {
	.fill_modes = drm_helper_probe_single_connector_modes,
	.detect = rk630_tve_connector_detect,
	.destroy = drm_connector_cleanup,
	.reset = drm_atomic_helper_connector_reset,
	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
};

static void
rk630_tve_bridge_mode_set(struct drm_bridge *bridge,
			  const struct drm_display_mode *mode,
			  const struct drm_display_mode *adjusted_mode)
{
	struct rk630_tve *tve;

	tve = bridge_to_tve(bridge);

	if (adjusted_mode->vdisplay == 576)
		tve->mode = CVBS_PAL;
	else
		tve->mode = CVBS_NTSC;
}

static void rk630_tve_bridge_enable(struct drm_bridge *bridge)
{
	int ret;
	struct rk630_tve *tve = bridge_to_tve(bridge);

	dev_dbg(tve->dev, "%s\n",  __func__);
	ret = rk630_tve_enable(tve);
	if (ret)
		dev_err(tve->dev, "rk630 enable failed\n");
}

static void rk630_tve_bridge_disable(struct drm_bridge *bridge)
{
	struct rk630_tve *tve = bridge_to_tve(bridge);

	dev_dbg(tve->dev, "%s\n",  __func__);
	rk630_tve_disable(tve);
}

static int rk630_tve_bridge_attach(struct drm_bridge *bridge,
				   enum drm_bridge_attach_flags flags)
{
	struct rk630_tve *tve = bridge_to_tve(bridge);
	int ret;

	if (!bridge->encoder) {
		dev_err(tve->dev, "Parent encoder object not found\n");
		return -ENODEV;
	}

	tve->encoder = bridge->encoder;
	ret = drm_connector_init(bridge->dev, &tve->connector,
				 &rk630_tve_connector_funcs,
				 DRM_MODE_CONNECTOR_TV);
	if (ret) {
		dev_err(tve->dev, "Failed to initialize connector\n");
		return ret;
	}

	drm_connector_helper_add(&tve->connector,
				 &rk630_tve_connector_helper_funcs);
	ret = drm_connector_attach_encoder(&tve->connector,
					   bridge->encoder);

	if (ret)
		dev_err(tve->dev, "rk630 attach failed ret:%d", ret);
	tve->sub_dev.connector = &tve->connector;
	tve->sub_dev.of_node = tve->dev->of_node;
	rockchip_drm_register_sub_dev(&tve->sub_dev);
	tve->connector.interlace_allowed = 1;

	return ret;
}

static void rk1000_bridge_detach(struct drm_bridge *bridge)
{
	struct rk630_tve *tve = bridge_to_tve(bridge);

	rockchip_drm_unregister_sub_dev(&tve->sub_dev);
}

static struct drm_bridge_funcs rk630_tve_bridge_funcs = {
	.enable = rk630_tve_bridge_enable,
	.disable = rk630_tve_bridge_disable,
	.mode_set = rk630_tve_bridge_mode_set,
	.attach = rk630_tve_bridge_attach,
	.detach = rk1000_bridge_detach,
};

static int rk630_tve_probe(struct platform_device *pdev)
{
	struct rk630 *rk630 = dev_get_drvdata(pdev->dev.parent);
	struct rk630_tve *tve;
	struct device *dev = &pdev->dev;

	if (!of_device_is_available(dev->of_node))
		return -ENODEV;

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

	tve->dev = dev;
	tve->parent = rk630;
	platform_set_drvdata(pdev, tve);

	tve->grf = rk630->grf;
	tve->cru = rk630->cru;
	tve->tvemap = rk630->tve;
	if (!tve->grf | !tve->cru | !tve->tvemap)
		return -ENODEV;

	tve->mode = CVBS_PAL;

	tve->bridge.funcs = &rk630_tve_bridge_funcs;
	tve->bridge.of_node = tve->dev->of_node;

	drm_bridge_add(&tve->bridge);

	dev_dbg(tve->dev, "rk630 probe tve ok\n");

	return 0;
}

static int rk630_tve_remove(struct platform_device *pdev)
{
	struct rk630_tve *tve = platform_get_drvdata(pdev);

	drm_bridge_remove(&tve->bridge);

	return 0;
}

static const struct of_device_id rk630_tve_dt_ids[] = {
	{ .compatible = "rockchip,rk630-tve" },
	{ }
};

MODULE_DEVICE_TABLE(of, rk630_tve_dt_ids);

static struct platform_driver rk630_tve_driver = {
	.driver = {
		.name = "rk630-tve",
		.of_match_table = of_match_ptr(rk630_tve_dt_ids),
	},
	.probe = rk630_tve_probe,
	.remove = rk630_tve_remove,
};
module_platform_driver(rk630_tve_driver);

MODULE_AUTHOR("Algea Cao <Algea.cao@rock-chips.com>");
MODULE_DESCRIPTION("ROCKCHIP rk630 TVE Driver");
MODULE_LICENSE("GPL v2");