Commit 42dcf15f authored by Neil Armstrong's avatar Neil Armstrong
Browse files

drm/meson: add DSI encoder 



This adds an encoder bridge designed to drive a MIPI-DSI display
by using the ENCL encoder through the internal MIPI DSI transceiver
connected to the output of the ENCL pixel encoder.

Signed-off-by: default avatarNeil Armstrong <narmstrong@baylibre.com>
Reviewed-by: default avatarJagan Teki <jagan@amarulasolutions.com>
Reviewed-by: default avatarNicolas Belin <nbelin@baylibre.com>
Tested-by: Nicolas Belin <nbelin@baylibre.com> # on Khadas VIM3 + TS050 Panel
Signed-off-by: default avatarNeil Armstrong <neil.armstrong@linaro.org>
Link: https://patchwork.freedesktop.org/patch/msgid/20230512-amlogic-v6-4-upstream-dsi-ccf-vim3-v5-11-56eb7a4d5b8e@linaro.org
parent 51fc01a0

drivers/gpu/drm/meson/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -2,7 +2,7 @@ 
meson-drm-y := meson_drv.o meson_plane.o meson_crtc.o meson_encoder_cvbs.o

meson-drm-y += meson_viu.o meson_vpp.o meson_venc.o meson_vclk.o meson_overlay.o

meson-drm-y += meson_rdma.o meson_osd_afbcd.o

meson-drm-y += meson_encoder_hdmi.o

meson-drm-y += meson_encoder_hdmi.o meson_encoder_dsi.o



obj-$(CONFIG_DRM_MESON) += meson-drm.o

obj-$(CONFIG_DRM_MESON_DW_HDMI) += meson_dw_hdmi.o

drivers/gpu/drm/meson/meson_drv.c

+9 −0
Original line number Diff line number Diff line
@@ -34,6 +34,7 @@ 
#include "meson_registers.h"

#include "meson_encoder_cvbs.h"

#include "meson_encoder_hdmi.h"

#include "meson_encoder_dsi.h"

#include "meson_viu.h"

#include "meson_vpp.h"

#include "meson_rdma.h"
@@ -329,6 +330,12 @@ static int meson_drv_bind_master(struct device *dev, bool has_components) 
	if (ret)

		goto exit_afbcd;



	if (meson_vpu_is_compatible(priv, VPU_COMPATIBLE_G12A)) {

		ret = meson_encoder_dsi_init(priv);

		if (ret)

			goto exit_afbcd;

	}



	ret = meson_plane_create(priv);

	if (ret)

		goto exit_afbcd;
@@ -367,6 +374,7 @@ static int meson_drv_bind_master(struct device *dev, bool has_components) 
free_drm:

	drm_dev_put(drm);



	meson_encoder_dsi_remove(priv);

	meson_encoder_hdmi_remove(priv);

	meson_encoder_cvbs_remove(priv);
@@ -399,6 +407,7 @@ static void meson_drv_unbind(struct device *dev) 
	free_irq(priv->vsync_irq, drm);

	drm_dev_put(drm);



	meson_encoder_dsi_remove(priv);

	meson_encoder_hdmi_remove(priv);

	meson_encoder_cvbs_remove(priv);

drivers/gpu/drm/meson/meson_drv.h

