[mirror_ubuntu-focal-kernel.git] / drivers / gpu / drm / rcar-du / rcar_lvds.c

// SPDX-License-Identifier: GPL-2.0
/*
 * rcar_lvds.c  --  R-Car LVDS Encoder
 *
 * Copyright (C) 2013-2018 Renesas Electronics Corporation
 *
 * Contact: Laurent Pinchart (laurent.pinchart@ideasonboard.com)
 */

#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/io.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_graph.h>
#include <linux/platform_device.h>
#include <linux/slab.h>

#include <drm/drm_atomic.h>
#include <drm/drm_atomic_helper.h>
#include <drm/drm_bridge.h>
#include <drm/drm_crtc_helper.h>
#include <drm/drm_panel.h>

#include "rcar_lvds_regs.h"

/* Keep in sync with the LVDCR0.LVMD hardware register values. */
enum rcar_lvds_mode {
	RCAR_LVDS_MODE_JEIDA = 0,
	RCAR_LVDS_MODE_MIRROR = 1,
	RCAR_LVDS_MODE_VESA = 4,
};

#define RCAR_LVDS_QUIRK_LANES	(1 << 0)	/* LVDS lanes 1 and 3 inverted */
#define RCAR_LVDS_QUIRK_GEN2_PLLCR (1 << 1)	/* LVDPLLCR has gen2 layout */
#define RCAR_LVDS_QUIRK_GEN3_LVEN (1 << 2)	/* LVEN bit needs to be set */
						/* on R8A77970/R8A7799x */

struct rcar_lvds_device_info {
	unsigned int gen;
	unsigned int quirks;
};

struct rcar_lvds {
	struct device *dev;
	const struct rcar_lvds_device_info *info;

	struct drm_bridge bridge;

	struct drm_bridge *next_bridge;
	struct drm_connector connector;
	struct drm_panel *panel;

	void __iomem *mmio;
	struct clk *clock;
	bool enabled;

	struct drm_display_mode display_mode;
	enum rcar_lvds_mode mode;
};

#define bridge_to_rcar_lvds(bridge) \
	container_of(bridge, struct rcar_lvds, bridge)

#define connector_to_rcar_lvds(connector) \
	container_of(connector, struct rcar_lvds, connector)

static void rcar_lvds_write(struct rcar_lvds *lvds, u32 reg, u32 data)
{
	iowrite32(data, lvds->mmio + reg);
}

/* -----------------------------------------------------------------------------
 * Connector & Panel
 */

static int rcar_lvds_connector_get_modes(struct drm_connector *connector)
{
	struct rcar_lvds *lvds = connector_to_rcar_lvds(connector);

	return drm_panel_get_modes(lvds->panel);
}

static int rcar_lvds_connector_atomic_check(struct drm_connector *connector,
					    struct drm_connector_state *state)
{
	struct rcar_lvds *lvds = connector_to_rcar_lvds(connector);
	const struct drm_display_mode *panel_mode;
	struct drm_crtc_state *crtc_state;

	if (!state->crtc)
		return 0;

	if (list_empty(&connector->modes)) {
		dev_dbg(lvds->dev, "connector: empty modes list\n");
		return -EINVAL;
	}

	panel_mode = list_first_entry(&connector->modes,
				      struct drm_display_mode, head);

	/* We're not allowed to modify the resolution. */
	crtc_state = drm_atomic_get_crtc_state(state->state, state->crtc);
	if (IS_ERR(crtc_state))
		return PTR_ERR(crtc_state);

	if (crtc_state->mode.hdisplay != panel_mode->hdisplay ||
	    crtc_state->mode.vdisplay != panel_mode->vdisplay)
		return -EINVAL;

	/* The flat panel mode is fixed, just copy it to the adjusted mode. */
	drm_mode_copy(&crtc_state->adjusted_mode, panel_mode);

	return 0;
}

static const struct drm_connector_helper_funcs rcar_lvds_conn_helper_funcs = {
	.get_modes = rcar_lvds_connector_get_modes,
	.atomic_check = rcar_lvds_connector_atomic_check,
};

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

/* -----------------------------------------------------------------------------
 * Bridge
 */

static u32 rcar_lvds_lvdpllcr_gen2(unsigned int freq)
{
	if (freq < 39000)
		return LVDPLLCR_CEEN | LVDPLLCR_COSEL | LVDPLLCR_PLLDLYCNT_38M;
	else if (freq < 61000)
		return LVDPLLCR_CEEN | LVDPLLCR_COSEL | LVDPLLCR_PLLDLYCNT_60M;
	else if (freq < 121000)
		return LVDPLLCR_CEEN | LVDPLLCR_COSEL | LVDPLLCR_PLLDLYCNT_121M;
	else
		return LVDPLLCR_PLLDLYCNT_150M;
}

static u32 rcar_lvds_lvdpllcr_gen3(unsigned int freq)
{
	if (freq < 42000)
		return LVDPLLCR_PLLDIVCNT_42M;
	else if (freq < 85000)
		return LVDPLLCR_PLLDIVCNT_85M;
	else if (freq < 128000)
		return LVDPLLCR_PLLDIVCNT_128M;
	else
		return LVDPLLCR_PLLDIVCNT_148M;
}

