[deliverable/linux.git] / drivers / gpu / drm / exynos / exynos_drm_encoder.c

/* exynos_drm_encoder.c
 *
 * Copyright (c) 2011 Samsung Electronics Co., Ltd.
 * Authors:
 *	Inki Dae <inki.dae@samsung.com>
 *	Joonyoung Shim <jy0922.shim@samsung.com>
 *	Seung-Woo Kim <sw0312.kim@samsung.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

#include "drmP.h"
#include "drm_crtc_helper.h"

#include "exynos_drm_drv.h"
#include "exynos_drm_encoder.h"
#include "exynos_drm_connector.h"

#define to_exynos_encoder(x)	container_of(x, struct exynos_drm_encoder,\
				drm_encoder)

/*
 * exynos specific encoder structure.
 *
 * @drm_encoder: encoder object.
 * @manager: specific encoder has its own manager to control a hardware
 *	appropriately and we can access a hardware drawing on this manager.
 * @dpms: store the encoder dpms value.
 */
struct exynos_drm_encoder {
	struct drm_crtc			*old_crtc;
	struct drm_encoder		drm_encoder;
	struct exynos_drm_manager	*manager;
	int dpms;
};

static void exynos_drm_connector_power(struct drm_encoder *encoder, int mode)
{
	struct drm_device *dev = encoder->dev;
	struct drm_connector *connector;

	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		if (connector->encoder == encoder) {
			DRM_DEBUG_KMS("connector[%d] dpms[%d]\n",
					connector->base.id, mode);

			exynos_drm_display_power(connector, mode);
		}
	}
}

static void exynos_drm_encoder_dpms(struct drm_encoder *encoder, int mode)
{
	struct drm_device *dev = encoder->dev;
	struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
	struct exynos_drm_manager_ops *manager_ops = manager->ops;
	struct exynos_drm_encoder *exynos_encoder = to_exynos_encoder(encoder);

	DRM_DEBUG_KMS("%s, encoder dpms: %d\n", __FILE__, mode);

	if (exynos_encoder->dpms == mode) {
		DRM_DEBUG_KMS("desired dpms mode is same as previous one.\n");
		return;
	}

	mutex_lock(&dev->struct_mutex);

	switch (mode) {
	case DRM_MODE_DPMS_ON:
		if (manager_ops && manager_ops->apply)
			manager_ops->apply(manager->dev);
		exynos_drm_connector_power(encoder, mode);
		exynos_encoder->dpms = mode;
		break;
	case DRM_MODE_DPMS_STANDBY:
	case DRM_MODE_DPMS_SUSPEND:
	case DRM_MODE_DPMS_OFF:
		exynos_drm_connector_power(encoder, mode);
		exynos_encoder->dpms = mode;
		break;
	default:
		DRM_ERROR("unspecified mode %d\n", mode);
		break;
	}

	mutex_unlock(&dev->struct_mutex);
}

static bool
exynos_drm_encoder_mode_fixup(struct drm_encoder *encoder,
			       const struct drm_display_mode *mode,
			       struct drm_display_mode *adjusted_mode)
{
	struct drm_device *dev = encoder->dev;
	struct drm_connector *connector;
	struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
	struct exynos_drm_manager_ops *manager_ops = manager->ops;

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

	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		if (connector->encoder == encoder)
			if (manager_ops && manager_ops->mode_fixup)
				manager_ops->mode_fixup(manager->dev, connector,
							mode, adjusted_mode);
	}

	return true;
}

static void disable_plane_to_crtc(struct drm_device *dev,
						struct drm_crtc *old_crtc,
						struct drm_crtc *new_crtc)
{
	struct drm_plane *plane;

	/*
	 * if old_crtc isn't same as encoder->crtc then it means that
	 * user changed crtc id to another one so the plane to old_crtc
	 * should be disabled and plane->crtc should be set to new_crtc
	 * (encoder->crtc)
	 */
	list_for_each_entry(plane, &dev->mode_config.plane_list, head) {
		if (plane->crtc == old_crtc) {
			/*
			 * do not change below call order.
			 *
			 * plane->funcs->disable_plane call checks
			 * if encoder->crtc is same as plane->crtc and if same
			 * then overlay_ops->disable callback will be called
			 * to diasble current hw overlay so plane->crtc should
			 * have new_crtc because new_crtc was set to
			 * encoder->crtc in advance.
			 */
			plane->crtc = new_crtc;
			plane->funcs->disable_plane(plane);
		}
	}
}