+1 −0
Original line number Diff line number Diff line
@@ -28,6 +28,7 @@ enum vpu_compatible { 
enum {

	MESON_ENC_CVBS = 0,

	MESON_ENC_HDMI,

	MESON_ENC_DSI,

	MESON_ENC_LAST,

};

drivers/gpu/drm/meson/meson_encoder_dsi.c

0 → 100644
+174 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-or-later

/*

 * Copyright (C) 2016 BayLibre, SAS

 * Author: Neil Armstrong <narmstrong@baylibre.com>

 * Copyright (C) 2015 Amlogic, Inc. All rights reserved.

 */



#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/of_device.h>

#include <linux/of_graph.h>



#include <drm/drm_atomic_helper.h>

#include <drm/drm_simple_kms_helper.h>

#include <drm/drm_bridge.h>

#include <drm/drm_bridge_connector.h>

#include <drm/drm_device.h>

#include <drm/drm_probe_helper.h>



#include "meson_drv.h"

#include "meson_encoder_dsi.h"

#include "meson_registers.h"

#include "meson_venc.h"

#include "meson_vclk.h"



struct meson_encoder_dsi {

	struct drm_encoder encoder;

	struct drm_bridge bridge;

	struct drm_bridge *next_bridge;

	struct meson_drm *priv;

};



#define bridge_to_meson_encoder_dsi(x) \

	container_of(x, struct meson_encoder_dsi, bridge)



static int meson_encoder_dsi_attach(struct drm_bridge *bridge,

				    enum drm_bridge_attach_flags flags)

{

	struct meson_encoder_dsi *encoder_dsi = bridge_to_meson_encoder_dsi(bridge);



	return drm_bridge_attach(bridge->encoder, encoder_dsi->next_bridge,

				 &encoder_dsi->bridge, flags);

}



static void meson_encoder_dsi_atomic_enable(struct drm_bridge *bridge,

					    struct drm_bridge_state *bridge_state)

{

	struct meson_encoder_dsi *encoder_dsi = bridge_to_meson_encoder_dsi(bridge);

	struct drm_atomic_state *state = bridge_state->base.state;

	struct meson_drm *priv = encoder_dsi->priv;

	struct drm_connector_state *conn_state;

	struct drm_crtc_state *crtc_state;

	struct drm_connector *connector;



	connector = drm_atomic_get_new_connector_for_encoder(state, bridge->encoder);

	if (WARN_ON(!connector))

		return;



	conn_state = drm_atomic_get_new_connector_state(state, connector);

	if (WARN_ON(!conn_state))

		return;



	crtc_state = drm_atomic_get_new_crtc_state(state, conn_state->crtc);

	if (WARN_ON(!crtc_state))

		return;



	/* ENCL clock setup is handled by CCF */



	meson_venc_mipi_dsi_mode_set(priv, &crtc_state->adjusted_mode);

	meson_encl_load_gamma(priv);



	writel_relaxed(0, priv->io_base + _REG(ENCL_VIDEO_EN));



	writel_bits_relaxed(ENCL_VIDEO_MODE_ADV_VFIFO_EN, ENCL_VIDEO_MODE_ADV_VFIFO_EN,

			    priv->io_base + _REG(ENCL_VIDEO_MODE_ADV));

	writel_relaxed(0, priv->io_base + _REG(ENCL_TST_EN));



	writel_bits_relaxed(BIT(0), 0, priv->io_base + _REG(VPP_WRAP_OSD1_MATRIX_EN_CTRL));



	writel_relaxed(1, priv->io_base + _REG(ENCL_VIDEO_EN));

}



static void meson_encoder_dsi_atomic_disable(struct drm_bridge *bridge,

					     struct drm_bridge_state *bridge_state)

{

	struct meson_encoder_dsi *meson_encoder_dsi =

					bridge_to_meson_encoder_dsi(bridge);

	struct meson_drm *priv = meson_encoder_dsi->priv;



	writel_relaxed(0, priv->io_base + _REG(ENCL_VIDEO_EN));



	writel_bits_relaxed(BIT(0), BIT(0), priv->io_base + _REG(VPP_WRAP_OSD1_MATRIX_EN_CTRL));

}



static const struct drm_bridge_funcs meson_encoder_dsi_bridge_funcs = {

	.attach	= meson_encoder_dsi_attach,

	.atomic_enable = meson_encoder_dsi_atomic_enable,

	.atomic_disable	= meson_encoder_dsi_atomic_disable,

	.atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state,

	.atomic_destroy_state = drm_atomic_helper_bridge_destroy_state,

	.atomic_reset = drm_atomic_helper_bridge_reset,

};



int meson_encoder_dsi_init(struct meson_drm *priv)

{

	struct meson_encoder_dsi *meson_encoder_dsi;

	struct device_node *remote;

	int ret;



	meson_encoder_dsi = devm_kzalloc(priv->dev, sizeof(*meson_encoder_dsi), GFP_KERNEL);

	if (!meson_encoder_dsi)

		return -ENOMEM;



	/* DSI Transceiver Bridge */

	remote = of_graph_get_remote_node(priv->dev->of_node, 2, 0);

	if (!remote) {

		dev_err(priv->dev, "DSI transceiver device is disabled");

		return 0;

	}



	meson_encoder_dsi->next_bridge = of_drm_find_bridge(remote);

	if (!meson_encoder_dsi->next_bridge) {

		dev_dbg(priv->dev, "Failed to find DSI transceiver bridge\n");

		return -EPROBE_DEFER;

	}



	/* DSI Encoder Bridge */

	meson_encoder_dsi->bridge.funcs = &meson_encoder_dsi_bridge_funcs;

	meson_encoder_dsi->bridge.of_node = priv->dev->of_node;

	meson_encoder_dsi->bridge.type = DRM_MODE_CONNECTOR_DSI;



	drm_bridge_add(&meson_encoder_dsi->bridge);



	meson_encoder_dsi->priv = priv;



	/* Encoder */

	ret = drm_simple_encoder_init(priv->drm, &meson_encoder_dsi->encoder,

				      DRM_MODE_ENCODER_DSI);

	if (ret) {

		dev_err(priv->dev, "Failed to init DSI encoder: %d\n", ret);

		return ret;

	}



	meson_encoder_dsi->encoder.possible_crtcs = BIT(0);



	/* Attach DSI Encoder Bridge to Encoder */

	ret = drm_bridge_attach(&meson_encoder_dsi->encoder, &meson_encoder_dsi->bridge, NULL, 0);

	if (ret) {

		dev_err(priv->dev, "Failed to attach bridge: %d\n", ret);

		return ret;

	}



	/*

	 * We should have now in place:

	 * encoder->[dsi encoder bridge]->[dw-mipi-dsi bridge]->[panel bridge]->[panel]

	 */



	priv->encoders[MESON_ENC_DSI] = meson_encoder_dsi;



	dev_dbg(priv->dev, "DSI encoder initialized\n");



	return 0;

}



void meson_encoder_dsi_remove(struct meson_drm *priv)

{

	struct meson_encoder_dsi *meson_encoder_dsi;



	if (priv->encoders[MESON_ENC_DSI]) {

		meson_encoder_dsi = priv->encoders[MESON_ENC_DSI];

		drm_bridge_remove(&meson_encoder_dsi->bridge);

		drm_bridge_remove(meson_encoder_dsi->next_bridge);

	}

}

drivers/gpu/drm/meson/meson_encoder_dsi.h

0 → 100644
+13 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0-or-later */

/*

 * Copyright (C) 2021 BayLibre, SAS

 * Author: Neil Armstrong <narmstrong@baylibre.com>

 */



#ifndef __MESON_ENCODER_DSI_H

#define __MESON_ENCODER_DSI_H



int meson_encoder_dsi_init(struct meson_drm *priv);

void meson_encoder_dsi_remove(struct meson_drm *priv);



#endif /* __MESON_ENCODER_DSI_H */