static void rcar_lvds_enable(struct drm_bridge *bridge)
{
	struct rcar_lvds *lvds = bridge_to_rcar_lvds(bridge);
	const struct drm_display_mode *mode = &lvds->display_mode;
	/*
	 * FIXME: We should really retrieve the CRTC through the state, but how
	 * do we get a state pointer?
	 */
	struct drm_crtc *crtc = lvds->bridge.encoder->crtc;
	u32 lvdpllcr;
	u32 lvdhcr;
	u32 lvdcr0;
	int ret;

	WARN_ON(lvds->enabled);

	ret = clk_prepare_enable(lvds->clock);
	if (ret < 0)
		return;

	/*
	 * Hardcode the channels and control signals routing for now.
	 *
	 * HSYNC -> CTRL0
	 * VSYNC -> CTRL1
	 * DISP  -> CTRL2
	 * 0     -> CTRL3
	 */
	rcar_lvds_write(lvds, LVDCTRCR, LVDCTRCR_CTR3SEL_ZERO |
			LVDCTRCR_CTR2SEL_DISP | LVDCTRCR_CTR1SEL_VSYNC |
			LVDCTRCR_CTR0SEL_HSYNC);

	if (lvds->info->quirks & RCAR_LVDS_QUIRK_LANES)
		lvdhcr = LVDCHCR_CHSEL_CH(0, 0) | LVDCHCR_CHSEL_CH(1, 3)
		       | LVDCHCR_CHSEL_CH(2, 2) | LVDCHCR_CHSEL_CH(3, 1);
	else
		lvdhcr = LVDCHCR_CHSEL_CH(0, 0) | LVDCHCR_CHSEL_CH(1, 1)
		       | LVDCHCR_CHSEL_CH(2, 2) | LVDCHCR_CHSEL_CH(3, 3);

	rcar_lvds_write(lvds, LVDCHCR, lvdhcr);

	/* PLL clock configuration. */
	if (lvds->info->quirks & RCAR_LVDS_QUIRK_GEN2_PLLCR)
		lvdpllcr = rcar_lvds_lvdpllcr_gen2(mode->clock);
	else
		lvdpllcr = rcar_lvds_lvdpllcr_gen3(mode->clock);
	rcar_lvds_write(lvds, LVDPLLCR, lvdpllcr);

	/* Set the LVDS mode and select the input. */
	lvdcr0 = lvds->mode << LVDCR0_LVMD_SHIFT;
	if (drm_crtc_index(crtc) == 2)
		lvdcr0 |= LVDCR0_DUSEL;
	rcar_lvds_write(lvds, LVDCR0, lvdcr0);

	/* Turn all the channels on. */
	rcar_lvds_write(lvds, LVDCR1,
			LVDCR1_CHSTBY(3) | LVDCR1_CHSTBY(2) |
			LVDCR1_CHSTBY(1) | LVDCR1_CHSTBY(0) | LVDCR1_CLKSTBY);

	if (lvds->info->gen < 3) {
		/* Enable LVDS operation and turn the bias circuitry on. */
		lvdcr0 |= LVDCR0_BEN | LVDCR0_LVEN;
		rcar_lvds_write(lvds, LVDCR0, lvdcr0);
	}

	/* Turn the PLL on. */
	lvdcr0 |= LVDCR0_PLLON;
	rcar_lvds_write(lvds, LVDCR0, lvdcr0);

	if (lvds->info->gen > 2) {
		/* Set LVDS normal mode. */
		lvdcr0 |= LVDCR0_PWD;
		rcar_lvds_write(lvds, LVDCR0, lvdcr0);
	}

	if (lvds->info->quirks & RCAR_LVDS_QUIRK_GEN3_LVEN) {
		/* Turn on the LVDS PHY. */
		lvdcr0 |= LVDCR0_LVEN;
		rcar_lvds_write(lvds, LVDCR0, lvdcr0);
	}

	/* Wait for the startup delay. */
	usleep_range(100, 150);

	/* Turn the output on. */
	lvdcr0 |= LVDCR0_LVRES;
	rcar_lvds_write(lvds, LVDCR0, lvdcr0);

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

	lvds->enabled = true;
}

static void rcar_lvds_disable(struct drm_bridge *bridge)
{
	struct rcar_lvds *lvds = bridge_to_rcar_lvds(bridge);

	WARN_ON(!lvds->enabled);

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

	rcar_lvds_write(lvds, LVDCR0, 0);
	rcar_lvds_write(lvds, LVDCR1, 0);

	clk_disable_unprepare(lvds->clock);

	lvds->enabled = false;
}

static bool rcar_lvds_mode_fixup(struct drm_bridge *bridge,
				 const struct drm_display_mode *mode,
				 struct drm_display_mode *adjusted_mode)
{
	/*
	 * The internal LVDS encoder has a restricted clock frequency operating
	 * range (31MHz to 148.5MHz). Clamp the clock accordingly.
	 */
	adjusted_mode->clock = clamp(adjusted_mode->clock, 31000, 148500);

	return true;
}

