Unverified Commit 711c7adc authored by Jagan Teki's avatar Jagan Teki Committed by Robert Foss
Browse files

drm: exynos: dsi: Use drm panel_bridge API 



Replace the manual panel handling code by a drm panel_bridge via
devm_drm_of_get_bridge().

Adding panel_bridge handling,

- Drops drm_connector and related operations as drm_bridge_attach
  creates connector during attachment.

- Drops panel pointer and iterate the bridge, so-that it can operate
  the normal bridge and panel_bridge in constitutive callbacks.

This simplifies the driver and allows all components in the display
pipeline to be treated as bridges.

Signed-off-by: default avatarJagan Teki <jagan@amarulasolutions.com>
Acked-by: default avatarMarek Szyprowski <m.szyprowski@samsung.com>
Tested-by: default avatarMarek Szyprowski <m.szyprowski@samsung.com>
Signed-off-by: default avatarRobert Foss <robert.foss@linaro.org>
Link: https://patchwork.freedesktop.org/patch/msgid/20220303163654.3381470-5-jagan@amarulasolutions.com
parent dd8b6803

drivers/gpu/drm/exynos/exynos_drm_dsi.c

+23 −134
Original line number Diff line number Diff line
@@ -24,9 +24,7 @@ 


#include <drm/drm_atomic_helper.h>

#include <drm/drm_bridge.h>

#include <drm/drm_fb_helper.h>

#include <drm/drm_mipi_dsi.h>

#include <drm/drm_panel.h>

#include <drm/drm_print.h>

#include <drm/drm_probe_helper.h>