static void exynos_drm_encoder_mode_set(struct drm_encoder *encoder,
					 struct drm_display_mode *mode,
					 struct drm_display_mode *adjusted_mode)
{
	struct drm_device *dev = encoder->dev;
	struct drm_connector *connector;
	struct exynos_drm_manager *manager;
	struct exynos_drm_manager_ops *manager_ops;

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

	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		if (connector->encoder == encoder) {
			struct exynos_drm_encoder *exynos_encoder;

			exynos_encoder = to_exynos_encoder(encoder);

			if (exynos_encoder->old_crtc != encoder->crtc &&
					exynos_encoder->old_crtc) {

				/*
				 * disable a plane to old crtc and change
				 * crtc of the plane to new one.
				 */
				disable_plane_to_crtc(dev,
						exynos_encoder->old_crtc,
						encoder->crtc);
			}

			manager = exynos_drm_get_manager(encoder);
			manager_ops = manager->ops;

			if (manager_ops && manager_ops->mode_set)
				manager_ops->mode_set(manager->dev,
							adjusted_mode);

			exynos_encoder->old_crtc = encoder->crtc;
		}
	}
}

static void exynos_drm_encoder_prepare(struct drm_encoder *encoder)
{
	DRM_DEBUG_KMS("%s\n", __FILE__);

	/* drm framework doesn't check NULL. */
}

static void exynos_drm_encoder_commit(struct drm_encoder *encoder)
{
	struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
	struct exynos_drm_manager_ops *manager_ops = manager->ops;

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

	if (manager_ops && manager_ops->commit)
		manager_ops->commit(manager->dev);
}

static void exynos_drm_encoder_disable(struct drm_encoder *encoder)
{
	struct drm_plane *plane;
	struct drm_device *dev = encoder->dev;

	exynos_drm_encoder_dpms(encoder, DRM_MODE_DPMS_OFF);

	/* all planes connected to this encoder should be also disabled. */
	list_for_each_entry(plane, &dev->mode_config.plane_list, head) {
		if (plane->crtc == encoder->crtc)
			plane->funcs->disable_plane(plane);
	}
}

static struct drm_encoder_helper_funcs exynos_encoder_helper_funcs = {
	.dpms		= exynos_drm_encoder_dpms,
	.mode_fixup	= exynos_drm_encoder_mode_fixup,
	.mode_set	= exynos_drm_encoder_mode_set,
	.prepare	= exynos_drm_encoder_prepare,
	.commit		= exynos_drm_encoder_commit,
	.disable	= exynos_drm_encoder_disable,
};

static void exynos_drm_encoder_destroy(struct drm_encoder *encoder)
{
	struct exynos_drm_encoder *exynos_encoder =
		to_exynos_encoder(encoder);

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

	exynos_encoder->manager->pipe = -1;

	drm_encoder_cleanup(encoder);
	kfree(exynos_encoder);
}

static struct drm_encoder_funcs exynos_encoder_funcs = {
	.destroy = exynos_drm_encoder_destroy,
};

static unsigned int exynos_drm_encoder_clones(struct drm_encoder *encoder)
{
	struct drm_encoder *clone;
	struct drm_device *dev = encoder->dev;
	struct exynos_drm_encoder *exynos_encoder = to_exynos_encoder(encoder);
	struct exynos_drm_display_ops *display_ops =
				exynos_encoder->manager->display_ops;
	unsigned int clone_mask = 0;
	int cnt = 0;

	list_for_each_entry(clone, &dev->mode_config.encoder_list, head) {
		switch (display_ops->type) {
		case EXYNOS_DISPLAY_TYPE_LCD:
		case EXYNOS_DISPLAY_TYPE_HDMI:
		case EXYNOS_DISPLAY_TYPE_VIDI:
			clone_mask |= (1 << (cnt++));
			break;
		default:
			continue;
		}
	}

	return clone_mask;
}

void exynos_drm_encoder_setup(struct drm_device *dev)
{
	struct drm_encoder *encoder;

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

	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
		encoder->possible_clones = exynos_drm_encoder_clones(encoder);
}

struct drm_encoder *
exynos_drm_encoder_create(struct drm_device *dev,
			   struct exynos_drm_manager *manager,
			   unsigned int possible_crtcs)
{
	struct drm_encoder *encoder;
	struct exynos_drm_encoder *exynos_encoder;

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

	if (!manager || !possible_crtcs)
		return NULL;

	if (!manager->dev)
		return NULL;

	exynos_encoder = kzalloc(sizeof(*exynos_encoder), GFP_KERNEL);
	if (!exynos_encoder) {
		DRM_ERROR("failed to allocate encoder\n");
		return NULL;
	}

	exynos_encoder->dpms = DRM_MODE_DPMS_OFF;
	exynos_encoder->manager = manager;
	encoder = &exynos_encoder->drm_encoder;
	encoder->possible_crtcs = possible_crtcs;

	DRM_DEBUG_KMS("possible_crtcs = 0x%x\n", encoder->possible_crtcs);

	drm_encoder_init(dev, encoder, &exynos_encoder_funcs,
			DRM_MODE_ENCODER_TMDS);

	drm_encoder_helper_add(encoder, &exynos_encoder_helper_funcs);

	DRM_DEBUG_KMS("encoder has been created\n");

	return encoder;
}

