android13/kernel-5.10/drivers/gpu/drm/rockchip/rk628/rk628_rgb.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2020 Rockchip Electronics Co. Ltd.
 *
 * Author: Wyon Bi <bivvy.bi@rock-chips.com>
 */

#include <linux/module.h>
#include <linux/clk.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/regmap.h>
#include <linux/mfd/rk628.h>
#include <linux/phy/phy.h>
#include <linux/reset.h>

#include <drm/drm_of.h>
#include <drm/drm_atomic.h>
#include <drm/drm_probe_helper.h>
#include <drm/drm_atomic_helper.h>
#include <drm/drm_panel.h>

#include <video/of_display_timing.h>
#include <video/videomode.h>

enum interface_type {
	RGB_TX,
	YUV_RX,
	YUV_TX,
	BT1120_RX,
	BT1120_TX,
};

struct rk628_rgb {
	struct drm_bridge base;
	struct drm_connector connector;
	struct drm_display_mode mode;
	struct drm_panel *panel;
	struct drm_bridge *bridge;
	struct device *dev;
	struct regmap *grf;
	struct rk628 *parent;
	struct clk *decclk;
	struct reset_control *rstc;
	bool dual_edge;
	enum interface_type interface_type;
};

static inline struct rk628_rgb *bridge_to_rgb(struct drm_bridge *b)
{
	return container_of(b, struct rk628_rgb, base);
}

static inline struct rk628_rgb *connector_to_rgb(struct drm_connector *c)
{
	return container_of(c, struct rk628_rgb, connector);
}

static enum interface_type rk628_rgb_get_interface_type(struct rk628_rgb *rgb)
{
	const struct device_node *of_node = rgb->dev->of_node;

	if (of_device_is_compatible(of_node, "rockchip,rk628-yuv-rx"))
		return YUV_RX;
	else if (of_device_is_compatible(of_node, "rockchip,rk628-yuv-tx"))
		return YUV_TX;
	else if (of_device_is_compatible(of_node, "rockchip,rk628-bt1120-rx"))
		return BT1120_RX;
	else if (of_device_is_compatible(of_node, "rockchip,rk628-bt1120-tx"))
		return BT1120_TX;
	else
		return RGB_TX;
}

static struct drm_encoder *
rk628_rgb_connector_best_encoder(struct drm_connector *connector)
{
	struct rk628_rgb *rgb = connector_to_rgb(connector);

	return rgb->base.encoder;
}

static int rk628_rgb_connector_get_modes(struct drm_connector *connector)
{
	struct rk628_rgb *rgb = connector_to_rgb(connector);

	return drm_panel_get_modes(rgb->panel, connector);
}

static const struct drm_connector_helper_funcs
rk628_rgb_connector_helper_funcs = {
	.get_modes = rk628_rgb_connector_get_modes,
	.best_encoder = rk628_rgb_connector_best_encoder,
};

static void rk628_rgb_connector_destroy(struct drm_connector *connector)
{
	drm_connector_cleanup(connector);
}