#include <drm/drm_simple_kms_helper.h>
@@ -253,8 +251,6 @@ struct exynos_dsi_driver_data { 
struct exynos_dsi {

	struct drm_encoder encoder;

	struct mipi_dsi_host dsi_host;

	struct drm_connector connector;

	struct drm_panel *panel;

	struct list_head bridge_chain;

	struct drm_bridge *out_bridge;

	struct device *dev;
@@ -285,7 +281,6 @@ struct exynos_dsi { 
};



#define host_to_dsi(host) container_of(host, struct exynos_dsi, dsi_host)

#define connector_to_dsi(c) container_of(c, struct exynos_dsi, connector)



static inline struct exynos_dsi *encoder_to_dsi(struct drm_encoder *e)

{
@@ -1380,42 +1375,21 @@ static void exynos_dsi_enable(struct drm_encoder *encoder) 


	dsi->state |= DSIM_STATE_ENABLED;



	if (dsi->panel) {

		ret = drm_panel_prepare(dsi->panel);

		if (ret < 0)

			goto err_put_sync;

	} else {

		list_for_each_entry_reverse(iter, &dsi->bridge_chain,

					    chain_node) {

	list_for_each_entry_reverse(iter, &dsi->bridge_chain, chain_node) {

		if (iter->funcs->pre_enable)

			iter->funcs->pre_enable(iter);

	}

	}



	exynos_dsi_set_display_mode(dsi);

	exynos_dsi_set_display_enable(dsi, true);



	if (dsi->panel) {

		ret = drm_panel_enable(dsi->panel);

		if (ret < 0)

			goto err_display_disable;

	} else {

	list_for_each_entry(iter, &dsi->bridge_chain, chain_node) {

		if (iter->funcs->enable)

			iter->funcs->enable(iter);

	}

	}



	dsi->state |= DSIM_STATE_VIDOUT_AVAILABLE;

	return;



err_display_disable:

	exynos_dsi_set_display_enable(dsi, false);

	drm_panel_unprepare(dsi->panel);



err_put_sync:

	dsi->state &= ~DSIM_STATE_ENABLED;

	pm_runtime_put(dsi->dev);

}



static void exynos_dsi_disable(struct drm_encoder *encoder)
@@ -1428,15 +1402,12 @@ static void exynos_dsi_disable(struct drm_encoder *encoder) 


	dsi->state &= ~DSIM_STATE_VIDOUT_AVAILABLE;



	drm_panel_disable(dsi->panel);



	list_for_each_entry_reverse(iter, &dsi->bridge_chain, chain_node) {

		if (iter->funcs->disable)

			iter->funcs->disable(iter);

	}



	exynos_dsi_set_display_enable(dsi, false);

	drm_panel_unprepare(dsi->panel);



	list_for_each_entry(iter, &dsi->bridge_chain, chain_node) {

		if (iter->funcs->post_disable)
@@ -1456,70 +1427,6 @@ static void exynos_dsi_mode_set(struct drm_encoder *encoder, 
	drm_mode_copy(&dsi->mode, adjusted_mode);

}



static enum drm_connector_status

exynos_dsi_detect(struct drm_connector *connector, bool force)

{

	return connector->status;

}



static void exynos_dsi_connector_destroy(struct drm_connector *connector)

{

	drm_connector_unregister(connector);

	drm_connector_cleanup(connector);

	connector->dev = NULL;

}



static const struct drm_connector_funcs exynos_dsi_connector_funcs = {

	.detect = exynos_dsi_detect,

	.fill_modes = drm_helper_probe_single_connector_modes,

	.destroy = exynos_dsi_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 int exynos_dsi_get_modes(struct drm_connector *connector)

{

	struct exynos_dsi *dsi = connector_to_dsi(connector);



	if (dsi->panel)

		return drm_panel_get_modes(dsi->panel, connector);



	return 0;

}



static const struct drm_connector_helper_funcs exynos_dsi_connector_helper_funcs = {

	.get_modes = exynos_dsi_get_modes,

};



static int exynos_dsi_create_connector(struct drm_encoder *encoder)

{

	struct exynos_dsi *dsi = encoder_to_dsi(encoder);

	struct drm_connector *connector = &dsi->connector;

	struct drm_device *drm = encoder->dev;

	int ret;



	connector->polled = DRM_CONNECTOR_POLL_HPD;



	ret = drm_connector_init(drm, connector, &exynos_dsi_connector_funcs,

				 DRM_MODE_CONNECTOR_DSI);

	if (ret) {

		DRM_DEV_ERROR(dsi->dev,

			      "Failed to initialize connector with drm\n");

		return ret;

	}



	connector->status = connector_status_disconnected;

	drm_connector_helper_add(connector, &exynos_dsi_connector_helper_funcs);

	drm_connector_attach_encoder(connector, encoder);

	if (!drm->registered)

		return 0;



	connector->funcs->reset(connector);

	drm_connector_register(connector);

	return 0;

}



static const struct drm_encoder_helper_funcs exynos_dsi_encoder_helper_funcs = {

	.enable = exynos_dsi_enable,

	.disable = exynos_dsi_disable,
@@ -1532,32 +1439,22 @@ static int exynos_dsi_host_attach(struct mipi_dsi_host *host, 
				  struct mipi_dsi_device *device)

{

	struct exynos_dsi *dsi = host_to_dsi(host);

	struct device *dev = dsi->dev;

	struct drm_encoder *encoder = &dsi->encoder;

	struct drm_device *drm = encoder->dev;

	struct drm_bridge *out_bridge;



	out_bridge  = of_drm_find_bridge(device->dev.of_node);

	if (out_bridge) {

		drm_bridge_attach(encoder, out_bridge, NULL, 0);

		dsi->out_bridge = out_bridge;

		list_splice_init(&encoder->bridge_chain, &dsi->bridge_chain);

	} else {

		int ret = exynos_dsi_create_connector(encoder);

	int ret;



		if (ret) {

			DRM_DEV_ERROR(dsi->dev,

				      "failed to create connector ret = %d\n",

				      ret);

			drm_encoder_cleanup(encoder);

	dsi->out_bridge = devm_drm_of_get_bridge(dev, dev->of_node, 1, 0);

	if (IS_ERR(dsi->out_bridge)) {

		ret = PTR_ERR(dsi->out_bridge);

		DRM_DEV_ERROR(dev, "failed to find the bridge: %d\n", ret);

		return ret;

	}



		dsi->panel = of_drm_find_panel(device->dev.of_node);

		if (IS_ERR(dsi->panel))

			dsi->panel = NULL;

		else

			dsi->connector.status = connector_status_connected;

	}

	DRM_DEV_INFO(dev, "Attached %s device\n", device->name);



	drm_bridge_attach(encoder, dsi->out_bridge, NULL, 0);

	list_splice_init(&encoder->bridge_chain, &dsi->bridge_chain);



	/*

	 * This is a temporary solution and should be made by more generic way.
@@ -1566,7 +1463,7 @@ static int exynos_dsi_host_attach(struct mipi_dsi_host *host, 
	 * TE interrupt handler.

	 */

	if (!(device->mode_flags & MIPI_DSI_MODE_VIDEO)) {

		int ret = exynos_dsi_register_te_irq(dsi, &device->dev);

		ret = exynos_dsi_register_te_irq(dsi, &device->dev);

		if (ret)

			return ret;

	}
@@ -1593,18 +1490,10 @@ static int exynos_dsi_host_detach(struct mipi_dsi_host *host, 
	struct exynos_dsi *dsi = host_to_dsi(host);

	struct drm_device *drm = dsi->encoder.dev;



	if (dsi->panel) {

		mutex_lock(&drm->mode_config.mutex);

		exynos_dsi_disable(&dsi->encoder);

		dsi->panel = NULL;

		dsi->connector.status = connector_status_disconnected;

		mutex_unlock(&drm->mode_config.mutex);

	} else {

	if (dsi->out_bridge->funcs->detach)

		dsi->out_bridge->funcs->detach(dsi->out_bridge);

	dsi->out_bridge = NULL;

	INIT_LIST_HEAD(&dsi->bridge_chain);

	}



	if (drm->mode_config.poll_enabled)

		drm_kms_helper_hotplug_event(drm);