struct exynos_drm_manager *exynos_drm_get_manager(struct drm_encoder *encoder)
{
	return to_exynos_encoder(encoder)->manager;
}

void exynos_drm_fn_encoder(struct drm_crtc *crtc, void *data,
			    void (*fn)(struct drm_encoder *, void *))
{
	struct drm_device *dev = crtc->dev;
	struct drm_encoder *encoder;
	struct exynos_drm_private *private = dev->dev_private;
	struct exynos_drm_manager *manager;

	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
		/*
		 * if crtc is detached from encoder, check pipe,
		 * otherwise check crtc attached to encoder
		 */
		if (!encoder->crtc) {
			manager = to_exynos_encoder(encoder)->manager;
			if (manager->pipe < 0 ||
					private->crtc[manager->pipe] != crtc)
				continue;
		} else {
			if (encoder->crtc != crtc)
				continue;
		}

		fn(encoder, data);
	}
}

void exynos_drm_enable_vblank(struct drm_encoder *encoder, void *data)
{
	struct exynos_drm_manager *manager =
		to_exynos_encoder(encoder)->manager;
	struct exynos_drm_manager_ops *manager_ops = manager->ops;
	int crtc = *(int *)data;

	if (manager->pipe != crtc)
		return;

	if (manager_ops->enable_vblank)
		manager_ops->enable_vblank(manager->dev);
}

void exynos_drm_disable_vblank(struct drm_encoder *encoder, void *data)
{
	struct exynos_drm_manager *manager =
		to_exynos_encoder(encoder)->manager;
	struct exynos_drm_manager_ops *manager_ops = manager->ops;
	int crtc = *(int *)data;

	if (manager->pipe != crtc)
		return;

	if (manager_ops->disable_vblank)
		manager_ops->disable_vblank(manager->dev);
}

void exynos_drm_encoder_crtc_dpms(struct drm_encoder *encoder, void *data)
{
	struct exynos_drm_encoder *exynos_encoder = to_exynos_encoder(encoder);
	struct exynos_drm_manager *manager = exynos_encoder->manager;
	struct exynos_drm_manager_ops *manager_ops = manager->ops;
	int mode = *(int *)data;

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

	if (manager_ops && manager_ops->dpms)
		manager_ops->dpms(manager->dev, mode);

	/*
	 * set current mode to new one so that data aren't updated into
	 * registers by drm_helper_connector_dpms two times.
	 *
	 * in case that drm_crtc_helper_set_mode() is called,
	 * overlay_ops->commit() and manager_ops->commit() callbacks
	 * can be called two times, first at drm_crtc_helper_set_mode()
	 * and second at drm_helper_connector_dpms().
	 * so with this setting, when drm_helper_connector_dpms() is called
	 * encoder->funcs->dpms() will be ignored.
	 */
	exynos_encoder->dpms = mode;

	/*
	 * if this condition is ok then it means that the crtc is already
	 * detached from encoder and last function for detaching is properly
	 * done, so clear pipe from manager to prevent repeated call.
	 */
	if (mode > DRM_MODE_DPMS_ON) {
		if (!encoder->crtc)
			manager->pipe = -1;
	}
}

void exynos_drm_encoder_crtc_pipe(struct drm_encoder *encoder, void *data)
{
	struct exynos_drm_manager *manager =
		to_exynos_encoder(encoder)->manager;
	int pipe = *(int *)data;

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

	/*
	 * when crtc is detached from encoder, this pipe is used
	 * to select manager operation
	 */
	manager->pipe = pipe;
}

void exynos_drm_encoder_plane_mode_set(struct drm_encoder *encoder, void *data)
{
	struct exynos_drm_manager *manager =
		to_exynos_encoder(encoder)->manager;
	struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
	struct exynos_drm_overlay *overlay = data;

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

	if (overlay_ops && overlay_ops->mode_set)
		overlay_ops->mode_set(manager->dev, overlay);
}