static const struct drm_connector_funcs rk628_rgb_connector_funcs = {
	.fill_modes = drm_helper_probe_single_connector_modes,
	.destroy = rk628_rgb_connector_destroy,
	.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 rk628_bt1120_rx_enable(struct rk628_rgb *rgb)
{
	const struct drm_display_mode *mode = &rgb->mode;

	reset_control_assert(rgb->rstc);
	udelay(10);
	reset_control_deassert(rgb->rstc);
	udelay(10);

	clk_set_rate(rgb->decclk, mode->clock * 1000);
	clk_prepare_enable(rgb->decclk);

	if (rgb->dual_edge) {
		regmap_update_bits(rgb->grf, GRF_RGB_DEC_CON0,
				   DEC_DUALEDGE_EN, DEC_DUALEDGE_EN);

		regmap_write(rgb->grf,
			     GRF_BT1120_DCLK_DELAY_CON0, 0x10000000);
		regmap_write(rgb->grf, GRF_BT1120_DCLK_DELAY_CON1, 0);
	} else
		regmap_update_bits(rgb->grf, GRF_RGB_DEC_CON0,
				   DEC_DUALEDGE_EN, 0);

	regmap_update_bits(rgb->grf, GRF_RGB_DEC_CON1,
			   SW_SET_X_MASK, SW_SET_X(mode->hdisplay));
	regmap_update_bits(rgb->grf, GRF_RGB_DEC_CON2,
			   SW_SET_Y_MASK, SW_SET_Y(mode->vdisplay));

	regmap_update_bits(rgb->grf, GRF_SYSTEM_CON0,
			   SW_BT_DATA_OEN_MASK | SW_INPUT_MODE_MASK,
			   SW_BT_DATA_OEN | SW_INPUT_MODE(INPUT_MODE_BT1120));

	regmap_write(rgb->grf, GRF_CSC_CTRL_CON, SW_Y2R_EN(1));

	regmap_update_bits(rgb->grf, GRF_RGB_DEC_CON0,
			   SW_CAP_EN_PSYNC | SW_CAP_EN_ASYNC | SW_PROGRESS_EN,
			   SW_CAP_EN_PSYNC | SW_CAP_EN_ASYNC | SW_PROGRESS_EN);
}

static void rk628_bt1120_tx_enable(struct rk628_rgb *rgb)
{
	u32 val = 0;

	regmap_update_bits(rgb->grf, GRF_SYSTEM_CON0,
			   SW_BT_DATA_OEN_MASK | SW_OUTPUT_MODE_MASK,
			   SW_OUTPUT_MODE(OUTPUT_MODE_BT1120));
	regmap_write(rgb->grf, GRF_CSC_CTRL_CON, SW_R2Y_EN(1));
	regmap_update_bits(rgb->grf, GRF_POST_PROC_CON,
			   SW_DCLK_OUT_INV_EN, SW_DCLK_OUT_INV_EN);

	if (rgb->dual_edge) {
		val |= ENC_DUALEDGE_EN(1);
		regmap_write(rgb->grf, GRF_BT1120_DCLK_DELAY_CON0, 0x10000000);
		regmap_write(rgb->grf, GRF_BT1120_DCLK_DELAY_CON1, 0);
	}

	val |= BT1120_UV_SWAP(1);
	regmap_write(rgb->grf, GRF_RGB_ENC_CON, val);

}

static void rk628_rgb_bridge_enable(struct drm_bridge *bridge)
{
	struct rk628_rgb *rgb = bridge_to_rgb(bridge);

	switch (rgb->interface_type) {
	case YUV_RX:
		regmap_write(rgb->grf, GRF_CSC_CTRL_CON, SW_Y2R_EN(1));
		regmap_update_bits(rgb->grf, GRF_SYSTEM_CON0,
				   SW_BT_DATA_OEN_MASK | SW_INPUT_MODE_MASK,
				   SW_BT_DATA_OEN | SW_INPUT_MODE(INPUT_MODE_YUV));
		break;
	case YUV_TX:
		regmap_write(rgb->grf, GRF_CSC_CTRL_CON, SW_R2Y_EN(1));
		regmap_update_bits(rgb->grf, GRF_POST_PROC_CON,
				   SW_DCLK_OUT_INV_EN, SW_DCLK_OUT_INV_EN);

		regmap_update_bits(rgb->grf, GRF_SYSTEM_CON0,
				   SW_BT_DATA_OEN_MASK | SW_OUTPUT_MODE_MASK,
				   SW_OUTPUT_MODE(OUTPUT_MODE_YUV));
		break;
	case BT1120_RX:
		rk628_bt1120_rx_enable(rgb);
		break;
	case BT1120_TX:
		rk628_bt1120_tx_enable(rgb);
		break;
	case RGB_TX:
	default:
		regmap_update_bits(rgb->grf, GRF_SYSTEM_CON0,
				   SW_BT_DATA_OEN_MASK | SW_OUTPUT_MODE_MASK,
				   SW_OUTPUT_MODE(OUTPUT_MODE_RGB));
		regmap_update_bits(rgb->grf, GRF_POST_PROC_CON,
				   SW_DCLK_OUT_INV_EN, SW_DCLK_OUT_INV_EN);
		break;
	}

	if (rgb->panel) {
		drm_panel_prepare(rgb->panel);
		drm_panel_enable(rgb->panel);
	}
}

static void rk628_rgb_bridge_disable(struct drm_bridge *bridge)
{
	struct rk628_rgb *rgb = bridge_to_rgb(bridge);

	if (rgb->panel) {
		drm_panel_disable(rgb->panel);
		drm_panel_unprepare(rgb->panel);
	}

	if (rgb->decclk)
		clk_disable_unprepare(rgb->decclk);

	if (rgb->rstc)
		reset_control_assert(rgb->rstc);
}

static int rk628_rgb_bridge_attach(struct drm_bridge *bridge,
				   enum drm_bridge_attach_flags flags)
{
	struct rk628_rgb *rgb = bridge_to_rgb(bridge);
	struct drm_connector *connector = &rgb->connector;
	struct drm_device *drm = bridge->dev;
	struct device *dev = rgb->dev;
	int ret;

	ret = drm_of_find_panel_or_bridge(dev->of_node, 1, -1,
					  &rgb->panel, &rgb->bridge);
	if (ret)
		return ret;

	if (rgb->interface_type == YUV_RX || rgb->interface_type == BT1120_RX) {
		if (!rgb->bridge) {
			dev_err(dev, "decoder failed to find bridge\n");
			return -EPROBE_DEFER;
		}

		ret = drm_bridge_attach(bridge->encoder, rgb->bridge, bridge,
					flags);
		if (ret) {
			dev_err(dev, "failed to attach bridge\n");
			return ret;
		}
	} else {
		if (rgb->bridge) {
			ret = drm_bridge_attach(bridge->encoder, rgb->bridge,
						bridge, flags);
			if (ret) {
				dev_err(dev, "failed to attach bridge\n");
				return ret;
			}
		}

		if (flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR)
			return 0;

		if (rgb->panel) {
			ret = drm_connector_init(drm, connector,
						 &rk628_rgb_connector_funcs,
						 DRM_MODE_CONNECTOR_DPI);
			if (ret) {
				dev_err(dev,
					"Failed to initialize connector with drm\n");
				return ret;
			}

			drm_connector_helper_add(connector,
						 &rk628_rgb_connector_helper_funcs);
			drm_connector_attach_encoder(connector,
							  bridge->encoder);
		}
	}

	return 0;
}

static void rk628_rgb_bridge_mode_set(struct drm_bridge *bridge,
				      const struct drm_display_mode *mode,
				      const struct drm_display_mode *adj)
{
	struct rk628_rgb *rgb = bridge_to_rgb(bridge);

	drm_mode_copy(&rgb->mode, adj);
}

static const struct drm_bridge_funcs rk628_rgb_bridge_funcs = {
	.attach = rk628_rgb_bridge_attach,
	.enable = rk628_rgb_bridge_enable,
	.disable = rk628_rgb_bridge_disable,
	.mode_set = rk628_rgb_bridge_mode_set,
};

static int rk628_rgb_probe(struct platform_device *pdev)
{
	struct rk628 *rk628 = dev_get_drvdata(pdev->dev.parent);
	struct device *dev = &pdev->dev;
	struct rk628_rgb *rgb;
	int ret;

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

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

	rgb->dev = dev;
	rgb->parent = rk628;
	rgb->grf = rk628->grf;
	rgb->interface_type = rk628_rgb_get_interface_type(rgb);
	rgb->dual_edge = of_property_read_bool(dev->of_node, "dual-edge");
	platform_set_drvdata(pdev, rgb);

	if (rgb->interface_type == BT1120_RX) {
		rgb->decclk = devm_clk_get(dev, "bt1120dec");
		if (IS_ERR(rgb->decclk)) {
			ret = PTR_ERR(rgb->decclk);
			dev_err(dev, "failed to get dec clk: %d\n", ret);
			return ret;
		}

		rgb->rstc = of_reset_control_get(dev->of_node, NULL);
		if (IS_ERR(rgb->rstc)) {
			ret = PTR_ERR(rgb->rstc);
			dev_err(dev, "failed to get reset control: %d\n", ret);
			return ret;
		}
	}

	rgb->base.funcs = &rk628_rgb_bridge_funcs;
	rgb->base.of_node = dev->of_node;
	drm_bridge_add(&rgb->base);

	return 0;
}

static int rk628_rgb_remove(struct platform_device *pdev)
{
	struct rk628_rgb *rgb = platform_get_drvdata(pdev);

	drm_bridge_remove(&rgb->base);

	return 0;
}

static const struct of_device_id rk628_rgb_of_match[] = {
	{ .compatible = "rockchip,rk628-rgb-tx", },
	{ .compatible = "rockchip,rk628-yuv-rx", },
	{ .compatible = "rockchip,rk628-yuv-tx", },
	{ .compatible = "rockchip,rk628-bt1120-rx", },
	{ .compatible = "rockchip,rk628-bt1120-tx", },
	{},
};
MODULE_DEVICE_TABLE(of, rk628_rgb_of_match);

static struct platform_driver rk628_rgb_driver = {
	.driver = {
		.name = "rk628-rgb",
		.of_match_table = of_match_ptr(rk628_rgb_of_match),
	},
	.probe = rk628_rgb_probe,
	.remove = rk628_rgb_remove,
};
module_platform_driver(rk628_rgb_driver);

MODULE_AUTHOR("Wyon Bi <bivvy.bi@rock-chips.com>");
MODULE_DESCRIPTION("Rockchip RK628 RGB driver");
MODULE_LICENSE("GPL v2");