ARK-OS/arkos/kernel/drivers/gpu/drm/rockchip/inno_hdmi-rockchip.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) Rockchip Electronics Co., Ltd.
 *    Zheng Yang <zhengyang@rock-chips.com>
 *    Andy Yan <andy.yan@rock-chips.com>
 */
#include <linux/err.h>
#include <linux/hw_bitfield.h>
#include <linux/mfd/syscon.h>
#include <linux/mod_devicetable.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>

#include <drm/bridge/inno_hdmi.h>
#include <drm/drm_bridge_connector.h>
#include <drm/drm_of.h>

#include "rockchip_drm_drv.h"

#define HIWORD_UPDATE(val, mask)	((val) | (mask) << 16)

#define RK3036_GRF_SOC_CON2	0x148
#define RK3036_HDMI_PHSYNC	BIT(4)
#define RK3036_HDMI_PVSYNC	BIT(5)

enum inno_hdmi_dev_type {
	RK3036_HDMI,
	RK3128_HDMI,
};

struct inno_hdmi_connector_state {
	struct drm_connector_state	base;
	unsigned int			colorimetry;
};

struct rockchip_inno_hdmi {
	struct inno_hdmi *base;
	struct device *dev;
	struct regmap *grf;
	struct rockchip_encoder encoder;
};

static struct inno_hdmi_phy_config rk3036_hdmi_phy_configs[] = {
	{  74250000, 0x3f, 0xbb },
	{ 165000000, 0x6f, 0xbb },
	{      ~0UL, 0x00, 0x00 }
};

static struct inno_hdmi_phy_config rk3128_hdmi_phy_configs[] = {
	{  74250000, 0x3f, 0xaa },
	{ 165000000, 0x5f, 0xaa },
	{      ~0UL, 0x00, 0x00 }
};

static void inno_hdmi_rk3036_enable(struct device *dev, struct drm_display_mode *mode)
{
	struct rockchip_inno_hdmi *hdmi = dev_get_drvdata(dev);
	int value, psync;

	psync = mode->flags & DRM_MODE_FLAG_PHSYNC ? 1 : 0;
	value = FIELD_PREP_WM16(RK3036_HDMI_PHSYNC, psync);
	psync = mode->flags & DRM_MODE_FLAG_PVSYNC ? 1 : 0;
	value |= FIELD_PREP_WM16(RK3036_HDMI_PVSYNC, psync);
	regmap_write(hdmi->grf, RK3036_GRF_SOC_CON2, value);
}

static int inno_hdmi_encoder_atomic_check(struct drm_encoder *encoder,
					  struct drm_crtc_state *crtc_state,
					  struct drm_connector_state *conn_state)
{
	struct rockchip_crtc_state *s = to_rockchip_crtc_state(crtc_state);

	s->output_mode = ROCKCHIP_OUT_MODE_P888;
	s->output_type = DRM_MODE_CONNECTOR_HDMIA;

	return 0;
}

static const struct drm_encoder_helper_funcs inno_hdmi_rockchip_encoder_helper_funcs = {
	.atomic_check	= inno_hdmi_encoder_atomic_check,
};

static int inno_hdmi_rockchip_bind(struct device *dev, struct device *master, void *data)
{
	struct drm_device *drm = data;
	struct drm_connector *connector;
	struct drm_encoder *encoder;
	struct rockchip_inno_hdmi *hdmi;
	const struct inno_hdmi_plat_data *plat_data;
	int ret;

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

	hdmi->dev = dev;

	plat_data = of_device_get_match_data(hdmi->dev);
	if (!plat_data)
		return -EINVAL;

	if (of_device_is_compatible(dev->of_node, "rockchip,rk3036-inno-hdmi")) {
		hdmi->grf = syscon_regmap_lookup_by_phandle(dev->of_node, "rockchip,grf");
		if (IS_ERR(hdmi->grf))
			return dev_err_probe(dev,
					     PTR_ERR(hdmi->grf), "Unable to get rockchip,grf\n");
	}

	encoder = &hdmi->encoder.encoder;
	encoder->possible_crtcs = drm_of_find_possible_crtcs(drm, dev->of_node);

	/*
	 * If we failed to find the CRTC(s) which this encoder is
	 * supposed to be connected to, it's because the CRTC has
	 * not been registered yet.  Defer probing, and hope that
	 * the required CRTC is added later.
	 */
	if (encoder->possible_crtcs == 0)
		return -EPROBE_DEFER;

	ret = drmm_encoder_init(drm, encoder, NULL, DRM_MODE_ENCODER_TMDS, NULL);
	if (ret)
		return ret;

	drm_encoder_helper_add(encoder, &inno_hdmi_rockchip_encoder_helper_funcs);

	dev_set_drvdata(dev, hdmi);

	hdmi->base = inno_hdmi_bind(dev, encoder, plat_data);

	connector = drm_bridge_connector_init(drm, encoder);
	if (IS_ERR(connector)) {
		ret = PTR_ERR(connector);
		dev_err(hdmi->dev, "failed to init bridge connector: %d\n", ret);
		return ret;
	}

	return drm_connector_attach_encoder(connector, encoder);
}

static const struct component_ops inno_hdmi_rockchip_ops = {
	.bind	= inno_hdmi_rockchip_bind,
};

static int inno_hdmi_rockchip_probe(struct platform_device *pdev)
{
	return component_add(&pdev->dev, &inno_hdmi_rockchip_ops);
}

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

static const struct inno_hdmi_plat_ops rk3036_inno_hdmi_plat_ops = {
	.enable = inno_hdmi_rk3036_enable,
};

static const struct inno_hdmi_plat_data rk3036_inno_hdmi_plat_data = {
	.ops = &rk3036_inno_hdmi_plat_ops,
	.phy_configs = rk3036_hdmi_phy_configs,
	.default_phy_config = &rk3036_hdmi_phy_configs[1],
};

static const struct inno_hdmi_plat_data rk3128_inno_hdmi_plat_data = {
	.phy_configs = rk3128_hdmi_phy_configs,
	.default_phy_config = &rk3128_hdmi_phy_configs[1],
};

static const struct of_device_id inno_hdmi_rockchip_dt_ids[] = {
	{ .compatible = "rockchip,rk3036-inno-hdmi",
	  .data = &rk3036_inno_hdmi_plat_data,
	},
	{ .compatible = "rockchip,rk3128-inno-hdmi",
	  .data = &rk3128_inno_hdmi_plat_data,
	},
	{},
};
MODULE_DEVICE_TABLE(of, inno_hdmi_rockchip_dt_ids);

struct platform_driver inno_hdmi_driver = {
	.probe  = inno_hdmi_rockchip_probe,
	.remove = inno_hdmi_rockchip_remove,
	.driver = {
		.name = "innohdmi-rockchip",
		.of_match_table = inno_hdmi_rockchip_dt_ids,
	},
};