[linux-2.6-block.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_crtc.h"
#include "exynos_drm_encoder.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.
 */
struct exynos_drm_encoder {
	struct drm_encoder		drm_encoder;
	struct exynos_drm_manager	*manager;
};

static void exynos_drm_encoder_dpms(struct drm_encoder *encoder, int 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, encoder dpms: %d\n", __FILE__, mode);

	switch (mode) {
	case DRM_MODE_DPMS_ON:
		if (manager_ops && manager_ops->commit)
			manager_ops->commit(manager->dev);
		break;
	case DRM_MODE_DPMS_STANDBY:
	case DRM_MODE_DPMS_SUSPEND:
	case DRM_MODE_DPMS_OFF:
		/* TODO */
		if (manager_ops && manager_ops->disable)
			manager_ops->disable(manager->dev);
		break;
	default:
		DRM_ERROR("unspecified mode %d\n", mode);
		break;
	}

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

			DRM_DEBUG_KMS("connector[%d] dpms[%d]\n",
					connector->base.id, mode);
			if (display_ops && display_ops->power_on)
				display_ops->power_on(manager->dev, mode);
		}
	}
}

static bool
exynos_drm_encoder_mode_fixup(struct drm_encoder *encoder,
			       struct drm_display_mode *mode,
			       struct drm_display_mode *adjusted_mode)
{
	DRM_DEBUG_KMS("%s\n", __FILE__);

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

	return true;
}

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 = exynos_drm_get_manager(encoder);
	struct exynos_drm_manager_ops *manager_ops = manager->ops;
	struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
	struct exynos_drm_overlay *overlay = get_exynos_drm_overlay(dev,
						encoder->crtc);

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

	mode = adjusted_mode;

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

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

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 struct drm_crtc *
exynos_drm_encoder_get_crtc(struct drm_encoder *encoder)
{
	return encoder->crtc;
}

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,
	.get_crtc	= exynos_drm_encoder_get_crtc,
};

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);
	encoder->dev->mode_config.num_encoder--;
	kfree(exynos_encoder);
}

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

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->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 == -1)
		manager->pipe = crtc;

	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 == -1)
		manager->pipe = crtc;

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

void exynos_drm_encoder_crtc_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 crtc = *(int *)data;

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

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

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

void exynos_drm_encoder_crtc_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;

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

void exynos_drm_encoder_crtc_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;

	DRM_DEBUG_KMS("\n");

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

	/*
	 * crtc is already detached from encoder and last
	 * function for detaching is properly done, so
	 * clear pipe from manager to prevent repeated call
	 */
	if (!encoder->crtc)
		manager->pipe = -1;
}