void exynos_drm_encoder_plane_commit(struct drm_encoder *encoder, void *data)
{
	struct exynos_drm_manager *manager =
		to_exynos_encoder(encoder)->manager;
	struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
	int zpos = DEFAULT_ZPOS;

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

	if (data)
		zpos = *(int *)data;

	if (overlay_ops && overlay_ops->commit)
		overlay_ops->commit(manager->dev, zpos);
}

void exynos_drm_encoder_plane_enable(struct drm_encoder *encoder, void *data)
{
	struct exynos_drm_manager *manager =
		to_exynos_encoder(encoder)->manager;
	struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
	int zpos = DEFAULT_ZPOS;

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

	if (data)
		zpos = *(int *)data;

	if (overlay_ops && overlay_ops->enable)
		overlay_ops->enable(manager->dev, zpos);
}

void exynos_drm_encoder_plane_disable(struct drm_encoder *encoder, void *data)
{
	struct exynos_drm_manager *manager =
		to_exynos_encoder(encoder)->manager;
	struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
	int zpos = DEFAULT_ZPOS;

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

	if (data)
		zpos = *(int *)data;

	if (overlay_ops && overlay_ops->disable)
		overlay_ops->disable(manager->dev, zpos);

	/*
	 * wait for vblank interrupt
	 * - this makes sure that hardware overlay is disabled to avoid
	 * for the dma accesses to memory after gem buffer was released
	 * because the setting for disabling the overlay will be updated
	 * at vsync.
	 */
	if (overlay_ops->wait_for_vblank)
		overlay_ops->wait_for_vblank(manager->dev);
}
Commit	Line	Data
1c248b7d ID	1	/* exynos_drm_encoder.c
	2	*
	3	* Copyright (c) 2011 Samsung Electronics Co., Ltd.
	4	* Authors:
	5	* Inki Dae <inki.dae@samsung.com>
	6	* Joonyoung Shim <jy0922.shim@samsung.com>
	7	* Seung-Woo Kim <sw0312.kim@samsung.com>
	8	*
	9	* Permission is hereby granted, free of charge, to any person obtaining a
	10	* copy of this software and associated documentation files (the "Software"),
	11	* to deal in the Software without restriction, including without limitation
	12	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	13	* and/or sell copies of the Software, and to permit persons to whom the
	14	* Software is furnished to do so, subject to the following conditions:
	15	*
	16	* The above copyright notice and this permission notice (including the next
	17	* paragraph) shall be included in all copies or substantial portions of the
	18	* Software.
	19	*
	20	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	21	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	22	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	23	* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
	24	* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
	25	* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
	26	* OTHER DEALINGS IN THE SOFTWARE.
	27	*/
	28
	29	#include "drmP.h"
	30	#include "drm_crtc_helper.h"
	31
	32	#include "exynos_drm_drv.h"
