Orange Pi5 kernel

// 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");