MODULE_AUTHOR("Inki Dae <inki.dae@samsung.com>");
MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
MODULE_AUTHOR("Seung-Woo Kim <sw0312.kim@samsung.com>");
MODULE_DESCRIPTION("Samsung SoC DRM Encoder Driver");
MODULE_LICENSE("GPL");
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"
	33	#include "exynos_drm_crtc.h"
	34	#include "exynos_drm_encoder.h"
	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.
	45	*/
	46	struct exynos_drm_encoder {
	47	struct drm_encoder drm_encoder;
	48	struct exynos_drm_manager *manager;
	49	};
	50
	51	static void exynos_drm_encoder_dpms(struct drm_encoder *encoder, int mode)
	52	{
	53	struct drm_device *dev = encoder->dev;
	54	struct drm_connector *connector;
	55	struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
396464df	56	struct exynos_drm_manager_ops *manager_ops = manager->ops;
1c248b7d ID	57
	58	DRM_DEBUG_KMS("%s, encoder dpms: %d\n", __FILE__, mode);
	59
396464df JS	60	switch (mode) {
	61	case DRM_MODE_DPMS_ON:
	62	if (manager_ops && manager_ops->commit)
	63	manager_ops->commit(manager->dev);
	64	break;
	65	case DRM_MODE_DPMS_STANDBY:
	66	case DRM_MODE_DPMS_SUSPEND:
	67	case DRM_MODE_DPMS_OFF:
	68	/* TODO */
	69	if (manager_ops && manager_ops->disable)
	70	manager_ops->disable(manager->dev);
	71	break;
	72	default:
	73	DRM_ERROR("unspecified mode %d\n", mode);
	74	break;
	75	}
	76
1c248b7d ID	77	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
1c248b7d ID	78	if (connector->encoder == encoder) {
74ccc539 ID	79	struct exynos_drm_display_ops *display_ops =
74ccc539 ID	80	manager->display_ops;
1c248b7d	81
d2716c89 JS	82	DRM_DEBUG_KMS("connector[%d] dpms[%d]\n",
d2716c89 JS	83	connector->base.id, mode);
74ccc539 ID	84	if (display_ops && display_ops->power_on)
74ccc539 ID	85	display_ops->power_on(manager->dev, mode);
1c248b7d ID	86	}
	87	}
	88	}
	89
	90	static bool
	91	exynos_drm_encoder_mode_fixup(struct drm_encoder *encoder,
	92	struct drm_display_mode *mode,
	93	struct drm_display_mode *adjusted_mode)
	94	{
	95	DRM_DEBUG_KMS("%s\n", __FILE__);
	96
	97	/* drm framework doesn't check NULL. */
	98
	99	return true;
	100	}
	101
	102	static void exynos_drm_encoder_mode_set(struct drm_encoder *encoder,
	103	struct drm_display_mode *mode,
	104	struct drm_display_mode *adjusted_mode)
	105	{
	106	struct drm_device *dev = encoder->dev;
	107	struct drm_connector *connector;
	108	struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
	109	struct exynos_drm_manager_ops *manager_ops = manager->ops;
	110	struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
	111	struct exynos_drm_overlay *overlay = get_exynos_drm_overlay(dev,
	112	encoder->crtc);
	113
	114	DRM_DEBUG_KMS("%s\n", __FILE__);
	115
	116	mode = adjusted_mode;
	117
	118	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
	119	if (connector->encoder == encoder) {
	120	if (manager_ops && manager_ops->mode_set)
	121	manager_ops->mode_set(manager->dev, mode);
	122
	123	if (overlay_ops && overlay_ops->mode_set)
	124	overlay_ops->mode_set(manager->dev, overlay);
	125	}
	126	}
	127	}
	128
	129	static void exynos_drm_encoder_prepare(struct drm_encoder *encoder)
	130	{
	131	DRM_DEBUG_KMS("%s\n", __FILE__);
	132
	133	/* drm framework doesn't check NULL. */
	134	}
	135
	136	static void exynos_drm_encoder_commit(struct drm_encoder *encoder)
	137	{
	138	struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
	139	struct exynos_drm_manager_ops *manager_ops = manager->ops;
1c248b7d ID	140
	141	DRM_DEBUG_KMS("%s\n", __FILE__);
	142
	143	if (manager_ops && manager_ops->commit)
	144	manager_ops->commit(manager->dev);
1c248b7d ID	145	}
	146
	147	static struct drm_crtc *
	148	exynos_drm_encoder_get_crtc(struct drm_encoder *encoder)
	149	{
	150	return encoder->crtc;
	151	}
	152
	153	static struct drm_encoder_helper_funcs exynos_encoder_helper_funcs = {
	154	.dpms = exynos_drm_encoder_dpms,
	155	.mode_fixup = exynos_drm_encoder_mode_fixup,
	156	.mode_set = exynos_drm_encoder_mode_set,
	157	.prepare = exynos_drm_encoder_prepare,
	158	.commit = exynos_drm_encoder_commit,
	159	.get_crtc = exynos_drm_encoder_get_crtc,
	160	};
	161
	162	static void exynos_drm_encoder_destroy(struct drm_encoder *encoder)
	163	{
	164	struct exynos_drm_encoder *exynos_encoder =
	165	to_exynos_encoder(encoder);
	166
	167	DRM_DEBUG_KMS("%s\n", __FILE__);
	168
	169	exynos_encoder->manager->pipe = -1;
	170
	171	drm_encoder_cleanup(encoder);
	172	encoder->dev->mode_config.num_encoder--;
	173	kfree(exynos_encoder);
	174	}
	175
	176	static struct drm_encoder_funcs exynos_encoder_funcs = {
	177	.destroy = exynos_drm_encoder_destroy,
	178	};
	179
	180	struct drm_encoder *
	181	exynos_drm_encoder_create(struct drm_device *dev,
	182	struct exynos_drm_manager *manager,
	183	unsigned int possible_crtcs)
	184	{
	185	struct drm_encoder *encoder;
	186	struct exynos_drm_encoder *exynos_encoder;
	187
	188	DRM_DEBUG_KMS("%s\n", __FILE__);
	189
	190	if (!manager \|\| !possible_crtcs)
	191	return NULL;
	192
	193	if (!manager->dev)
	194	return NULL;
	195
	196	exynos_encoder = kzalloc(sizeof(*exynos_encoder), GFP_KERNEL);
	197	if (!exynos_encoder) {
	198	DRM_ERROR("failed to allocate encoder\n");
	199	return NULL;
	200	}
	201
	202	exynos_encoder->manager = manager;
	203	encoder = &exynos_encoder->drm_encoder;
	204	encoder->possible_crtcs = possible_crtcs;
	205
	206	DRM_DEBUG_KMS("possible_crtcs = 0x%x\n", encoder->possible_crtcs);
	207
	208	drm_encoder_init(dev, encoder, &exynos_encoder_funcs,
209	DRM_MODE_ENCODER_TMDS);
210
211	drm_encoder_helper_add(encoder, &exynos_encoder_helper_funcs);
212
213	DRM_DEBUG_KMS("encoder has been created\n");
214
215	return encoder;
216	}
217
218	struct exynos_drm_manager exynos_drm_get_manager(struct drm_encoder encoder)
219	{
220	return to_exynos_encoder(encoder)->manager;
221	}
222
223	void exynos_drm_fn_encoder(struct drm_crtc crtc, void data,
224	void (fn)(struct drm_encoder , void *))
225	{
226	struct drm_device *dev = crtc->dev;
227	struct drm_encoder *encoder;
d2716c89 JS	228	struct exynos_drm_private *private = dev->dev_private;
d2716c89 JS	229	struct exynos_drm_manager *manager;
1c248b7d ID	230
1c248b7d ID	231	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
d2716c89 JS	232	/*
	233	* if crtc is detached from encoder, check pipe,
	234	* otherwise check crtc attached to encoder
	235	*/
	236	if (!encoder->crtc) {
	237	manager = to_exynos_encoder(encoder)->manager;
	238	if (manager->pipe < 0 \|\|
	239	private->crtc[manager->pipe] != crtc)
	240	continue;
	241	} else {
	242	if (encoder->crtc != crtc)
	243	continue;
	244	}
1c248b7d ID	245
	246	fn(encoder, data);
	247	}
	248	}
	249
	250	void exynos_drm_enable_vblank(struct drm_encoder encoder, void data)
	251	{
	252	struct exynos_drm_manager *manager =
	253	to_exynos_encoder(encoder)->manager;
	254	struct exynos_drm_manager_ops *manager_ops = manager->ops;
	255	int crtc = (int )data;
	256
	257	if (manager->pipe == -1)
	258	manager->pipe = crtc;
	259
	260	if (manager_ops->enable_vblank)
	261	manager_ops->enable_vblank(manager->dev);
	262	}
	263
	264	void exynos_drm_disable_vblank(struct drm_encoder encoder, void data)
	265	{
	266	struct exynos_drm_manager *manager =
	267	to_exynos_encoder(encoder)->manager;
	268	struct exynos_drm_manager_ops *manager_ops = manager->ops;
	269	int crtc = (int )data;
	270
	271	if (manager->pipe == -1)
	272	manager->pipe = crtc;
	273
	274	if (manager_ops->disable_vblank)
	275	manager_ops->disable_vblank(manager->dev);
	276	}
	277
	278	void exynos_drm_encoder_crtc_commit(struct drm_encoder encoder, void data)
	279	{
	280	struct exynos_drm_manager *manager =
	281	to_exynos_encoder(encoder)->manager;
	282	struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
d2716c89 JS	283	int crtc = (int )data;
	284
	285	DRM_DEBUG_KMS("%s\n", __FILE__);
1c248b7d	286
d2716c89 JS	287	/*
	288	* when crtc is detached from encoder, this pipe is used
	289	* to select manager operation
	290	*/
	291	manager->pipe = crtc;
	292
	293	if (overlay_ops && overlay_ops->commit)
	294	overlay_ops->commit(manager->dev);
1c248b7d ID	295	}
	296
	297	void exynos_drm_encoder_crtc_mode_set(struct drm_encoder encoder, void data)
	298	{
	299	struct exynos_drm_manager *manager =
	300	to_exynos_encoder(encoder)->manager;
	301	struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
	302	struct exynos_drm_overlay *overlay = data;
	303
b0e0f856 SWK	304	if (overlay_ops && overlay_ops->mode_set)
b0e0f856 SWK	305	overlay_ops->mode_set(manager->dev, overlay);
1c248b7d ID	306	}
1c248b7d ID	307
d2716c89 JS	308	void exynos_drm_encoder_crtc_disable(struct drm_encoder encoder, void data)
	309	{
	310	struct exynos_drm_manager *manager =
	311	to_exynos_encoder(encoder)->manager;
	312	struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
	313
	314	DRM_DEBUG_KMS("\n");
	315
b0e0f856 SWK	316	if (overlay_ops && overlay_ops->disable)
b0e0f856 SWK	317	overlay_ops->disable(manager->dev);
d2716c89 JS	318
	319	/*
	320	* crtc is already detached from encoder and last
	321	* function for detaching is properly done, so
	322	* clear pipe from manager to prevent repeated call
	323	*/
	324	if (!encoder->crtc)
	325	manager->pipe = -1;
	326	}
	327
1c248b7d ID	328	MODULE_AUTHOR("Inki Dae <inki.dae@samsung.com>");
	329	MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
	330	MODULE_AUTHOR("Seung-Woo Kim <sw0312.kim@samsung.com>");
	331	MODULE_DESCRIPTION("Samsung SoC DRM Encoder Driver");
	332	MODULE_LICENSE("GPL");