KernelNanopiR5S/drivers/mfd/rkx110_x120/rkx110_x120_panel.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * rockchip SerDes Panele driver for drm platform
 *
 * Copyright (C) 2022 Rockchip Electronics Co. Ltd.
 */

#include <linux/module.h>
#include <linux/of_platform.h>
#include <linux/of_graph.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/gpio/consumer.h>
#include <linux/regulator/consumer.h>
#include <linux/delay.h>

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

#include <drm/drm_crtc.h>
#include <drm/drm_mipi_dsi.h>
#include <drm/drm_panel.h>

#include "rkx110_x120.h"
#include "rkx120_dsi_tx.h"

static inline struct rk_serdes_panel *to_serdes_panel(struct drm_panel *panel)
{
	return container_of(panel, struct rk_serdes_panel, panel);
}

static int serdes_panel_prepare(struct drm_panel *panel)
{
	struct rk_serdes_panel *sd_panel = to_serdes_panel(panel);
	struct rk_serdes_route *route = &sd_panel->route;
	struct rk_serdes *serdes = sd_panel->parent;

	if (sd_panel->supply) {
		int err;

		err = regulator_enable(sd_panel->supply);
		if (err < 0) {
			dev_err(sd_panel->dev, "failed to enable supply: %d\n",
				err);
			return err;
		}
		mdelay(20);
	}

	if (sd_panel->enable_gpio) {
		gpiod_set_value_cansleep(sd_panel->enable_gpio, 1);
		mdelay(20);
	}

	if (sd_panel->reset_gpio) {
		gpiod_set_value_cansleep(sd_panel->reset_gpio, 1);
		mdelay(20);
	}

	if (serdes->route_prepare)
		serdes->route_prepare(serdes, &sd_panel->route);

	if (route->remote0_port0 == RK_SERDES_DSI_TX0 && !!(sd_panel->on_cmds))
		rkx120_dsi_tx_cmd_seq_xfer(serdes, DEVICE_REMOTE0,
					   sd_panel->on_cmds);

	if (route->remote1_port0 == RK_SERDES_DSI_TX0 && !!(sd_panel->on_cmds))
		rkx120_dsi_tx_cmd_seq_xfer(serdes, DEVICE_REMOTE1,
					   sd_panel->on_cmds);

	return 0;
}

static int serdes_panel_enable(struct drm_panel *panel)
{
	struct rk_serdes_panel *sd_panel = to_serdes_panel(panel);
	struct rk_serdes *serdes = sd_panel->parent;

	if (serdes->route_enable)
		serdes->route_enable(serdes, &sd_panel->route);

	return 0;
}

static int serdes_panel_disable(struct drm_panel *panel)
{
	struct rk_serdes_panel *sd_panel = to_serdes_panel(panel);
	struct rk_serdes *serdes = sd_panel->parent;


	if (serdes->route_disable)
		serdes->route_disable(serdes, &sd_panel->route);

	return 0;
}

static int serdes_panel_unprepare(struct drm_panel *panel)
{
	struct rk_serdes_panel *sd_panel = to_serdes_panel(panel);
	struct rk_serdes_route *route = &sd_panel->route;
	struct rk_serdes *serdes = sd_panel->parent;

	if (route->remote0_port0 == RK_SERDES_DSI_TX0 && !!(sd_panel->on_cmds))
		rkx120_dsi_tx_cmd_seq_xfer(serdes, DEVICE_REMOTE0,
					   sd_panel->off_cmds);

	if (route->remote1_port0 == RK_SERDES_DSI_TX0 && !!(sd_panel->on_cmds))
		rkx120_dsi_tx_cmd_seq_xfer(serdes, DEVICE_REMOTE1,
					   sd_panel->off_cmds);
	if (serdes->route_unprepare)
		serdes->route_unprepare(serdes, &sd_panel->route);

	if (sd_panel->reset_gpio) {
		gpiod_set_value_cansleep(sd_panel->reset_gpio, 0);
		mdelay(20);
	}

	if (sd_panel->enable_gpio) {
		gpiod_set_value_cansleep(sd_panel->enable_gpio, 0);
		mdelay(20);
	}

	if (sd_panel->supply)
		regulator_disable(sd_panel->supply);

	return 0;
}