1c248b7d	33	#include "exynos_drm_encoder.h"
50caf25c	34	#include "exynos_drm_connector.h"
1c248b7d ID	35
	36	#define to_exynos_encoder(x) container_of(x, struct exynos_drm_encoder,\
	37	drm_encoder)
	38
	39	/*
	40	* exynos specific encoder structure.
	41	*
	42	* @drm_encoder: encoder object.
	43	* @manager: specific encoder has its own manager to control a hardware
	44	* appropriately and we can access a hardware drawing on this manager.
ec05da95	45	* @dpms: store the encoder dpms value.
1c248b7d ID	46	*/
1c248b7d ID	47	struct exynos_drm_encoder {
1b85a071	48	struct drm_crtc *old_crtc;
1c248b7d ID	49	struct drm_encoder drm_encoder;
1c248b7d ID	50	struct exynos_drm_manager *manager;
ec05da95	51	int dpms;
1c248b7d ID	52	};
1c248b7d ID	53
50caf25c	54	static void exynos_drm_connector_power(struct drm_encoder *encoder, int mode)
1c248b7d ID	55	{
	56	struct drm_device *dev = encoder->dev;
	57	struct drm_connector *connector;
ec05da95 ID	58
	59	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
	60	if (connector->encoder == encoder) {
ec05da95 ID	61	DRM_DEBUG_KMS("connector[%d] dpms[%d]\n",
ec05da95 ID	62	connector->base.id, mode);
50caf25c ID	63
50caf25c ID	64	exynos_drm_display_power(connector, mode);
ec05da95 ID	65	}
	66	}
	67	}
	68
	69	static void exynos_drm_encoder_dpms(struct drm_encoder *encoder, int mode)
	70	{
	71	struct drm_device *dev = encoder->dev;
	72	struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
396464df	73	struct exynos_drm_manager_ops *manager_ops = manager->ops;
ec05da95	74	struct exynos_drm_encoder *exynos_encoder = to_exynos_encoder(encoder);
1c248b7d ID	75
	76	DRM_DEBUG_KMS("%s, encoder dpms: %d\n", __FILE__, mode);
	77
ec05da95 ID	78	if (exynos_encoder->dpms == mode) {
	79	DRM_DEBUG_KMS("desired dpms mode is same as previous one.\n");
	80	return;
	81	}
	82
	83	mutex_lock(&dev->struct_mutex);
	84
396464df JS	85	switch (mode) {
396464df JS	86	case DRM_MODE_DPMS_ON:
ec05da95 ID	87	if (manager_ops && manager_ops->apply)
ec05da95 ID	88	manager_ops->apply(manager->dev);
50caf25c	89	exynos_drm_connector_power(encoder, mode);
ec05da95	90	exynos_encoder->dpms = mode;
396464df JS	91	break;
	92	case DRM_MODE_DPMS_STANDBY:
	93	case DRM_MODE_DPMS_SUSPEND:
	94	case DRM_MODE_DPMS_OFF:
50caf25c	95	exynos_drm_connector_power(encoder, mode);
ec05da95	96	exynos_encoder->dpms = mode;
396464df JS	97	break;
	98	default:
	99	DRM_ERROR("unspecified mode %d\n", mode);
	100	break;
	101	}
	102
ec05da95	103	mutex_unlock(&dev->struct_mutex);
1c248b7d ID	104	}
	105
	106	static bool
	107	exynos_drm_encoder_mode_fixup(struct drm_encoder *encoder,
e811f5ae	108	const struct drm_display_mode *mode,
1c248b7d ID	109	struct drm_display_mode *adjusted_mode)
1c248b7d ID	110	{
1de425b0 ID	111	struct drm_device *dev = encoder->dev;
	112	struct drm_connector *connector;
	113	struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
	114	struct exynos_drm_manager_ops *manager_ops = manager->ops;
	115
1c248b7d ID	116	DRM_DEBUG_KMS("%s\n", __FILE__);
1c248b7d ID	117
1de425b0 ID	118	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
	119	if (connector->encoder == encoder)
	120	if (manager_ops && manager_ops->mode_fixup)
	121	manager_ops->mode_fixup(manager->dev, connector,
	122	mode, adjusted_mode);
	123	}
1c248b7d ID	124
	125	return true;
	126	}
	127
1b85a071 ID	128	static void disable_plane_to_crtc(struct drm_device *dev,
	129	struct drm_crtc *old_crtc,
	130	struct drm_crtc *new_crtc)
	131	{
	132	struct drm_plane *plane;
	133
	134	/*
	135	* if old_crtc isn't same as encoder->crtc then it means that
	136	* user changed crtc id to another one so the plane to old_crtc
	137	* should be disabled and plane->crtc should be set to new_crtc
	138	* (encoder->crtc)
	139	*/
	140	list_for_each_entry(plane, &dev->mode_config.plane_list, head) {
	141	if (plane->crtc == old_crtc) {
	142	/*
	143	* do not change below call order.
	144	*
	145	* plane->funcs->disable_plane call checks
	146	* if encoder->crtc is same as plane->crtc and if same
	147	* then overlay_ops->disable callback will be called
	148	* to diasble current hw overlay so plane->crtc should
	149	* have new_crtc because new_crtc was set to
	150	* encoder->crtc in advance.
	151	*/
	152	plane->crtc = new_crtc;
	153	plane->funcs->disable_plane(plane);
	154	}
	155	}
	156	}
	157