static void rcar_lvds_get_lvds_mode(struct rcar_lvds *lvds)
{
	struct drm_display_info *info = &lvds->connector.display_info;
	enum rcar_lvds_mode mode;

	/*
	 * There is no API yet to retrieve LVDS mode from a bridge, only panels
	 * are supported.
	 */
	if (!lvds->panel)
		return;

	if (!info->num_bus_formats || !info->bus_formats) {
		dev_err(lvds->dev, "no LVDS bus format reported\n");
		return;
	}

	switch (info->bus_formats[0]) {
	case MEDIA_BUS_FMT_RGB666_1X7X3_SPWG:
	case MEDIA_BUS_FMT_RGB888_1X7X4_JEIDA:
		mode = RCAR_LVDS_MODE_JEIDA;
		break;
	case MEDIA_BUS_FMT_RGB888_1X7X4_SPWG:
		mode = RCAR_LVDS_MODE_VESA;
		break;
	default:
		dev_err(lvds->dev, "unsupported LVDS bus format 0x%04x\n",
			info->bus_formats[0]);
		return;
	}

	if (info->bus_flags & DRM_BUS_FLAG_DATA_LSB_TO_MSB)
		mode |= RCAR_LVDS_MODE_MIRROR;

	lvds->mode = mode;
}

static void rcar_lvds_mode_set(struct drm_bridge *bridge,
			       struct drm_display_mode *mode,
			       struct drm_display_mode *adjusted_mode)
{
	struct rcar_lvds *lvds = bridge_to_rcar_lvds(bridge);

	WARN_ON(lvds->enabled);

	lvds->display_mode = *adjusted_mode;

	rcar_lvds_get_lvds_mode(lvds);
}

static int rcar_lvds_attach(struct drm_bridge *bridge)
{
	struct rcar_lvds *lvds = bridge_to_rcar_lvds(bridge);
	struct drm_connector *connector = &lvds->connector;
	struct drm_encoder *encoder = bridge->encoder;
	int ret;

	/* If we have a next bridge just attach it. */
	if (lvds->next_bridge)
		return drm_bridge_attach(bridge->encoder, lvds->next_bridge,
					 bridge);

	/* Otherwise we have a panel, create a connector. */
	ret = drm_connector_init(bridge->dev, connector, &rcar_lvds_conn_funcs,
				 DRM_MODE_CONNECTOR_LVDS);
	if (ret < 0)
		return ret;

	drm_connector_helper_add(connector, &rcar_lvds_conn_helper_funcs);

	ret = drm_connector_attach_encoder(connector, encoder);
	if (ret < 0)
		return ret;

	return drm_panel_attach(lvds->panel, connector);
}

static void rcar_lvds_detach(struct drm_bridge *bridge)
{
	struct rcar_lvds *lvds = bridge_to_rcar_lvds(bridge);

	if (lvds->panel)
		drm_panel_detach(lvds->panel);
}

static const struct drm_bridge_funcs rcar_lvds_bridge_ops = {
	.attach = rcar_lvds_attach,
	.detach = rcar_lvds_detach,
	.enable = rcar_lvds_enable,
	.disable = rcar_lvds_disable,
	.mode_fixup = rcar_lvds_mode_fixup,
	.mode_set = rcar_lvds_mode_set,
};

/* -----------------------------------------------------------------------------
 * Probe & Remove
 */

static int rcar_lvds_parse_dt(struct rcar_lvds *lvds)
{
	struct device_node *local_output = NULL;
	struct device_node *remote_input = NULL;
	struct device_node *remote = NULL;
	struct device_node *node;
	bool is_bridge = false;
	int ret = 0;

	local_output = of_graph_get_endpoint_by_regs(lvds->dev->of_node, 1, 0);
	if (!local_output) {
		dev_dbg(lvds->dev, "unconnected port@1\n");
		return -ENODEV;
	}

	/*
	 * Locate the connected entity and infer its type from the number of
	 * endpoints.
	 */
	remote = of_graph_get_remote_port_parent(local_output);
	if (!remote) {
		dev_dbg(lvds->dev, "unconnected endpoint %pOF\n", local_output);
		ret = -ENODEV;
		goto done;
	}

	if (!of_device_is_available(remote)) {
		dev_dbg(lvds->dev, "connected entity %pOF is disabled\n",
			remote);
		ret = -ENODEV;
		goto done;
	}

	remote_input = of_graph_get_remote_endpoint(local_output);

	for_each_endpoint_of_node(remote, node) {
		if (node != remote_input) {
			/*
			 * We've found one endpoint other than the input, this
			 * must be a bridge.
			 */
			is_bridge = true;
			of_node_put(node);
			break;
		}
	}

	if (is_bridge) {
		lvds->next_bridge = of_drm_find_bridge(remote);
		if (!lvds->next_bridge)
			ret = -EPROBE_DEFER;
	} else {
		lvds->panel = of_drm_find_panel(remote);
		if (IS_ERR(lvds->panel))
			ret = PTR_ERR(lvds->panel);
	}

done:
	of_node_put(local_output);
	of_node_put(remote_input);
	of_node_put(remote);

	return ret;
}

