Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 080be03d authored by Sean Paul's avatar Sean Paul Committed by Inki Dae
Browse files

drm/exynos: Split manager/display/subdrv 



This patch splits display and manager from subdrv. The result is that
crtc functions can directly call into manager callbacks and encoder
functions can directly call into display callbacks. This will allow
us to remove the exynos_drm_hdmi shim and support mixer/hdmi & fimd/dp
with common code.

Signed-off-by: default avatarSean Paul <seanpaul@chromium.org>
Signed-off-by: default avatarInki Dae <inki.dae@samsung.com>
parent 3f283d93

drivers/gpu/drm/exynos/exynos_drm_connector.c

+20 −30
Original line number Diff line number Diff line
@@ -25,24 +25,18 @@ 
struct exynos_drm_connector {

	struct drm_connector		drm_connector;

	uint32_t			encoder_id;

	struct exynos_drm_manager *manager;

	struct exynos_drm_display	*display;

};



static int exynos_drm_connector_get_modes(struct drm_connector *connector)

{

	struct exynos_drm_connector *exynos_connector =

					to_exynos_connector(connector);

	struct exynos_drm_manager *manager = exynos_connector->manager;

	struct exynos_drm_display_ops *display_ops = manager->display_ops;

	struct exynos_drm_display *display = exynos_connector->display;

	struct edid *edid = NULL;

	unsigned int count = 0;

	int ret;



	if (!display_ops) {

		DRM_DEBUG_KMS("display_ops is null.\n");

		return 0;

	}



	/*

	 * if get_edid() exists then get_edid() callback of hdmi side

	 * is called to get edid data through i2c interface else
@@ -51,8 +45,8 @@ static int exynos_drm_connector_get_modes(struct drm_connector *connector) 
	 * P.S. in case of lcd panel, count is always 1 if success

	 * because lcd panel has only one mode.

	 */

	if (display_ops->get_edid) {

		edid = display_ops->get_edid(manager->dev, connector);

	if (display->ops->get_edid) {

		edid = display->ops->get_edid(display, connector);

		if (IS_ERR_OR_NULL(edid)) {

			ret = PTR_ERR(edid);

			edid = NULL;
@@ -75,8 +69,8 @@ static int exynos_drm_connector_get_modes(struct drm_connector *connector) 
			return 0;

		}



		if (display_ops->get_panel)

			panel = display_ops->get_panel(manager->dev);

		if (display->ops->get_panel)

			panel = display->ops->get_panel(display);

		else {

			drm_mode_destroy(connector->dev, mode);

			return 0;
@@ -105,14 +99,13 @@ static int exynos_drm_connector_mode_valid(struct drm_connector *connector, 
{

	struct exynos_drm_connector *exynos_connector =

					to_exynos_connector(connector);

	struct exynos_drm_manager *manager = exynos_connector->manager;

	struct exynos_drm_display_ops *display_ops = manager->display_ops;

	struct exynos_drm_display *display = exynos_connector->display;

	int ret = MODE_BAD;



	DRM_DEBUG_KMS("%s\n", __FILE__);



	if (display_ops && display_ops->check_mode)

		if (!display_ops->check_mode(manager->dev, mode))

	if (display->ops->check_mode)

		if (!display->ops->check_mode(display, mode))

			ret = MODE_OK;



	return ret;
@@ -151,8 +144,7 @@ static int exynos_drm_connector_fill_modes(struct drm_connector *connector, 
{

	struct exynos_drm_connector *exynos_connector =

					to_exynos_connector(connector);

	struct exynos_drm_manager *manager = exynos_connector->manager;

	struct exynos_drm_manager_ops *ops = manager->ops;

	struct exynos_drm_display *display = exynos_connector->display;

	unsigned int width, height;



	width = max_width;
@@ -162,8 +154,8 @@ static int exynos_drm_connector_fill_modes(struct drm_connector *connector, 
	 * if specific driver want to find desired_mode using maxmum

	 * resolution then get max width and height from that driver.

	 */

	if (ops && ops->get_max_resol)

		ops->get_max_resol(manager, &width, &height);

	if (display->ops->get_max_resol)

		display->ops->get_max_resol(display, &width, &height);



	return drm_helper_probe_single_connector_modes(connector, width,

							height);
@@ -175,13 +167,11 @@ exynos_drm_connector_detect(struct drm_connector *connector, bool force) 
{

	struct exynos_drm_connector *exynos_connector =

					to_exynos_connector(connector);

	struct exynos_drm_manager *manager = exynos_connector->manager;

	struct exynos_drm_display_ops *display_ops =

					manager->display_ops;

	struct exynos_drm_display *display = exynos_connector->display;

	enum drm_connector_status status = connector_status_disconnected;



	if (display_ops && display_ops->is_connected) {

		if (display_ops->is_connected(manager->dev))

	if (display->ops->is_connected) {

		if (display->ops->is_connected(display))

			status = connector_status_connected;

		else

			status = connector_status_disconnected;
@@ -211,7 +201,7 @@ struct drm_connector *exynos_drm_connector_create(struct drm_device *dev, 
						   struct drm_encoder *encoder)

{

	struct exynos_drm_connector *exynos_connector;

	struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);

	struct exynos_drm_display *display = exynos_drm_get_display(encoder);

	struct drm_connector *connector;

	int type;

	int err;
@@ -222,7 +212,7 @@ struct drm_connector *exynos_drm_connector_create(struct drm_device *dev, 


	connector = &exynos_connector->drm_connector;



	switch (manager->display_ops->type) {

	switch (display->type) {

	case EXYNOS_DISPLAY_TYPE_HDMI:

		type = DRM_MODE_CONNECTOR_HDMIA;

		connector->interlace_allowed = true;
@@ -245,7 +235,7 @@ struct drm_connector *exynos_drm_connector_create(struct drm_device *dev, 
		goto err_connector;



	exynos_connector->encoder_id = encoder->base.id;

	exynos_connector->manager = manager;

	exynos_connector->display = display;

	connector->dpms = DRM_MODE_DPMS_OFF;

	connector->encoder = encoder;

drivers/gpu/drm/exynos/exynos_drm_core.c

+134 −45
Original line number Diff line number Diff line
@@ -14,24 +14,31 @@ 


#include <drm/drmP.h>

#include "exynos_drm_drv.h"

#include "exynos_drm_crtc.h"

#include "exynos_drm_encoder.h"

#include "exynos_drm_connector.h"

#include "exynos_drm_fbdev.h"



static LIST_HEAD(exynos_drm_subdrv_list);

static LIST_HEAD(exynos_drm_manager_list);

static LIST_HEAD(exynos_drm_display_list);



static int exynos_drm_create_enc_conn(struct drm_device *dev,

					struct exynos_drm_subdrv *subdrv)

					struct exynos_drm_display *display)

{

	struct drm_encoder *encoder;

	struct drm_connector *connector;

	struct exynos_drm_manager *manager;

	int ret;

	unsigned long possible_crtcs = 0;



	subdrv->manager->dev = subdrv->dev;

	/* Find possible crtcs for this display */

	list_for_each_entry(manager, &exynos_drm_manager_list, list)

		if (manager->type == display->type)

			possible_crtcs |= 1 << manager->pipe;



	/* create and initialize a encoder for this sub driver. */

	encoder = exynos_drm_encoder_create(dev, subdrv->manager,

			(1 << MAX_CRTC) - 1);

	encoder = exynos_drm_encoder_create(dev, display, possible_crtcs);

	if (!encoder) {

		DRM_ERROR("failed to create encoder\n");

		return -EFAULT;
@@ -48,8 +55,8 @@ static int exynos_drm_create_enc_conn(struct drm_device *dev, 
		goto err_destroy_encoder;

	}



	subdrv->encoder = encoder;

	subdrv->connector = connector;

	display->encoder = encoder;

	display->connector = connector;



	return 0;
@@ -58,21 +65,6 @@ static int exynos_drm_create_enc_conn(struct drm_device *dev, 
	return ret;

}



static void exynos_drm_destroy_enc_conn(struct exynos_drm_subdrv *subdrv)

{

	if (subdrv->encoder) {

		struct drm_encoder *encoder = subdrv->encoder;

		encoder->funcs->destroy(encoder);

		subdrv->encoder = NULL;

	}



	if (subdrv->connector) {

		struct drm_connector *connector = subdrv->connector;

		connector->funcs->destroy(connector);

		subdrv->connector = NULL;

	}

}



static int exynos_drm_subdrv_probe(struct drm_device *dev,

					struct exynos_drm_subdrv *subdrv)

{
@@ -104,10 +96,98 @@ static void exynos_drm_subdrv_remove(struct drm_device *dev, 
		subdrv->remove(dev, subdrv->dev);

}



int exynos_drm_initialize_managers(struct drm_device *dev)

{

	struct exynos_drm_manager *manager, *n;

	int ret, pipe = 0;



	list_for_each_entry(manager, &exynos_drm_manager_list, list) {

		if (manager->ops->initialize) {

			ret = manager->ops->initialize(manager, dev, pipe);

			if (ret) {

				DRM_ERROR("Mgr init [%d] failed with %d\n",

						manager->type, ret);

				goto err;

			}

		}



		manager->drm_dev = dev;

		manager->pipe = pipe++;



		ret = exynos_drm_crtc_create(manager);

		if (ret) {

			DRM_ERROR("CRTC create [%d] failed with %d\n",

					manager->type, ret);

			goto err;

		}

	}

	return 0;



err:

	list_for_each_entry_safe(manager, n, &exynos_drm_manager_list, list) {

		if (pipe-- > 0)

			exynos_drm_manager_unregister(manager);

		else

			list_del(&manager->list);

	}

	return ret;

}



void exynos_drm_remove_managers(struct drm_device *dev)

{

	struct exynos_drm_manager *manager, *n;



	list_for_each_entry_safe(manager, n, &exynos_drm_manager_list, list)

		exynos_drm_manager_unregister(manager);

}



int exynos_drm_initialize_displays(struct drm_device *dev)

{

	struct exynos_drm_display *display, *n;

	int ret, initialized = 0;



	list_for_each_entry(display, &exynos_drm_display_list, list) {

		if (display->ops->initialize) {

			ret = display->ops->initialize(display, dev);

			if (ret) {

				DRM_ERROR("Display init [%d] failed with %d\n",

						display->type, ret);

				goto err;

			}

		}



		initialized++;



		ret = exynos_drm_create_enc_conn(dev, display);

		if (ret) {

			DRM_ERROR("Encoder create [%d] failed with %d\n",

					display->type, ret);

			goto err;

		}

	}

	return 0;



err:

	list_for_each_entry_safe(display, n, &exynos_drm_display_list, list) {

		if (initialized-- > 0)

			exynos_drm_display_unregister(display);

		else

			list_del(&display->list);

	}

	return ret;

}



void exynos_drm_remove_displays(struct drm_device *dev)

{

	struct exynos_drm_display *display, *n;



	list_for_each_entry_safe(display, n, &exynos_drm_display_list, list)

		exynos_drm_display_unregister(display);

}



int exynos_drm_device_register(struct drm_device *dev)

{

	struct exynos_drm_subdrv *subdrv, *n;

	unsigned int fine_cnt = 0;

	int err;



	if (!dev)
@@ -120,30 +200,8 @@ int exynos_drm_device_register(struct drm_device *dev) 
			list_del(&subdrv->list);

			continue;

		}



		/*

		 * if manager is null then it means that this sub driver

		 * doesn't need encoder and connector.

		 */

		if (!subdrv->manager) {

			fine_cnt++;

			continue;

		}



		err = exynos_drm_create_enc_conn(dev, subdrv);

		if (err) {

			DRM_DEBUG("failed to create encoder and connector.\n");

			exynos_drm_subdrv_remove(dev, subdrv);

			list_del(&subdrv->list);

			continue;

		}



		fine_cnt++;

	}



	if (!fine_cnt)

		return -EINVAL;



	return 0;

}

EXPORT_SYMBOL_GPL(exynos_drm_device_register);
@@ -159,13 +217,44 @@ int exynos_drm_device_unregister(struct drm_device *dev) 


	list_for_each_entry(subdrv, &exynos_drm_subdrv_list, list) {

		exynos_drm_subdrv_remove(dev, subdrv);

		exynos_drm_destroy_enc_conn(subdrv);

	}



	return 0;

}

EXPORT_SYMBOL_GPL(exynos_drm_device_unregister);



int exynos_drm_manager_register(struct exynos_drm_manager *manager)

{

	BUG_ON(!manager->ops);

	list_add_tail(&manager->list, &exynos_drm_manager_list);

	return 0;

}



int exynos_drm_manager_unregister(struct exynos_drm_manager *manager)

{

	if (manager->ops->remove)

		manager->ops->remove(manager);



	list_del(&manager->list);

	return 0;

}



int exynos_drm_display_register(struct exynos_drm_display *display)

{

	BUG_ON(!display->ops);

	list_add_tail(&display->list, &exynos_drm_display_list);

	return 0;

}



int exynos_drm_display_unregister(struct exynos_drm_display *display)

{

	if (display->ops->remove)

		display->ops->remove(display);



	list_del(&display->list);

	return 0;

}



int exynos_drm_subdrv_register(struct exynos_drm_subdrv *subdrv)

{

	if (!subdrv)

drivers/gpu/drm/exynos/exynos_drm_crtc.c

+92 −23
Original line number Diff line number Diff line
@@ -33,6 +33,7 @@ enum exynos_crtc_mode { 
 *

 * @drm_crtc: crtc object.

 * @drm_plane: pointer of private plane object for this crtc

 * @manager: the manager associated with this crtc

 * @pipe: a crtc index created at load() with a new crtc object creation

 *	and the crtc object would be set to private->crtc array

 *	to get a crtc object corresponding to this pipe from private->crtc
@@ -46,6 +47,7 @@ enum exynos_crtc_mode { 
struct exynos_drm_crtc {

	struct drm_crtc			drm_crtc;

	struct drm_plane		*plane;

	struct exynos_drm_manager	*manager;

	unsigned int			pipe;

	unsigned int			dpms;

	enum exynos_crtc_mode		mode;
@@ -56,6 +58,7 @@ struct exynos_drm_crtc { 
static void exynos_drm_crtc_dpms(struct drm_crtc *crtc, int mode)

{

	struct exynos_drm_crtc *exynos_crtc = to_exynos_crtc(crtc);

	struct exynos_drm_manager *manager = exynos_crtc->manager;



	DRM_DEBUG_KMS("crtc[%d] mode[%d]\n", crtc->base.id, mode);
@@ -71,7 +74,9 @@ static void exynos_drm_crtc_dpms(struct drm_crtc *crtc, int mode) 
		drm_vblank_off(crtc->dev, exynos_crtc->pipe);

	}



	exynos_drm_fn_encoder(crtc, &mode, exynos_drm_encoder_crtc_dpms);

	if (manager->ops->dpms)

		manager->ops->dpms(manager, mode);



	exynos_crtc->dpms = mode;

}
@@ -83,9 +88,15 @@ static void exynos_drm_crtc_prepare(struct drm_crtc *crtc) 
static void exynos_drm_crtc_commit(struct drm_crtc *crtc)

{

	struct exynos_drm_crtc *exynos_crtc = to_exynos_crtc(crtc);

	struct exynos_drm_manager *manager = exynos_crtc->manager;



	exynos_drm_crtc_dpms(crtc, DRM_MODE_DPMS_ON);



	exynos_plane_commit(exynos_crtc->plane);



	if (manager->ops->commit)

		manager->ops->commit(manager);



	exynos_plane_dpms(exynos_crtc->plane, DRM_MODE_DPMS_ON);

}
@@ -107,7 +118,6 @@ exynos_drm_crtc_mode_set(struct drm_crtc *crtc, struct drm_display_mode *mode, 
	struct drm_plane *plane = exynos_crtc->plane;

	unsigned int crtc_w;

	unsigned int crtc_h;

	int pipe = exynos_crtc->pipe;

	int ret;



	/*
@@ -127,8 +137,6 @@ exynos_drm_crtc_mode_set(struct drm_crtc *crtc, struct drm_display_mode *mode, 
	plane->crtc = crtc;

	plane->fb = crtc->fb;



	exynos_drm_fn_encoder(crtc, &pipe, exynos_drm_encoder_crtc_pipe);



	return 0;

}
@@ -318,21 +326,24 @@ static void exynos_drm_crtc_attach_mode_property(struct drm_crtc *crtc) 
	drm_object_attach_property(&crtc->base, prop, 0);

}



int exynos_drm_crtc_create(struct drm_device *dev, unsigned int nr)

int exynos_drm_crtc_create(struct exynos_drm_manager *manager)

{

	struct exynos_drm_crtc *exynos_crtc;

	struct exynos_drm_private *private = dev->dev_private;

	struct exynos_drm_private *private = manager->drm_dev->dev_private;

	struct drm_crtc *crtc;



	exynos_crtc = kzalloc(sizeof(*exynos_crtc), GFP_KERNEL);

	if (!exynos_crtc)

		return -ENOMEM;



	exynos_crtc->pipe = nr;

	exynos_crtc->dpms = DRM_MODE_DPMS_OFF;

	init_waitqueue_head(&exynos_crtc->pending_flip_queue);

	atomic_set(&exynos_crtc->pending_flip, 0);

	exynos_crtc->plane = exynos_plane_init(dev, 1 << nr, true);



	exynos_crtc->dpms = DRM_MODE_DPMS_OFF;

	exynos_crtc->manager = manager;

	exynos_crtc->pipe = manager->pipe;

	exynos_crtc->plane = exynos_plane_init(manager->drm_dev,

				1 << manager->pipe, true);

	if (!exynos_crtc->plane) {

		kfree(exynos_crtc);

		return -ENOMEM;
@@ -340,9 +351,9 @@ int exynos_drm_crtc_create(struct drm_device *dev, unsigned int nr) 


	crtc = &exynos_crtc->drm_crtc;



	private->crtc[nr] = crtc;

	private->crtc[manager->pipe] = crtc;



	drm_crtc_init(dev, crtc, &exynos_crtc_funcs);

	drm_crtc_init(manager->drm_dev, crtc, &exynos_crtc_funcs);

	drm_crtc_helper_add(crtc, &exynos_crtc_helper_funcs);



	exynos_drm_crtc_attach_mode_property(crtc);
@@ -350,39 +361,41 @@ int exynos_drm_crtc_create(struct drm_device *dev, unsigned int nr) 
	return 0;

}



int exynos_drm_crtc_enable_vblank(struct drm_device *dev, int crtc)

int exynos_drm_crtc_enable_vblank(struct drm_device *dev, int pipe)

{

	struct exynos_drm_private *private = dev->dev_private;

	struct exynos_drm_crtc *exynos_crtc =

		to_exynos_crtc(private->crtc[crtc]);

		to_exynos_crtc(private->crtc[pipe]);

	struct exynos_drm_manager *manager = exynos_crtc->manager;



	if (exynos_crtc->dpms != DRM_MODE_DPMS_ON)

		return -EPERM;



	exynos_drm_fn_encoder(private->crtc[crtc], &crtc,

			exynos_drm_enable_vblank);

	if (manager->ops->enable_vblank)

		manager->ops->enable_vblank(manager);



	return 0;

}



void exynos_drm_crtc_disable_vblank(struct drm_device *dev, int crtc)

void exynos_drm_crtc_disable_vblank(struct drm_device *dev, int pipe)

{

	struct exynos_drm_private *private = dev->dev_private;

	struct exynos_drm_crtc *exynos_crtc =

		to_exynos_crtc(private->crtc[crtc]);

		to_exynos_crtc(private->crtc[pipe]);

	struct exynos_drm_manager *manager = exynos_crtc->manager;



	if (exynos_crtc->dpms != DRM_MODE_DPMS_ON)

		return;



	exynos_drm_fn_encoder(private->crtc[crtc], &crtc,

			exynos_drm_disable_vblank);

	if (manager->ops->disable_vblank)

		manager->ops->disable_vblank(manager);

}



void exynos_drm_crtc_finish_pageflip(struct drm_device *dev, int crtc)

void exynos_drm_crtc_finish_pageflip(struct drm_device *dev, int pipe)

{

	struct exynos_drm_private *dev_priv = dev->dev_private;

	struct drm_pending_vblank_event *e, *t;

	struct drm_crtc *drm_crtc = dev_priv->crtc[crtc];

	struct drm_crtc *drm_crtc = dev_priv->crtc[pipe];

	struct exynos_drm_crtc *exynos_crtc = to_exynos_crtc(drm_crtc);

	unsigned long flags;
@@ -391,15 +404,71 @@ void exynos_drm_crtc_finish_pageflip(struct drm_device *dev, int crtc) 
	list_for_each_entry_safe(e, t, &dev_priv->pageflip_event_list,

			base.link) {

		/* if event's pipe isn't same as crtc then ignore it. */

		if (crtc != e->pipe)

		if (pipe != e->pipe)

			continue;



		list_del(&e->base.link);

		drm_send_vblank_event(dev, -1, e);

		drm_vblank_put(dev, crtc);

		drm_vblank_put(dev, pipe);

		atomic_set(&exynos_crtc->pending_flip, 0);

		wake_up(&exynos_crtc->pending_flip_queue);

	}



	spin_unlock_irqrestore(&dev->event_lock, flags);

}



void exynos_drm_crtc_plane_mode_set(struct drm_crtc *crtc,

			struct exynos_drm_overlay *overlay)

{

	struct exynos_drm_manager *manager = to_exynos_crtc(crtc)->manager;



	if (manager->ops->win_mode_set)

		manager->ops->win_mode_set(manager, overlay);

}



void exynos_drm_crtc_plane_commit(struct drm_crtc *crtc, int zpos)

{

	struct exynos_drm_manager *manager = to_exynos_crtc(crtc)->manager;



	if (manager->ops->win_commit)

		manager->ops->win_commit(manager, zpos);

}



void exynos_drm_crtc_plane_enable(struct drm_crtc *crtc, int zpos)

{

	struct exynos_drm_manager *manager = to_exynos_crtc(crtc)->manager;



	if (manager->ops->win_enable)

		manager->ops->win_enable(manager, zpos);

}



void exynos_drm_crtc_plane_disable(struct drm_crtc *crtc, int zpos)

{

	struct exynos_drm_manager *manager = to_exynos_crtc(crtc)->manager;



	if (manager->ops->win_disable)

		manager->ops->win_disable(manager, zpos);

}



void exynos_drm_crtc_complete_scanout(struct drm_framebuffer *fb)

{

	struct exynos_drm_manager *manager;

	struct drm_device *dev = fb->dev;

	struct drm_crtc *crtc;



	/*

	 * make sure that overlay data are updated to real hardware

	 * for all encoders.

	 */

	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {

		manager = to_exynos_crtc(crtc)->manager;



		/*

		 * wait for vblank interrupt

		 * - this makes sure that overlay data are updated to

		 *	real hardware.

		 */

		if (manager->ops->wait_for_vblank)

			manager->ops->wait_for_vblank(manager);

	}

}

drivers/gpu/drm/exynos/exynos_drm_crtc.h

+16 −4
Original line number Diff line number Diff line
@@ -15,9 +15,21 @@ 
#ifndef _EXYNOS_DRM_CRTC_H_

#define _EXYNOS_DRM_CRTC_H_



int exynos_drm_crtc_create(struct drm_device *dev, unsigned int nr);

int exynos_drm_crtc_enable_vblank(struct drm_device *dev, int crtc);

void exynos_drm_crtc_disable_vblank(struct drm_device *dev, int crtc);

void exynos_drm_crtc_finish_pageflip(struct drm_device *dev, int crtc);

struct drm_device;

struct drm_crtc;

struct exynos_drm_manager;

struct exynos_drm_overlay;



int exynos_drm_crtc_create(struct exynos_drm_manager *manager);

int exynos_drm_crtc_enable_vblank(struct drm_device *dev, int pipe);

void exynos_drm_crtc_disable_vblank(struct drm_device *dev, int pipe);

void exynos_drm_crtc_finish_pageflip(struct drm_device *dev, int pipe);

void exynos_drm_crtc_complete_scanout(struct drm_framebuffer *fb);



void exynos_drm_crtc_plane_mode_set(struct drm_crtc *crtc,

			struct exynos_drm_overlay *overlay);

void exynos_drm_crtc_plane_commit(struct drm_crtc *crtc, int zpos);

void exynos_drm_crtc_plane_enable(struct drm_crtc *crtc, int zpos);

void exynos_drm_crtc_plane_disable(struct drm_crtc *crtc, int zpos);



#endif

drivers/gpu/drm/exynos/exynos_drm_drv.c

+17 −12
Original line number Diff line number Diff line
@@ -74,15 +74,9 @@ static int exynos_drm_load(struct drm_device *dev, unsigned long flags) 


	exynos_drm_mode_config_init(dev);



	/*

	 * EXYNOS4 is enough to have two CRTCs and each crtc would be used

	 * without dependency of hardware.

	 */

	for (nr = 0; nr < MAX_CRTC; nr++) {

		ret = exynos_drm_crtc_create(dev, nr);

	ret = exynos_drm_initialize_managers(dev);

	if (ret)

			goto err_release_iommu_mapping;

	}

		goto err_mode_config_cleanup;



	for (nr = 0; nr < MAX_PLANE; nr++) {

		struct drm_plane *plane;
@@ -90,12 +84,16 @@ static int exynos_drm_load(struct drm_device *dev, unsigned long flags) 


		plane = exynos_plane_init(dev, possible_crtcs, false);

		if (!plane)

			goto err_release_iommu_mapping;

			goto err_manager_cleanup;

	}



	ret = exynos_drm_initialize_displays(dev);

	if (ret)

		goto err_manager_cleanup;



	ret = drm_vblank_init(dev, MAX_CRTC);

	if (ret)

		goto err_release_iommu_mapping;

		goto err_display_cleanup;



	/*

	 * probe sub drivers such as display controller and hdmi driver,
@@ -129,7 +127,12 @@ static int exynos_drm_load(struct drm_device *dev, unsigned long flags) 
	exynos_drm_device_unregister(dev);

err_vblank:

	drm_vblank_cleanup(dev);

err_release_iommu_mapping:

err_display_cleanup:

	exynos_drm_remove_displays(dev);

err_manager_cleanup:

	exynos_drm_remove_managers(dev);

err_mode_config_cleanup:

	drm_mode_config_cleanup(dev);

	drm_release_iommu_mapping(dev);

err_crtc:

	drm_mode_config_cleanup(dev);
@@ -144,6 +147,8 @@ static int exynos_drm_unload(struct drm_device *dev) 
	exynos_drm_device_unregister(dev);

	drm_vblank_cleanup(dev);

	drm_kms_helper_poll_fini(dev);

	exynos_drm_remove_displays(dev);

	exynos_drm_remove_managers(dev);

	drm_mode_config_cleanup(dev);



	drm_release_iommu_mapping(dev);