1c248b7d ID	158	static void exynos_drm_encoder_mode_set(struct drm_encoder *encoder,
	159	struct drm_display_mode *mode,
	160	struct drm_display_mode *adjusted_mode)
	161	{
	162	struct drm_device *dev = encoder->dev;
	163	struct drm_connector *connector;
1b85a071 ID	164	struct exynos_drm_manager *manager;
1b85a071 ID	165	struct exynos_drm_manager_ops *manager_ops;
1c248b7d ID	166
	167	DRM_DEBUG_KMS("%s\n", __FILE__);
	168
1c248b7d	169	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1b85a071 ID	170	if (connector->encoder == encoder) {
	171	struct exynos_drm_encoder *exynos_encoder;
	172
	173	exynos_encoder = to_exynos_encoder(encoder);
	174
	175	if (exynos_encoder->old_crtc != encoder->crtc &&
	176	exynos_encoder->old_crtc) {
	177
	178	/*
	179	* disable a plane to old crtc and change
	180	* crtc of the plane to new one.
	181	*/
	182	disable_plane_to_crtc(dev,
	183	exynos_encoder->old_crtc,
	184	encoder->crtc);
	185	}
	186
	187	manager = exynos_drm_get_manager(encoder);
	188	manager_ops = manager->ops;
	189
1c248b7d	190	if (manager_ops && manager_ops->mode_set)
1de425b0 ID	191	manager_ops->mode_set(manager->dev,
1de425b0 ID	192	adjusted_mode);
1b85a071 ID	193
	194	exynos_encoder->old_crtc = encoder->crtc;
	195	}
1c248b7d ID	196	}
	197	}
	198
	199	static void exynos_drm_encoder_prepare(struct drm_encoder *encoder)
	200	{
	201	DRM_DEBUG_KMS("%s\n", __FILE__);
	202
	203	/* drm framework doesn't check NULL. */
	204	}
	205
	206	static void exynos_drm_encoder_commit(struct drm_encoder *encoder)
	207	{
	208	struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
	209	struct exynos_drm_manager_ops *manager_ops = manager->ops;
1c248b7d ID	210
	211	DRM_DEBUG_KMS("%s\n", __FILE__);
	212
	213	if (manager_ops && manager_ops->commit)
	214	manager_ops->commit(manager->dev);
1c248b7d ID	215	}
1c248b7d ID	216
bcf4cef9 ID	217	static void exynos_drm_encoder_disable(struct drm_encoder *encoder)
	218	{
	219	struct drm_plane *plane;
	220	struct drm_device *dev = encoder->dev;
	221
	222	exynos_drm_encoder_dpms(encoder, DRM_MODE_DPMS_OFF);
	223
	224	/* all planes connected to this encoder should be also disabled. */
	225	list_for_each_entry(plane, &dev->mode_config.plane_list, head) {
	226	if (plane->crtc == encoder->crtc)
	227	plane->funcs->disable_plane(plane);
	228	}
	229	}
	230
1c248b7d ID	231	static struct drm_encoder_helper_funcs exynos_encoder_helper_funcs = {
	232	.dpms = exynos_drm_encoder_dpms,
	233	.mode_fixup = exynos_drm_encoder_mode_fixup,
	234	.mode_set = exynos_drm_encoder_mode_set,
	235	.prepare = exynos_drm_encoder_prepare,
	236	.commit = exynos_drm_encoder_commit,
bcf4cef9	237	.disable = exynos_drm_encoder_disable,
1c248b7d ID	238	};
	239
	240	static void exynos_drm_encoder_destroy(struct drm_encoder *encoder)
	241	{
	242	struct exynos_drm_encoder *exynos_encoder =
	243	to_exynos_encoder(encoder);
	244
	245	DRM_DEBUG_KMS("%s\n", __FILE__);
	246
	247	exynos_encoder->manager->pipe = -1;
	248
	249	drm_encoder_cleanup(encoder);
1c248b7d ID	250	kfree(exynos_encoder);
	251	}
	252
	253	static struct drm_encoder_funcs exynos_encoder_funcs = {
	254	.destroy = exynos_drm_encoder_destroy,
	255	};
	256
d081f566 ID	257	static unsigned int exynos_drm_encoder_clones(struct drm_encoder *encoder)
	258	{
	259	struct drm_encoder *clone;
	260	struct drm_device *dev = encoder->dev;
	261	struct exynos_drm_encoder *exynos_encoder = to_exynos_encoder(encoder);
	262	struct exynos_drm_display_ops *display_ops =
	263	exynos_encoder->manager->display_ops;
	264	unsigned int clone_mask = 0;
	265	int cnt = 0;
	266
	267	list_for_each_entry(clone, &dev->mode_config.encoder_list, head) {
	268	switch (display_ops->type) {
	269	case EXYNOS_DISPLAY_TYPE_LCD:
	270	case EXYNOS_DISPLAY_TYPE_HDMI:
b73d1230	271	case EXYNOS_DISPLAY_TYPE_VIDI:
d081f566 ID	272	clone_mask \|= (1 << (cnt++));
	273	break;
	274	default:
	275	continue;
	276	}
	277	}
	278
	279	return clone_mask;
	280	}
	281
	282	void exynos_drm_encoder_setup(struct drm_device *dev)
	283	{
	284	struct drm_encoder *encoder;
	285
	286	DRM_DEBUG_KMS("%s\n", __FILE__);
	287
	288	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
	289	encoder->possible_clones = exynos_drm_encoder_clones(encoder);
	290	}
	291