static int rcar_lvds_probe(struct platform_device *pdev)
{
	struct rcar_lvds *lvds;
	struct resource *mem;
	int ret;

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

	platform_set_drvdata(pdev, lvds);

	lvds->dev = &pdev->dev;
	lvds->info = of_device_get_match_data(&pdev->dev);
	lvds->enabled = false;

	ret = rcar_lvds_parse_dt(lvds);
	if (ret < 0)
		return ret;

	lvds->bridge.driver_private = lvds;
	lvds->bridge.funcs = &rcar_lvds_bridge_ops;
	lvds->bridge.of_node = pdev->dev.of_node;

	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	lvds->mmio = devm_ioremap_resource(&pdev->dev, mem);
	if (IS_ERR(lvds->mmio))
		return PTR_ERR(lvds->mmio);

	lvds->clock = devm_clk_get(&pdev->dev, NULL);
	if (IS_ERR(lvds->clock)) {
		dev_err(&pdev->dev, "failed to get clock\n");
		return PTR_ERR(lvds->clock);
	}

	drm_bridge_add(&lvds->bridge);

	return 0;
}

static int rcar_lvds_remove(struct platform_device *pdev)
{
	struct rcar_lvds *lvds = platform_get_drvdata(pdev);

	drm_bridge_remove(&lvds->bridge);

	return 0;
}

static const struct rcar_lvds_device_info rcar_lvds_gen2_info = {
	.gen = 2,
	.quirks = RCAR_LVDS_QUIRK_GEN2_PLLCR,
};

static const struct rcar_lvds_device_info rcar_lvds_r8a7790_info = {
	.gen = 2,
	.quirks = RCAR_LVDS_QUIRK_GEN2_PLLCR | RCAR_LVDS_QUIRK_LANES,
};

static const struct rcar_lvds_device_info rcar_lvds_gen3_info = {
	.gen = 3,
};

static const struct rcar_lvds_device_info rcar_lvds_r8a77970_info = {
	.gen = 3,
	.quirks = RCAR_LVDS_QUIRK_GEN2_PLLCR | RCAR_LVDS_QUIRK_GEN3_LVEN,
};

static const struct of_device_id rcar_lvds_of_table[] = {
	{ .compatible = "renesas,r8a7743-lvds", .data = &rcar_lvds_gen2_info },
	{ .compatible = "renesas,r8a7790-lvds", .data = &rcar_lvds_r8a7790_info },
	{ .compatible = "renesas,r8a7791-lvds", .data = &rcar_lvds_gen2_info },
	{ .compatible = "renesas,r8a7793-lvds", .data = &rcar_lvds_gen2_info },
	{ .compatible = "renesas,r8a7795-lvds", .data = &rcar_lvds_gen3_info },
	{ .compatible = "renesas,r8a7796-lvds", .data = &rcar_lvds_gen3_info },
	{ .compatible = "renesas,r8a77970-lvds", .data = &rcar_lvds_r8a77970_info },
	{ }
};

MODULE_DEVICE_TABLE(of, rcar_lvds_of_table);

static struct platform_driver rcar_lvds_platform_driver = {
	.probe		= rcar_lvds_probe,
	.remove		= rcar_lvds_remove,
	.driver		= {
		.name	= "rcar-lvds",
		.of_match_table = rcar_lvds_of_table,
	},
};

module_platform_driver(rcar_lvds_platform_driver);