static int serdes_panel_of_get_native_mode(struct rk_serdes_panel *sd_panel,
					   struct drm_connector *connector)
{
	struct rk_serdes_route *route = &sd_panel->route;
	struct device_node *timings_np;
	struct drm_display_mode *mode;
	struct drm_device *drm = connector->dev;
	u32 bus_flags;
	int ret;

	timings_np = of_get_child_by_name(sd_panel->dev->of_node, "display-timings");
	if (!timings_np) {
		dev_err(sd_panel->dev, "failed to find display-timings node\n");
		return 0;
	}

	of_node_put(timings_np);

	mode = drm_mode_create(drm);
	if (!mode)
		return 0;

	ret = of_get_drm_display_mode(sd_panel->dev->of_node, mode,
				      &bus_flags, OF_USE_NATIVE_MODE);
	if (ret) {
		dev_err(sd_panel->dev, "failed to find dts display timings\n");
		drm_mode_destroy(drm, mode);
		return 0;
	}

	drm_mode_set_name(mode);
	connector->display_info.bus_flags = bus_flags;
	mode->type |= DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
	drm_mode_probed_add(connector, mode);
	drm_display_mode_to_videomode(mode, &sd_panel->route.vm);

	if (route->frame_mode == SERDES_SP_LEFT_RIGHT_SPLIT ||
	    route->frame_mode == SERDES_SP_PIXEL_INTERLEAVED) {
		sd_panel->route.vm.pixelclock /= 2;
		sd_panel->route.vm.hactive /= 2;
		sd_panel->route.vm.hfront_porch /= 2;
		sd_panel->route.vm.hback_porch /= 2;
		sd_panel->route.vm.hsync_len /= 2;
	} else if (route->frame_mode == SERDES_SP_LINE_INTERLEAVED) {
		sd_panel->route.vm.pixelclock /= 2;
		sd_panel->route.vm.vactive /= 2;
		sd_panel->route.vm.vfront_porch /= 2;
		sd_panel->route.vm.vback_porch /= 2;
		sd_panel->route.vm.vsync_len /= 2;
	}

	return 1;
}

static int serdes_panel_get_modes(struct drm_panel *panel,
				struct drm_connector *connector)
{
	struct rk_serdes_panel *sd_panel = to_serdes_panel(panel);
	int num = 0;

	num += serdes_panel_of_get_native_mode(sd_panel, connector);
	drm_display_info_set_bus_formats(&connector->display_info,
					 &sd_panel->bus_format, 1);

	return num;
}

static const struct drm_panel_funcs serdes_panel_funcs = {
	.prepare = serdes_panel_prepare,
	.enable = serdes_panel_enable,
	.disable = serdes_panel_disable,
	.unprepare = serdes_panel_unprepare,
	.get_modes = serdes_panel_get_modes,
};