1c248b7d ID	292	struct drm_encoder *
	293	exynos_drm_encoder_create(struct drm_device *dev,
	294	struct exynos_drm_manager *manager,
	295	unsigned int possible_crtcs)
	296	{
	297	struct drm_encoder *encoder;
	298	struct exynos_drm_encoder *exynos_encoder;
	299
	300	DRM_DEBUG_KMS("%s\n", __FILE__);
	301
	302	if (!manager \|\| !possible_crtcs)
	303	return NULL;
	304
	305	if (!manager->dev)
	306	return NULL;
	307
	308	exynos_encoder = kzalloc(sizeof(*exynos_encoder), GFP_KERNEL);
	309	if (!exynos_encoder) {
	310	DRM_ERROR("failed to allocate encoder\n");
	311	return NULL;
	312	}
	313
ec05da95	314	exynos_encoder->dpms = DRM_MODE_DPMS_OFF;
1c248b7d ID	315	exynos_encoder->manager = manager;
	316	encoder = &exynos_encoder->drm_encoder;
	317	encoder->possible_crtcs = possible_crtcs;
	318
	319	DRM_DEBUG_KMS("possible_crtcs = 0x%x\n", encoder->possible_crtcs);
	320
	321	drm_encoder_init(dev, encoder, &exynos_encoder_funcs,
	322	DRM_MODE_ENCODER_TMDS);
	323
	324	drm_encoder_helper_add(encoder, &exynos_encoder_helper_funcs);
	325
	326	DRM_DEBUG_KMS("encoder has been created\n");
	327
	328	return encoder;
	329	}
	330
	331	struct exynos_drm_manager exynos_drm_get_manager(struct drm_encoder encoder)
	332	{
	333	return to_exynos_encoder(encoder)->manager;
	334	}
	335
	336	void exynos_drm_fn_encoder(struct drm_crtc crtc, void data,
	337	void (fn)(struct drm_encoder , void *))
	338	{
	339	struct drm_device *dev = crtc->dev;
	340	struct drm_encoder *encoder;
d2716c89 JS	341	struct exynos_drm_private *private = dev->dev_private;
d2716c89 JS	342	struct exynos_drm_manager *manager;
1c248b7d ID	343
1c248b7d ID	344	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
d2716c89 JS	345	/*
	346	* if crtc is detached from encoder, check pipe,
	347	* otherwise check crtc attached to encoder
	348	*/
	349	if (!encoder->crtc) {
	350	manager = to_exynos_encoder(encoder)->manager;
	351	if (manager->pipe < 0 \|\|
	352	private->crtc[manager->pipe] != crtc)
	353	continue;
	354	} else {
	355	if (encoder->crtc != crtc)
	356	continue;
	357	}
1c248b7d ID	358
	359	fn(encoder, data);
	360	}
	361	}
	362
	363	void exynos_drm_enable_vblank(struct drm_encoder encoder, void data)
	364	{
	365	struct exynos_drm_manager *manager =
	366	to_exynos_encoder(encoder)->manager;
	367	struct exynos_drm_manager_ops *manager_ops = manager->ops;
	368	int crtc = (int )data;
	369
d249ce02 JS	370	if (manager->pipe != crtc)
d249ce02 JS	371	return;
1c248b7d ID	372
	373	if (manager_ops->enable_vblank)
	374	manager_ops->enable_vblank(manager->dev);
	375	}
	376
	377	void exynos_drm_disable_vblank(struct drm_encoder encoder, void data)
	378	{
	379	struct exynos_drm_manager *manager =
	380	to_exynos_encoder(encoder)->manager;
	381	struct exynos_drm_manager_ops *manager_ops = manager->ops;
	382	int crtc = (int )data;
	383
d249ce02 JS	384	if (manager->pipe != crtc)
d249ce02 JS	385	return;
1c248b7d ID	386
	387	if (manager_ops->disable_vblank)
	388	manager_ops->disable_vblank(manager->dev);
	389	}
	390