MODULE_AUTHOR("Laurent Pinchart <laurent.pinchart@ideasonboard.com>");
MODULE_DESCRIPTION("Renesas R-Car LVDS Encoder Driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
c6a27fa4 LP	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* rcar_lvds.c -- R-Car LVDS Encoder
	4	*
	5	* Copyright (C) 2013-2018 Renesas Electronics Corporation
	6	*
	7	* Contact: Laurent Pinchart (laurent.pinchart@ideasonboard.com)
	8	*/
	9
	10	#include <linux/clk.h>
	11	#include <linux/delay.h>
	12	#include <linux/io.h>
	13	#include <linux/of.h>
	14	#include <linux/of_device.h>
	15	#include <linux/of_graph.h>
	16	#include <linux/platform_device.h>
	17	#include <linux/slab.h>
	18
	19	#include <drm/drm_atomic.h>
	20	#include <drm/drm_atomic_helper.h>
	21	#include <drm/drm_bridge.h>
	22	#include <drm/drm_crtc_helper.h>
	23	#include <drm/drm_panel.h>
	24
	25	#include "rcar_lvds_regs.h"
	26
	27	/* Keep in sync with the LVDCR0.LVMD hardware register values. */
	28	enum rcar_lvds_mode {
	29	RCAR_LVDS_MODE_JEIDA = 0,
	30	RCAR_LVDS_MODE_MIRROR = 1,
	31	RCAR_LVDS_MODE_VESA = 4,
	32	};
	33
	34	#define RCAR_LVDS_QUIRK_LANES (1 << 0) /* LVDS lanes 1 and 3 inverted */
b6eb7102 SS	35	#define RCAR_LVDS_QUIRK_GEN2_PLLCR (1 << 1) /* LVDPLLCR has gen2 layout */
	36	#define RCAR_LVDS_QUIRK_GEN3_LVEN (1 << 2) /* LVEN bit needs to be set */
	37	/* on R8A77970/R8A7799x */
c6a27fa4 LP	38
	39	struct rcar_lvds_device_info {
	40	unsigned int gen;
	41	unsigned int quirks;
	42	};
	43
	44	struct rcar_lvds {
	45	struct device *dev;
	46	const struct rcar_lvds_device_info *info;
	47
	48	struct drm_bridge bridge;
	49
	50	struct drm_bridge *next_bridge;
	51	struct drm_connector connector;
	52	struct drm_panel *panel;
	53
	54	void __iomem *mmio;
	55	struct clk *clock;
	56	bool enabled;
	57
	58	struct drm_display_mode display_mode;
	59	enum rcar_lvds_mode mode;
	60	};
	61
	62	#define bridge_to_rcar_lvds(bridge) \
	63	container_of(bridge, struct rcar_lvds, bridge)
	64
	65	#define connector_to_rcar_lvds(connector) \
	66	container_of(connector, struct rcar_lvds, connector)
	67
	68	static void rcar_lvds_write(struct rcar_lvds *lvds, u32 reg, u32 data)
	69	{
	70	iowrite32(data, lvds->mmio + reg);
	71	}
	72
	73	/* -----------------------------------------------------------------------------
	74	* Connector & Panel
	75	*/
	76
	77	static int rcar_lvds_connector_get_modes(struct drm_connector *connector)
	78	{
	79	struct rcar_lvds *lvds = connector_to_rcar_lvds(connector);
	80
	81	return drm_panel_get_modes(lvds->panel);
	82	}
	83
	84	static int rcar_lvds_connector_atomic_check(struct drm_connector *connector,
	85	struct drm_connector_state *state)
	86	{
	87	struct rcar_lvds *lvds = connector_to_rcar_lvds(connector);
	88	const struct drm_display_mode *panel_mode;
	89	struct drm_crtc_state *crtc_state;
	90
643ca198 LP	91	if (!state->crtc)
	92	return 0;
	93
c6a27fa4 LP	94	if (list_empty(&connector->modes)) {
	95	dev_dbg(lvds->dev, "connector: empty modes list\n");
	96	return -EINVAL;
	97	}
	98
	99	panel_mode = list_first_entry(&connector->modes,
	100	struct drm_display_mode, head);
	101
	102	/* We're not allowed to modify the resolution. */
	103	crtc_state = drm_atomic_get_crtc_state(state->state, state->crtc);
	104	if (IS_ERR(crtc_state))
	105	return PTR_ERR(crtc_state);
	106
	107	if (crtc_state->mode.hdisplay != panel_mode->hdisplay \|\|
	108	crtc_state->mode.vdisplay != panel_mode->vdisplay)
	109	return -EINVAL;
	110
	111	/* The flat panel mode is fixed, just copy it to the adjusted mode. */
	112	drm_mode_copy(&crtc_state->adjusted_mode, panel_mode);
	113
	114	return 0;
	115	}
	116
	117	static const struct drm_connector_helper_funcs rcar_lvds_conn_helper_funcs = {
	118	.get_modes = rcar_lvds_connector_get_modes,
	119	.atomic_check = rcar_lvds_connector_atomic_check,
	120	};
	121
	122	static const struct drm_connector_funcs rcar_lvds_conn_funcs = {
	123	.reset = drm_atomic_helper_connector_reset,
	124	.fill_modes = drm_helper_probe_single_connector_modes,
	125	.destroy = drm_connector_cleanup,
	126	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
	127	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
	128	};
	129
	130	/* -----------------------------------------------------------------------------
	131	* Bridge
	132	*/
	133
	134	static u32 rcar_lvds_lvdpllcr_gen2(unsigned int freq)
	135	{
	136	if (freq < 39000)
	137	return LVDPLLCR_CEEN \| LVDPLLCR_COSEL \| LVDPLLCR_PLLDLYCNT_38M;
	138	else if (freq < 61000)
	139	return LVDPLLCR_CEEN \| LVDPLLCR_COSEL \| LVDPLLCR_PLLDLYCNT_60M;
	140	else if (freq < 121000)
	141	return LVDPLLCR_CEEN \| LVDPLLCR_COSEL \| LVDPLLCR_PLLDLYCNT_121M;
	142	else
	143	return LVDPLLCR_PLLDLYCNT_150M;
	144	}
	145
	146	static u32 rcar_lvds_lvdpllcr_gen3(unsigned int freq)
	147	{
	148	if (freq < 42000)
	149	return LVDPLLCR_PLLDIVCNT_42M;
	150	else if (freq < 85000)
	151	return LVDPLLCR_PLLDIVCNT_85M;
	152	else if (freq < 128000)
	153	return LVDPLLCR_PLLDIVCNT_128M;
	154	else
	155	return LVDPLLCR_PLLDIVCNT_148M;
	156	}
	157
158	static void rcar_lvds_enable(struct drm_bridge *bridge)
159	{
160	struct rcar_lvds *lvds = bridge_to_rcar_lvds(bridge);
161	const struct drm_display_mode *mode = &lvds->display_mode;
162	/*
163	* FIXME: We should really retrieve the CRTC through the state, but how
164	* do we get a state pointer?
165	*/
166	struct drm_crtc *crtc = lvds->bridge.encoder->crtc;
167	u32 lvdpllcr;
168	u32 lvdhcr;
169	u32 lvdcr0;
170	int ret;
171
172	WARN_ON(lvds->enabled);
173
174	ret = clk_prepare_enable(lvds->clock);
175	if (ret < 0)
176	return;
177
178	/*
179	* Hardcode the channels and control signals routing for now.
180	*
181	* HSYNC -> CTRL0
182	* VSYNC -> CTRL1
183	* DISP -> CTRL2
184	* 0 -> CTRL3
185	*/
186	rcar_lvds_write(lvds, LVDCTRCR, LVDCTRCR_CTR3SEL_ZERO \|
187	LVDCTRCR_CTR2SEL_DISP \| LVDCTRCR_CTR1SEL_VSYNC \|
188	LVDCTRCR_CTR0SEL_HSYNC);
189
190	if (lvds->info->quirks & RCAR_LVDS_QUIRK_LANES)
191	lvdhcr = LVDCHCR_CHSEL_CH(0, 0) \| LVDCHCR_CHSEL_CH(1, 3)
192	\| LVDCHCR_CHSEL_CH(2, 2) \| LVDCHCR_CHSEL_CH(3, 1);
193	else
194	lvdhcr = LVDCHCR_CHSEL_CH(0, 0) \| LVDCHCR_CHSEL_CH(1, 1)
195	\| LVDCHCR_CHSEL_CH(2, 2) \| LVDCHCR_CHSEL_CH(3, 3);
196
197	rcar_lvds_write(lvds, LVDCHCR, lvdhcr);
198
199	/* PLL clock configuration. */
b6eb7102	200	if (lvds->info->quirks & RCAR_LVDS_QUIRK_GEN2_PLLCR)
c6a27fa4 LP	201	lvdpllcr = rcar_lvds_lvdpllcr_gen2(mode->clock);
	202	else
	203	lvdpllcr = rcar_lvds_lvdpllcr_gen3(mode->clock);
	204	rcar_lvds_write(lvds, LVDPLLCR, lvdpllcr);
	205
	206	/* Set the LVDS mode and select the input. */
	207	lvdcr0 = lvds->mode << LVDCR0_LVMD_SHIFT;
	208	if (drm_crtc_index(crtc) == 2)
	209	lvdcr0 \|= LVDCR0_DUSEL;
	210	rcar_lvds_write(lvds, LVDCR0, lvdcr0);
	211
	212	/* Turn all the channels on. */
	213	rcar_lvds_write(lvds, LVDCR1,
	214	LVDCR1_CHSTBY(3) \| LVDCR1_CHSTBY(2) \|
	215	LVDCR1_CHSTBY(1) \| LVDCR1_CHSTBY(0) \| LVDCR1_CLKSTBY);
	216
	217	if (lvds->info->gen < 3) {
	218	/* Enable LVDS operation and turn the bias circuitry on. */
	219	lvdcr0 \|= LVDCR0_BEN \| LVDCR0_LVEN;
	220	rcar_lvds_write(lvds, LVDCR0, lvdcr0);
	221	}
	222
	223	/* Turn the PLL on. */
	224	lvdcr0 \|= LVDCR0_PLLON;
	225	rcar_lvds_write(lvds, LVDCR0, lvdcr0);
	226
	227	if (lvds->info->gen > 2) {
	228	/* Set LVDS normal mode. */
	229	lvdcr0 \|= LVDCR0_PWD;
	230	rcar_lvds_write(lvds, LVDCR0, lvdcr0);
	231	}
	232
b6eb7102 SS	233	if (lvds->info->quirks & RCAR_LVDS_QUIRK_GEN3_LVEN) {
	234	/* Turn on the LVDS PHY. */
	235	lvdcr0 \|= LVDCR0_LVEN;
	236	rcar_lvds_write(lvds, LVDCR0, lvdcr0);
	237	}
	238
c6a27fa4 LP	239	/* Wait for the startup delay. */
	240	usleep_range(100, 150);
	241
	242	/* Turn the output on. */
	243	lvdcr0 \|= LVDCR0_LVRES;
	244	rcar_lvds_write(lvds, LVDCR0, lvdcr0);
	245
	246	if (lvds->panel) {
	247	drm_panel_prepare(lvds->panel);
	248	drm_panel_enable(lvds->panel);
	249	}
	250
	251	lvds->enabled = true;
	252	}
	253
	254	static void rcar_lvds_disable(struct drm_bridge *bridge)
	255	{
	256	struct rcar_lvds *lvds = bridge_to_rcar_lvds(bridge);
	257
	258	WARN_ON(!lvds->enabled);
	259
	260	if (lvds->panel) {
	261	drm_panel_disable(lvds->panel);
	262	drm_panel_unprepare(lvds->panel);
	263	}
	264
	265	rcar_lvds_write(lvds, LVDCR0, 0);
	266	rcar_lvds_write(lvds, LVDCR1, 0);
	267
	268	clk_disable_unprepare(lvds->clock);
	269
	270	lvds->enabled = false;
	271	}
	272
	273	static bool rcar_lvds_mode_fixup(struct drm_bridge *bridge,
	274	const struct drm_display_mode *mode,
	275	struct drm_display_mode *adjusted_mode)
	276	{
	277	/*
	278	* The internal LVDS encoder has a restricted clock frequency operating
	279	* range (31MHz to 148.5MHz). Clamp the clock accordingly.
	280	*/
	281	adjusted_mode->clock = clamp(adjusted_mode->clock, 31000, 148500);
	282
	283	return true;
	284	}
	285
	286	static void rcar_lvds_get_lvds_mode(struct rcar_lvds *lvds)
	287	{
	288	struct drm_display_info *info = &lvds->connector.display_info;
	289	enum rcar_lvds_mode mode;
	290
	291	/*
	292	* There is no API yet to retrieve LVDS mode from a bridge, only panels
	293	* are supported.
	294	*/
	295	if (!lvds->panel)
	296	return;
	297
	298	if (!info->num_bus_formats \|\| !info->bus_formats) {
	299	dev_err(lvds->dev, "no LVDS bus format reported\n");
	300	return;
	301	}
	302
303	switch (info->bus_formats[0]) {
304	case MEDIA_BUS_FMT_RGB666_1X7X3_SPWG:
305	case MEDIA_BUS_FMT_RGB888_1X7X4_JEIDA:
306	mode = RCAR_LVDS_MODE_JEIDA;
307	break;
308	case MEDIA_BUS_FMT_RGB888_1X7X4_SPWG:
309	mode = RCAR_LVDS_MODE_VESA;
310	break;
311	default:
312	dev_err(lvds->dev, "unsupported LVDS bus format 0x%04x\n",
313	info->bus_formats[0]);
314	return;
315	}
316
317	if (info->bus_flags & DRM_BUS_FLAG_DATA_LSB_TO_MSB)
318	mode \|= RCAR_LVDS_MODE_MIRROR;
319
320	lvds->mode = mode;
321	}
322
323	static void rcar_lvds_mode_set(struct drm_bridge *bridge,
324	struct drm_display_mode *mode,
325	struct drm_display_mode *adjusted_mode)
326	{
327	struct rcar_lvds *lvds = bridge_to_rcar_lvds(bridge);
328
329	WARN_ON(lvds->enabled);
330
331	lvds->display_mode = *adjusted_mode;
332
333	rcar_lvds_get_lvds_mode(lvds);
334	}
335
336	static int rcar_lvds_attach(struct drm_bridge *bridge)
337	{
338	struct rcar_lvds *lvds = bridge_to_rcar_lvds(bridge);
339	struct drm_connector *connector = &lvds->connector;
340	struct drm_encoder *encoder = bridge->encoder;
341	int ret;
342
343	/* If we have a next bridge just attach it. */
344	if (lvds->next_bridge)
345	return drm_bridge_attach(bridge->encoder, lvds->next_bridge,
346	bridge);
347
348	/* Otherwise we have a panel, create a connector. */
349	ret = drm_connector_init(bridge->dev, connector, &rcar_lvds_conn_funcs,
350	DRM_MODE_CONNECTOR_LVDS);
351	if (ret < 0)
352	return ret;
353
354	drm_connector_helper_add(connector, &rcar_lvds_conn_helper_funcs);
355
cde4c44d	356	ret = drm_connector_attach_encoder(connector, encoder);
c6a27fa4 LP	357	if (ret < 0)
	358	return ret;
	359
	360	return drm_panel_attach(lvds->panel, connector);
	361	}
	362
	363	static void rcar_lvds_detach(struct drm_bridge *bridge)
	364	{
	365	struct rcar_lvds *lvds = bridge_to_rcar_lvds(bridge);
	366
	367	if (lvds->panel)
	368	drm_panel_detach(lvds->panel);
	369	}
	370
	371	static const struct drm_bridge_funcs rcar_lvds_bridge_ops = {
	372	.attach = rcar_lvds_attach,
	373	.detach = rcar_lvds_detach,
	374	.enable = rcar_lvds_enable,
	375	.disable = rcar_lvds_disable,
	376	.mode_fixup = rcar_lvds_mode_fixup,
	377	.mode_set = rcar_lvds_mode_set,
	378	};
	379
	380	/* -----------------------------------------------------------------------------
	381	* Probe & Remove
	382	*/
	383
	384	static int rcar_lvds_parse_dt(struct rcar_lvds *lvds)
	385	{
	386	struct device_node *local_output = NULL;
	387	struct device_node *remote_input = NULL;
	388	struct device_node *remote = NULL;
	389	struct device_node *node;
	390	bool is_bridge = false;
	391	int ret = 0;
	392
	393	local_output = of_graph_get_endpoint_by_regs(lvds->dev->of_node, 1, 0);
	394	if (!local_output) {
	395	dev_dbg(lvds->dev, "unconnected port@1\n");
	396	return -ENODEV;
	397	}
	398
	399	/*
	400	* Locate the connected entity and infer its type from the number of
	401	* endpoints.
	402	*/
	403	remote = of_graph_get_remote_port_parent(local_output);
	404	if (!remote) {
	405	dev_dbg(lvds->dev, "unconnected endpoint %pOF\n", local_output);
	406	ret = -ENODEV;
	407	goto done;
	408	}
	409
	410	if (!of_device_is_available(remote)) {
	411	dev_dbg(lvds->dev, "connected entity %pOF is disabled\n",
	412	remote);
	413	ret = -ENODEV;
	414	goto done;
	415	}
	416
	417	remote_input = of_graph_get_remote_endpoint(local_output);
	418
	419	for_each_endpoint_of_node(remote, node) {
	420	if (node != remote_input) {
421	/*
422	* We've found one endpoint other than the input, this
423	* must be a bridge.
424	*/
425	is_bridge = true;
426	of_node_put(node);
427	break;
428	}
429	}
430
431	if (is_bridge) {
432	lvds->next_bridge = of_drm_find_bridge(remote);
433	if (!lvds->next_bridge)
434	ret = -EPROBE_DEFER;
435	} else {
436	lvds->panel = of_drm_find_panel(remote);
5fa8e4a2 BB	437	if (IS_ERR(lvds->panel))
5fa8e4a2 BB	438	ret = PTR_ERR(lvds->panel);
c6a27fa4 LP	439	}
	440
	441	done:
	442	of_node_put(local_output);
	443	of_node_put(remote_input);
	444	of_node_put(remote);
	445
	446	return ret;
	447	}
	448
	449	static int rcar_lvds_probe(struct platform_device *pdev)
	450	{
	451	struct rcar_lvds *lvds;
	452	struct resource *mem;
	453	int ret;
	454
	455	lvds = devm_kzalloc(&pdev->dev, sizeof(*lvds), GFP_KERNEL);
	456	if (lvds == NULL)
	457	return -ENOMEM;
	458
	459	platform_set_drvdata(pdev, lvds);
	460
	461	lvds->dev = &pdev->dev;
	462	lvds->info = of_device_get_match_data(&pdev->dev);
	463	lvds->enabled = false;
	464
	465	ret = rcar_lvds_parse_dt(lvds);
	466	if (ret < 0)
	467	return ret;
	468
	469	lvds->bridge.driver_private = lvds;
	470	lvds->bridge.funcs = &rcar_lvds_bridge_ops;
	471	lvds->bridge.of_node = pdev->dev.of_node;
	472
	473	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	474	lvds->mmio = devm_ioremap_resource(&pdev->dev, mem);
	475	if (IS_ERR(lvds->mmio))
	476	return PTR_ERR(lvds->mmio);
	477
	478	lvds->clock = devm_clk_get(&pdev->dev, NULL);
	479	if (IS_ERR(lvds->clock)) {
	480	dev_err(&pdev->dev, "failed to get clock\n");
	481	return PTR_ERR(lvds->clock);
	482	}
	483
	484	drm_bridge_add(&lvds->bridge);
	485
	486	return 0;
	487	}
	488
	489	static int rcar_lvds_remove(struct platform_device *pdev)
	490	{
	491	struct rcar_lvds *lvds = platform_get_drvdata(pdev);
	492
	493	drm_bridge_remove(&lvds->bridge);
	494
	495	return 0;
	496	}
	497
	498	static const struct rcar_lvds_device_info rcar_lvds_gen2_info = {
	499	.gen = 2,
b6eb7102	500	.quirks = RCAR_LVDS_QUIRK_GEN2_PLLCR,
c6a27fa4 LP	501	};
	502
	503	static const struct rcar_lvds_device_info rcar_lvds_r8a7790_info = {
	504	.gen = 2,
b6eb7102	505	.quirks = RCAR_LVDS_QUIRK_GEN2_PLLCR \| RCAR_LVDS_QUIRK_LANES,
c6a27fa4 LP	506	};
	507
	508	static const struct rcar_lvds_device_info rcar_lvds_gen3_info = {
	509	.gen = 3,
	510	};
	511
b6eb7102 SS	512	static const struct rcar_lvds_device_info rcar_lvds_r8a77970_info = {
	513	.gen = 3,
	514	.quirks = RCAR_LVDS_QUIRK_GEN2_PLLCR \| RCAR_LVDS_QUIRK_GEN3_LVEN,
	515	};
	516
c6a27fa4 LP	517	static const struct of_device_id rcar_lvds_of_table[] = {
	518	{ .compatible = "renesas,r8a7743-lvds", .data = &rcar_lvds_gen2_info },
	519	{ .compatible = "renesas,r8a7790-lvds", .data = &rcar_lvds_r8a7790_info },
	520	{ .compatible = "renesas,r8a7791-lvds", .data = &rcar_lvds_gen2_info },
	521	{ .compatible = "renesas,r8a7793-lvds", .data = &rcar_lvds_gen2_info },
	522	{ .compatible = "renesas,r8a7795-lvds", .data = &rcar_lvds_gen3_info },
	523	{ .compatible = "renesas,r8a7796-lvds", .data = &rcar_lvds_gen3_info },
b6eb7102	524	{ .compatible = "renesas,r8a77970-lvds", .data = &rcar_lvds_r8a77970_info },
c6a27fa4 LP	525	{ }
	526	};
	527
	528	MODULE_DEVICE_TABLE(of, rcar_lvds_of_table);
	529
	530	static struct platform_driver rcar_lvds_platform_driver = {
	531	.probe = rcar_lvds_probe,
	532	.remove = rcar_lvds_remove,
	533	.driver = {
	534	.name = "rcar-lvds",
	535	.of_match_table = rcar_lvds_of_table,
	536	},
	537	};
	538
	539	module_platform_driver(rcar_lvds_platform_driver);
	540
	541	MODULE_AUTHOR("Laurent Pinchart <laurent.pinchart@ideasonboard.com>");
	542	MODULE_DESCRIPTION("Renesas R-Car LVDS Encoder Driver");
	543	MODULE_LICENSE("GPL");