static int
dsi_panel_parse_cmds(struct device *dev, const u8 *data,
		     int blen, struct panel_cmds *pcmds)
{
	unsigned int len;
	char *buf, *bp;
	struct cmd_ctrl_hdr *dchdr;
	int i, cnt;

	if (!pcmds)
		return -EINVAL;

	buf = devm_kmemdup(dev, data, blen, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;

	/* scan init commands */
	bp = buf;
	len = blen;
	cnt = 0;
	while (len > sizeof(*dchdr)) {
		dchdr = (struct cmd_ctrl_hdr *)bp;

		if (dchdr->dlen > len) {
			dev_err(dev, "%s: error, len=%d", __func__, dchdr->dlen);
			return -EINVAL;
		}

		bp += sizeof(*dchdr);
		len -= sizeof(*dchdr);
		bp += dchdr->dlen;
		len -= dchdr->dlen;
		cnt++;
	}

	if (len != 0) {
		dev_err(dev, "%s: dcs_cmd=%x len=%d error!", __func__, buf[0], blen);
		return -EINVAL;
	}

	pcmds->cmds = devm_kcalloc(dev, cnt, sizeof(struct cmd_desc), GFP_KERNEL);
	if (!pcmds->cmds)
		return -ENOMEM;

	pcmds->cmd_cnt = cnt;
	pcmds->buf = buf;
	pcmds->blen = blen;

	bp = buf;
	len = blen;
	for (i = 0; i < cnt; i++) {
		dchdr = (struct cmd_ctrl_hdr *)bp;
		len -= sizeof(*dchdr);
		bp += sizeof(*dchdr);
		pcmds->cmds[i].dchdr = *dchdr;
		pcmds->cmds[i].payload = bp;
		bp += dchdr->dlen;
		len -= dchdr->dlen;
	}

	return 0;
}

static int serdes_dsi_panel_get_cmds(struct rk_serdes_panel *sd_panel)
{
	struct device_node *np = sd_panel->dev->of_node;
	struct device *dev = sd_panel->dev;
	const void *data;
	int len, err;

	data = of_get_property(np, "panel-init-sequence", &len);
	if (data) {
		sd_panel->on_cmds = devm_kzalloc(dev, sizeof(*sd_panel->on_cmds), GFP_KERNEL);
		if (!sd_panel->on_cmds)
			return -ENOMEM;

		err = dsi_panel_parse_cmds(dev, data, len, sd_panel->on_cmds);
		if (err) {
			dev_err(dev, "failed to parse dsi panel init sequence\n");
			return err;
		}
	}

	data = of_get_property(np, "panel-exit-sequence", &len);
	if (data) {
		sd_panel->off_cmds = devm_kzalloc(dev, sizeof(*sd_panel->off_cmds), GFP_KERNEL);
		if (!sd_panel->off_cmds)
			return -ENOMEM;

		err = dsi_panel_parse_cmds(dev, data, len, sd_panel->off_cmds);
		if (err) {
			dev_err(dev, "failed to parse dsi panel exit sequence\n");
			return err;
		}
	}

	return 0;
}

static struct mipi_dsi_device *serdes_attach_dsi(struct rk_serdes_panel *sd_panel,
						 struct device_node *dsi_node)
{
	const struct mipi_dsi_device_info info = { "serdes", 0, NULL };
	struct mipi_dsi_device *dsi;
	struct mipi_dsi_host *host;
	int ret;

	host = of_find_mipi_dsi_host_by_node(dsi_node);
	if (!host) {
		dev_err(sd_panel->dev, "failed to find dsi host\n");
		return ERR_PTR(-EPROBE_DEFER);
	}

	dsi = mipi_dsi_device_register_full(host, &info);
	if (IS_ERR(dsi)) {
		dev_err(sd_panel->dev, "failed to create dsi device\n");
		return dsi;
	}

	dsi->lanes = 4;
	dsi->format = MIPI_DSI_FMT_RGB888;
	dsi->mode_flags = MIPI_DSI_MODE_LPM | MIPI_DSI_MODE_EOT_PACKET |
			  MIPI_DSI_CLOCK_NON_CONTINUOUS;

	ret = mipi_dsi_attach(dsi);
	if (ret < 0) {
		dev_err(sd_panel->dev, "failed to attach dsi to host\n");
		mipi_dsi_device_unregister(dsi);
		return ERR_PTR(ret);
	}

	return dsi;
}

static int rkx120_dsi_rx_parse(struct rk_serdes_panel *sd_panel)
{
	struct device_node *np = sd_panel->dev->of_node;
	struct rk_serdes *serdes = sd_panel->parent;
	struct rkx110_dsi_rx *dsi_rx = &serdes->dsi_rx;
	struct mipi_dsi_device *dsi;
	struct device_node *dsi_node;
	u32 val;

	if (of_property_read_u32(np, "dsi-rx,lanes", &val))
		dsi_rx->lanes = 4;
	else
		dsi_rx->lanes = val;

	if (of_property_read_bool(np, "dsi-rx,video-mode"))
		dsi_rx->mode_flags |= SERDES_MIPI_DSI_MODE_LPM | SERDES_MIPI_DSI_MODE_VIDEO |
				      SERDES_MIPI_DSI_MODE_VIDEO_BURST;
	else
		dsi_rx->mode_flags |= SERDES_MIPI_DSI_MODE_LPM;

	dsi_node = of_graph_get_remote_node(np, 0, -1);
	if (!dsi_node)
		dev_err(sd_panel->dev, "failed to get remote node for primary dsi\n");

	dsi = serdes_attach_dsi(sd_panel, dsi_node);
	if (IS_ERR(dsi))
		return -EPROBE_DEFER;

	return 0;
}

static int rkx120_dsi_tx_parse(struct rk_serdes_panel *sd_panel)
{
	struct device_node *np = sd_panel->dev->of_node;
	struct rk_serdes *serdes = sd_panel->parent;
	struct rkx120_dsi_tx *dsi_tx = &serdes->dsi_tx;
	const char *string;
	int ret;
	u32 val;

	if (of_property_read_u32(np, "dsi-tx,lanes", &val))
		dsi_tx->lanes = 4;
	else
		dsi_tx->lanes = val;

	if (of_property_read_bool(np, "dsi-tx,video-mode"))
		dsi_tx->mode_flags |= SERDES_MIPI_DSI_MODE_LPM | SERDES_MIPI_DSI_MODE_VIDEO |
				      SERDES_MIPI_DSI_MODE_VIDEO_BURST;
	else
		dsi_tx->mode_flags |= SERDES_MIPI_DSI_MODE_LPM;

	if (of_property_read_bool(np, "dsi-tx,eotp"))
		dsi_tx->mode_flags |= SERDES_MIPI_DSI_MODE_EOT_PACKET;

	if (!of_property_read_string(np, "dsi-tx,format", &string)) {
		if (!strcmp(string, "rgb666")) {
			dsi_tx->bus_format = SERDES_MIPI_DSI_FMT_RGB666;
			dsi_tx->bpp = 24;
		} else if (!strcmp(string, "rgb666-packed")) {
			dsi_tx->bus_format = SERDES_MIPI_DSI_FMT_RGB666_PACKED;
			dsi_tx->bpp = 18;
		} else if (!strcmp(string, "rgb565")) {
			dsi_tx->bus_format = SERDES_MIPI_DSI_FMT_RGB565;
			dsi_tx->bpp = 16;
		} else {
			dsi_tx->bus_format = SERDES_MIPI_DSI_FMT_RGB888;
			dsi_tx->bpp = 24;
		}
	} else {
		dsi_tx->bus_format = SERDES_MIPI_DSI_FMT_RGB888;
		dsi_tx->bpp = 24;
	}

	ret = serdes_dsi_panel_get_cmds(sd_panel);
	if (ret) {
		dev_err(sd_panel->dev, "failed to get cmds\n");
		return ret;
	}

	return 0;
}

static int serdes_panel_parse_dt(struct rk_serdes_panel *sd_panel)
{
	struct rk_serdes_route *route = &sd_panel->route;
	struct rk_serdes *serdes = sd_panel->parent;
	u32 lanes;
	int ret;

	device_property_read_u32(sd_panel->dev, "local-port0", &route->local_port0);
	device_property_read_u32(sd_panel->dev, "local-port1", &route->local_port1);
	device_property_read_u32(sd_panel->dev, "remote0-port0", &route->remote0_port0);
	device_property_read_u32(sd_panel->dev, "remote0-port1", &route->remote0_port1);
	device_property_read_u32(sd_panel->dev, "remote1-port0", &route->remote1_port0);
	device_property_read_u32(sd_panel->dev, "remote1-port1", &route->remote1_port1);
	device_property_read_u32(sd_panel->dev, "num-lanes", &lanes);

	serdes->route_flag = 0;

	if (!route->local_port0) {
		dev_err(sd_panel->dev, "local_port0 should set\n");
		return -EINVAL;
	}

	if (!route->remote0_port0) {
		dev_err(sd_panel->dev, "remote0_port0 should set\n");
		return -EINVAL;
	}

	if (route->remote1_port0 && route->remote0_port1) {
		dev_err(sd_panel->dev, "too many output\n");
		return -EINVAL;
	}

	route->frame_mode = SERDES_FRAME_NORMAL_MODE;

	/* 2 video stream output */
	if (route->remote1_port0 || route->remote0_port1) {
		if (route->remote1_port0)
			serdes->route_flag |= ROUTE_MULTI_REMOTE | ROUTE_MULTI_CHANNEL |
					     ROUTE_MULTI_LANE;

		if (route->remote0_port1) {
			if ((route->remote0_port0 == RK_SERDES_LVDS_TX0) &&
			    (route->remote0_port1 == RK_SERDES_LVDS_TX1)) {
				serdes->route_flag |= ROUTE_MULTI_CHANNEL;
			} else if ((route->remote0_port0 == RK_SERDES_LVDS_TX1) &&
				    (route->remote0_port1 == RK_SERDES_LVDS_TX0)) {
				serdes->route_flag |= ROUTE_MULTI_CHANNEL;
			} else {
				dev_err(sd_panel->dev, "invalid multi output type\n");
				return -EINVAL;
			}

			if (lanes == 2)
				serdes->route_flag |= ROUTE_MULTI_LANE;
		}

		if (route->local_port1) {
			if ((route->local_port0 == RK_SERDES_DSI_RX0) &&
			    (route->local_port1 == RK_SERDES_DSI_RX1))
				serdes->route_flag |= ROUTE_MULTI_DSI_INPUT;
			else if ((route->local_port0 == RK_SERDES_DSI_RX1) &&
				 (route->local_port1 == RK_SERDES_DSI_RX0))
				serdes->route_flag |= ROUTE_MULTI_DSI_INPUT;
			else if ((route->local_port0 == RK_SERDES_LVDS_RX0) &&
				 (route->local_port1 == RK_SERDES_LVDS_RX1))
				serdes->route_flag |= ROUTE_MULTI_LVDS_INPUT;
			else if ((route->local_port0 == RK_SERDES_LVDS_RX1) &&
				 (route->local_port1 == RK_SERDES_LVDS_RX0))
				serdes->route_flag |= ROUTE_MULTI_LVDS_INPUT;
			else {
				dev_err(sd_panel->dev, "invalid multi input type\n");
				return -EINVAL;
			}
			serdes->route_flag |= ROUTE_MULTI_SOURCE;
		} else {
			if (device_property_read_bool(sd_panel->dev, "split-mode")) {
				/* only dsi input support split mode */
				if ((route->local_port0 != RK_SERDES_DSI_RX0) &&
				    (route->local_port0 != RK_SERDES_DSI_RX1)) {
					dev_err(sd_panel->dev,
						"local_port should be dsi in split mode\n");
					return -EINVAL;
				}
				if (device_property_read_bool(sd_panel->dev,
							      "sf-pixel-interleaved"))
					route->frame_mode = SERDES_SP_PIXEL_INTERLEAVED;
				else if (device_property_read_bool(sd_panel->dev,
								   "sf-line-interleaved"))
					route->frame_mode = SERDES_SP_LINE_INTERLEAVED;
				else
					route->frame_mode = SERDES_SP_LEFT_RIGHT_SPLIT;

				serdes->route_flag |= ROUTE_MULTI_SPLIT;

			} else  {
				serdes->route_flag |= ROUTE_MULTI_MIRROR;
			}
		}
	} else {
		if (lanes == 2)
			serdes->route_flag |= ROUTE_MULTI_LANE;
	}

	if (route->remote0_port0 & RK_SERDES_DSI_TX0 ||
	    route->remote1_port0 & RK_SERDES_DSI_TX0) {
		ret = rkx120_dsi_tx_parse(sd_panel);
		if (ret) {
			dev_err(sd_panel->dev, "failed to get cmds\n");
			return ret;
		}
	}

	if (route->local_port0 & RK_SERDES_DSI_RX0 ||
	    route->local_port0 & RK_SERDES_DSI_TX1) {
		ret = rkx120_dsi_rx_parse(sd_panel);
		if (ret < 0)
			return ret;
	}

	return 0;
}

static int serdes_panel_probe(struct platform_device *pdev)
{
	struct rk_serdes *serdes = dev_get_drvdata(pdev->dev.parent);
	struct rk_serdes_panel *sd_panel;
	int ret;

	sd_panel = devm_kzalloc(&pdev->dev, sizeof(*sd_panel), GFP_KERNEL);
	if (!sd_panel)
		return -ENOMEM;

	sd_panel->dev = &pdev->dev;
	sd_panel->parent = serdes;
	sd_panel->route.stream_type = STREAM_DISPLAY;
	serdes->vm = &sd_panel->route.vm;

	sd_panel->supply = devm_regulator_get_optional(sd_panel->dev, "power");
	if (IS_ERR(sd_panel->supply)) {
		ret = PTR_ERR(sd_panel->supply);

		if (ret != -ENODEV) {
			if (ret != -EPROBE_DEFER)
				dev_err(sd_panel->dev, "failed to request regulator: %d\n",
					ret);
			return ret;
		}

		sd_panel->supply = NULL;
	}

	/* Get GPIOs and backlight controller. */
	sd_panel->enable_gpio = devm_gpiod_get_optional(sd_panel->dev, "enable",
							GPIOD_OUT_LOW);
	if (IS_ERR(sd_panel->enable_gpio)) {
		ret = PTR_ERR(sd_panel->enable_gpio);
		dev_err(sd_panel->dev, "failed to request %s GPIO: %d\n",
			"enable", ret);
		return ret;
	}

	sd_panel->reset_gpio = devm_gpiod_get_optional(sd_panel->dev, "reset",
						       GPIOD_OUT_HIGH);
	if (IS_ERR(sd_panel->reset_gpio)) {
		ret = PTR_ERR(sd_panel->reset_gpio);
		dev_err(sd_panel->dev, "failed to request %s GPIO: %d\n",
			"reset", ret);
		return ret;
	}

	/* Register the panel. */
	drm_panel_init(&sd_panel->panel, sd_panel->dev, &serdes_panel_funcs, 0);

	ret = drm_panel_of_backlight(&sd_panel->panel);
	if (ret)
		return ret;

	drm_panel_add(&sd_panel->panel);

	dev_set_drvdata(sd_panel->dev, sd_panel);

	ret = serdes_panel_parse_dt(sd_panel);
	if (ret < 0) {
		drm_panel_remove(&sd_panel->panel);
		return ret;
	}

	return 0;
}

static int serdes_panel_remove(struct platform_device *pdev)
{
	struct rk_serdes_panel *sd_panel = dev_get_drvdata(&pdev->dev);

	drm_panel_remove(&sd_panel->panel);

	drm_panel_disable(&sd_panel->panel);

	return 0;
}

static const struct of_device_id serdes_panel_of_table[] = {
	{ .compatible = "rockchip,serdes-panel", },
	{ /* Sentinel */ },
};

MODULE_DEVICE_TABLE(of, serdes_panel_of_table);

static struct platform_driver serdes_panel_driver = {
	.probe		= serdes_panel_probe,
	.remove		= serdes_panel_remove,
	.driver		= {
		.name	= "serdes-panel",
		.of_match_table = serdes_panel_of_table,
	},
};

module_platform_driver(serdes_panel_driver);

MODULE_AUTHOR("Zhang Yubing <yubing.zhang@rock-chips.com>");
MODULE_DESCRIPTION("RKx110 RKx120 Panel Driver");
MODULE_LICENSE("GPL");