ec05da95 ID	391	void exynos_drm_encoder_crtc_dpms(struct drm_encoder encoder, void data)
ec05da95 ID	392	{
ec05da95 ID	393	struct exynos_drm_encoder *exynos_encoder = to_exynos_encoder(encoder);
	394	struct exynos_drm_manager *manager = exynos_encoder->manager;
	395	struct exynos_drm_manager_ops *manager_ops = manager->ops;
ec05da95 ID	396	int mode = (int )data;
	397
	398	DRM_DEBUG_KMS("%s\n", __FILE__);
	399
	400	if (manager_ops && manager_ops->dpms)
	401	manager_ops->dpms(manager->dev, mode);
	402
50caf25c ID	403	/*
	404	* set current mode to new one so that data aren't updated into
	405	* registers by drm_helper_connector_dpms two times.
	406	*
	407	* in case that drm_crtc_helper_set_mode() is called,
	408	* overlay_ops->commit() and manager_ops->commit() callbacks
	409	* can be called two times, first at drm_crtc_helper_set_mode()
	410	* and second at drm_helper_connector_dpms().
	411	* so with this setting, when drm_helper_connector_dpms() is called
	412	* encoder->funcs->dpms() will be ignored.
	413	*/
	414	exynos_encoder->dpms = mode;
	415
ec05da95 ID	416	/*
	417	* if this condition is ok then it means that the crtc is already
	418	* detached from encoder and last function for detaching is properly
	419	* done, so clear pipe from manager to prevent repeated call.
	420	*/
	421	if (mode > DRM_MODE_DPMS_ON) {
	422	if (!encoder->crtc)
	423	manager->pipe = -1;
	424	}
	425	}
	426
4070d212 JS	427	void exynos_drm_encoder_crtc_pipe(struct drm_encoder encoder, void data)
	428	{
	429	struct exynos_drm_manager *manager =
	430	to_exynos_encoder(encoder)->manager;
	431	int pipe = (int )data;
	432
	433	DRM_DEBUG_KMS("%s\n", __FILE__);
	434
	435	/*
	436	* when crtc is detached from encoder, this pipe is used
	437	* to select manager operation
	438	*/
	439	manager->pipe = pipe;
	440	}
	441
	442	void exynos_drm_encoder_plane_mode_set(struct drm_encoder encoder, void data)
1c248b7d ID	443	{
	444	struct exynos_drm_manager *manager =
	445	to_exynos_encoder(encoder)->manager;
	446	struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
	447	struct exynos_drm_overlay *overlay = data;
	448
4070d212 JS	449	DRM_DEBUG_KMS("%s\n", __FILE__);
4070d212 JS	450
b0e0f856 SWK	451	if (overlay_ops && overlay_ops->mode_set)
b0e0f856 SWK	452	overlay_ops->mode_set(manager->dev, overlay);
1c248b7d ID	453	}
1c248b7d ID	454
4070d212	455	void exynos_drm_encoder_plane_commit(struct drm_encoder encoder, void data)
d2716c89 JS	456	{
	457	struct exynos_drm_manager *manager =
	458	to_exynos_encoder(encoder)->manager;
	459	struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
864ee9e6	460	int zpos = DEFAULT_ZPOS;
d2716c89	461
4070d212	462	DRM_DEBUG_KMS("%s\n", __FILE__);
d2716c89	463
864ee9e6 JS	464	if (data)
	465	zpos = (int )data;
	466
4070d212 JS	467	if (overlay_ops && overlay_ops->commit)
4070d212 JS	468	overlay_ops->commit(manager->dev, zpos);
d2716c89	469	}
d249ce02	470
cf5188ac JS	471	void exynos_drm_encoder_plane_enable(struct drm_encoder encoder, void data)
	472	{
	473	struct exynos_drm_manager *manager =
	474	to_exynos_encoder(encoder)->manager;
	475	struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
	476	int zpos = DEFAULT_ZPOS;
	477
	478	DRM_DEBUG_KMS("%s\n", __FILE__);
	479
	480	if (data)
	481	zpos = (int )data;
	482
	483	if (overlay_ops && overlay_ops->enable)
	484	overlay_ops->enable(manager->dev, zpos);
	485	}
	486
4070d212	487	void exynos_drm_encoder_plane_disable(struct drm_encoder encoder, void data)
d249ce02 JS	488	{
	489	struct exynos_drm_manager *manager =
	490	to_exynos_encoder(encoder)->manager;
4070d212 JS	491	struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
4070d212 JS	492	int zpos = DEFAULT_ZPOS;
d249ce02 JS	493
	494	DRM_DEBUG_KMS("%s\n", __FILE__);
	495
4070d212 JS	496	if (data)
	497	zpos = (int )data;
	498
	499	if (overlay_ops && overlay_ops->disable)
	500	overlay_ops->disable(manager->dev, zpos);
b011941f ID	501
	502	/*
	503	* wait for vblank interrupt
	504	* - this makes sure that hardware overlay is disabled to avoid
	505	* for the dma accesses to memory after gem buffer was released
	506	* because the setting for disabling the overlay will be updated
	507	* at vsync.
	508	*/
	509	if (overlay_ops->wait_for_vblank)
	510	overlay_ops->wait_for_vblank(manager->dev);
d249ce02	511	}