[deliverable/linux.git] / drivers / gpu / drm / exynos / exynos_drm_connector.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"

#define MAX_EDID 256
#define to_exynos_connector(x)	container_of(x, struct exynos_drm_connector,\
				drm_connector)

struct exynos_drm_connector {
	struct drm_connector	drm_connector;
	uint32_t		encoder_id;
	struct exynos_drm_manager *manager;
};

/* convert exynos_video_timings to drm_display_mode */
static inline void
convert_to_display_mode(struct drm_display_mode *mode,
			struct fb_videomode *timing)
{
	DRM_DEBUG_KMS("%s\n", __FILE__);

	mode->clock = timing->pixclock / 1000;
	mode->vrefresh = timing->refresh;

	mode->hdisplay = timing->xres;
	mode->hsync_start = mode->hdisplay + timing->left_margin;
	mode->hsync_end = mode->hsync_start + timing->hsync_len;
	mode->htotal = mode->hsync_end + timing->right_margin;

	mode->vdisplay = timing->yres;
	mode->vsync_start = mode->vdisplay + timing->upper_margin;
	mode->vsync_end = mode->vsync_start + timing->vsync_len;
	mode->vtotal = mode->vsync_end + timing->lower_margin;

	if (timing->vmode & FB_VMODE_INTERLACED)
		mode->flags |= DRM_MODE_FLAG_INTERLACE;

	if (timing->vmode & FB_VMODE_DOUBLE)
		mode->flags |= DRM_MODE_FLAG_DBLSCAN;
}

/* convert drm_display_mode to exynos_video_timings */
static inline void
convert_to_video_timing(struct fb_videomode *timing,
			struct drm_display_mode *mode)
{
	DRM_DEBUG_KMS("%s\n", __FILE__);

	memset(timing, 0, sizeof(*timing));

	timing->pixclock = mode->clock * 1000;
	timing->refresh = drm_mode_vrefresh(mode);

	timing->xres = mode->hdisplay;
	timing->left_margin = mode->hsync_start - mode->hdisplay;
	timing->hsync_len = mode->hsync_end - mode->hsync_start;
	timing->right_margin = mode->htotal - mode->hsync_end;

	timing->yres = mode->vdisplay;
	timing->upper_margin = mode->vsync_start - mode->vdisplay;
	timing->vsync_len = mode->vsync_end - mode->vsync_start;
	timing->lower_margin = mode->vtotal - mode->vsync_end;

	if (mode->flags & DRM_MODE_FLAG_INTERLACE)
		timing->vmode = FB_VMODE_INTERLACED;
	else
		timing->vmode = FB_VMODE_NONINTERLACED;

	if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
		timing->vmode |= FB_VMODE_DOUBLE;
}

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;
	unsigned int count;

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

	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
	 * get timing from the FIMD driver(display controller).
	 *
	 * 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) {
		int ret;
		void *edid;

		edid = kzalloc(MAX_EDID, GFP_KERNEL);
		if (!edid) {
			DRM_ERROR("failed to allocate edid\n");
			return 0;
		}

		ret = display_ops->get_edid(manager->dev, connector,
						edid, MAX_EDID);
		if (ret < 0) {
			DRM_ERROR("failed to get edid data.\n");
			kfree(edid);
			edid = NULL;
			return 0;
		}

		drm_mode_connector_update_edid_property(connector, edid);
		count = drm_add_edid_modes(connector, edid);

		kfree(connector->display_info.raw_edid);
		connector->display_info.raw_edid = edid;
	} else {
		struct drm_display_mode *mode = drm_mode_create(connector->dev);
		struct fb_videomode *timing;

		if (display_ops->get_timing)
			timing = display_ops->get_timing(manager->dev);
		else {
			drm_mode_destroy(connector->dev, mode);
			return 0;
		}

		convert_to_display_mode(mode, timing);

		mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
		drm_mode_set_name(mode);
		drm_mode_probed_add(connector, mode);

		count = 1;
	}

	return count;
}

static int exynos_drm_connector_mode_valid(struct drm_connector *connector,
					    struct drm_display_mode *mode)
{
	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 fb_videomode timing;
	int ret = MODE_BAD;

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

	convert_to_video_timing(&timing, mode);

	if (display_ops && display_ops->check_timing)
		if (!display_ops->check_timing(manager->dev, (void *)&timing))
			ret = MODE_OK;

	return ret;
}

struct drm_encoder *exynos_drm_best_encoder(struct drm_connector *connector)
{
	struct drm_device *dev = connector->dev;
	struct exynos_drm_connector *exynos_connector =
					to_exynos_connector(connector);
	struct drm_mode_object *obj;
	struct drm_encoder *encoder;

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

	obj = drm_mode_object_find(dev, exynos_connector->encoder_id,
				   DRM_MODE_OBJECT_ENCODER);
	if (!obj) {
		DRM_DEBUG_KMS("Unknown ENCODER ID %d\n",
				exynos_connector->encoder_id);
		return NULL;
	}

	encoder = obj_to_encoder(obj);

	return encoder;
}

static struct drm_connector_helper_funcs exynos_connector_helper_funcs = {
	.get_modes	= exynos_drm_connector_get_modes,
	.mode_valid	= exynos_drm_connector_mode_valid,
	.best_encoder	= exynos_drm_best_encoder,
};

/* get detection status of display device. */
static enum drm_connector_status
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;
	enum drm_connector_status status = connector_status_disconnected;

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

	if (display_ops && display_ops->is_connected) {
		if (display_ops->is_connected(manager->dev))
			status = connector_status_connected;
		else
			status = connector_status_disconnected;
	}

	return status;
}

static void exynos_drm_connector_destroy(struct drm_connector *connector)
{
	struct exynos_drm_connector *exynos_connector =
		to_exynos_connector(connector);

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

	drm_sysfs_connector_remove(connector);
	drm_connector_cleanup(connector);
	kfree(exynos_connector);
}

static struct drm_connector_funcs exynos_connector_funcs = {
	.dpms		= drm_helper_connector_dpms,
	.fill_modes	= drm_helper_probe_single_connector_modes,
	.detect		= exynos_drm_connector_detect,
	.destroy	= exynos_drm_connector_destroy,
};

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 drm_connector *connector;
	int type;
	int err;

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

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

	connector = &exynos_connector->drm_connector;

	switch (manager->display_ops->type) {
	case EXYNOS_DISPLAY_TYPE_HDMI:
		type = DRM_MODE_CONNECTOR_HDMIA;
		connector->interlace_allowed = true;
		connector->polled = DRM_CONNECTOR_POLL_HPD;
		break;
	default:
		type = DRM_MODE_CONNECTOR_Unknown;
		break;
	}

	drm_connector_init(dev, connector, &exynos_connector_funcs, type);
	drm_connector_helper_add(connector, &exynos_connector_helper_funcs);

	err = drm_sysfs_connector_add(connector);
	if (err)
		goto err_connector;

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

	err = drm_mode_connector_attach_encoder(connector, encoder);
	if (err) {
		DRM_ERROR("failed to attach a connector to a encoder\n");
		goto err_sysfs;
	}

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

	return connector;

err_sysfs:
	drm_sysfs_connector_remove(connector);
err_connector:
	drm_connector_cleanup(connector);
	kfree(exynos_connector);
	return NULL;
}

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 Connector Driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
1c248b7d ID	1	/*
	2	* Copyright (c) 2011 Samsung Electronics Co., Ltd.
	3	* Authors:
	4	* Inki Dae <inki.dae@samsung.com>
	5	* Joonyoung Shim <jy0922.shim@samsung.com>
	6	* Seung-Woo Kim <sw0312.kim@samsung.com>
	7	*
	8	* Permission is hereby granted, free of charge, to any person obtaining a
	9	* copy of this software and associated documentation files (the "Software"),
	10	* to deal in the Software without restriction, including without limitation
	11	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	12	* and/or sell copies of the Software, and to permit persons to whom the
	13	* Software is furnished to do so, subject to the following conditions:
	14	*
	15	* The above copyright notice and this permission notice (including the next
	16	* paragraph) shall be included in all copies or substantial portions of the
	17	* Software.
	18	*
	19	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	20	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	21	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	22	* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
	23	* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
	24	* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
	25	* OTHER DEALINGS IN THE SOFTWARE.
	26	*/
	27
	28	#include "drmP.h"
	29	#include "drm_crtc_helper.h"
	30
	31	#include "exynos_drm_drv.h"
	32	#include "exynos_drm_encoder.h"
	33
	34	#define MAX_EDID 256
	35	#define to_exynos_connector(x) container_of(x, struct exynos_drm_connector,\
	36	drm_connector)
	37
	38	struct exynos_drm_connector {
	39	struct drm_connector drm_connector;
adb6b159 ID	40	uint32_t encoder_id;
adb6b159 ID	41	struct exynos_drm_manager *manager;
1c248b7d ID	42	};
	43
	44	/* convert exynos_video_timings to drm_display_mode */
	45	static inline void
	46	convert_to_display_mode(struct drm_display_mode *mode,
	47	struct fb_videomode *timing)
	48	{
	49	DRM_DEBUG_KMS("%s\n", __FILE__);
	50
	51	mode->clock = timing->pixclock / 1000;
8b58dfe0	52	mode->vrefresh = timing->refresh;
1c248b7d ID	53
	54	mode->hdisplay = timing->xres;
	55	mode->hsync_start = mode->hdisplay + timing->left_margin;
	56	mode->hsync_end = mode->hsync_start + timing->hsync_len;
	57	mode->htotal = mode->hsync_end + timing->right_margin;
	58
	59	mode->vdisplay = timing->yres;
	60	mode->vsync_start = mode->vdisplay + timing->upper_margin;
	61	mode->vsync_end = mode->vsync_start + timing->vsync_len;
	62	mode->vtotal = mode->vsync_end + timing->lower_margin;
8b58dfe0 SWK	63
	64	if (timing->vmode & FB_VMODE_INTERLACED)
	65	mode->flags \|= DRM_MODE_FLAG_INTERLACE;
	66
	67	if (timing->vmode & FB_VMODE_DOUBLE)
	68	mode->flags \|= DRM_MODE_FLAG_DBLSCAN;
1c248b7d ID	69	}
	70
	71	/* convert drm_display_mode to exynos_video_timings */
	72	static inline void
	73	convert_to_video_timing(struct fb_videomode *timing,
	74	struct drm_display_mode *mode)
	75	{
	76	DRM_DEBUG_KMS("%s\n", __FILE__);
	77
	78	memset(timing, 0, sizeof(*timing));
	79
	80	timing->pixclock = mode->clock * 1000;
8b58dfe0	81	timing->refresh = drm_mode_vrefresh(mode);
1c248b7d ID	82
	83	timing->xres = mode->hdisplay;
	84	timing->left_margin = mode->hsync_start - mode->hdisplay;
	85	timing->hsync_len = mode->hsync_end - mode->hsync_start;
	86	timing->right_margin = mode->htotal - mode->hsync_end;
	87
	88	timing->yres = mode->vdisplay;
	89	timing->upper_margin = mode->vsync_start - mode->vdisplay;
	90	timing->vsync_len = mode->vsync_end - mode->vsync_start;
	91	timing->lower_margin = mode->vtotal - mode->vsync_end;
	92
	93	if (mode->flags & DRM_MODE_FLAG_INTERLACE)
	94	timing->vmode = FB_VMODE_INTERLACED;
	95	else
	96	timing->vmode = FB_VMODE_NONINTERLACED;
	97
	98	if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
	99	timing->vmode \|= FB_VMODE_DOUBLE;
	100	}
	101
	102	static int exynos_drm_connector_get_modes(struct drm_connector *connector)
	103	{
adb6b159 ID	104	struct exynos_drm_connector *exynos_connector =
	105	to_exynos_connector(connector);
	106	struct exynos_drm_manager *manager = exynos_connector->manager;
74ccc539	107	struct exynos_drm_display_ops *display_ops = manager->display_ops;
1c248b7d ID	108	unsigned int count;
	109
	110	DRM_DEBUG_KMS("%s\n", __FILE__);
	111
74ccc539 ID	112	if (!display_ops) {
74ccc539 ID	113	DRM_DEBUG_KMS("display_ops is null.\n");
1c248b7d ID	114	return 0;
	115	}
	116
	117	/*
	118	* if get_edid() exists then get_edid() callback of hdmi side
	119	* is called to get edid data through i2c interface else
	120	* get timing from the FIMD driver(display controller).
	121	*
	122	* P.S. in case of lcd panel, count is always 1 if success
	123	* because lcd panel has only one mode.
	124	*/
74ccc539	125	if (display_ops->get_edid) {
1c248b7d ID	126	int ret;
	127	void *edid;
	128
	129	edid = kzalloc(MAX_EDID, GFP_KERNEL);
	130	if (!edid) {
	131	DRM_ERROR("failed to allocate edid\n");
	132	return 0;
	133	}
	134
74ccc539	135	ret = display_ops->get_edid(manager->dev, connector,
1c248b7d ID	136	edid, MAX_EDID);
	137	if (ret < 0) {
	138	DRM_ERROR("failed to get edid data.\n");
	139	kfree(edid);
	140	edid = NULL;
	141	return 0;
	142	}
	143
	144	drm_mode_connector_update_edid_property(connector, edid);
	145	count = drm_add_edid_modes(connector, edid);
	146
	147	kfree(connector->display_info.raw_edid);
	148	connector->display_info.raw_edid = edid;
	149	} else {
	150	struct drm_display_mode *mode = drm_mode_create(connector->dev);
	151	struct fb_videomode *timing;
	152
74ccc539 ID	153	if (display_ops->get_timing)
74ccc539 ID	154	timing = display_ops->get_timing(manager->dev);
1c248b7d ID	155	else {
	156	drm_mode_destroy(connector->dev, mode);
	157	return 0;
	158	}
	159
	160	convert_to_display_mode(mode, timing);
	161
	162	mode->type = DRM_MODE_TYPE_DRIVER \| DRM_MODE_TYPE_PREFERRED;
	163	drm_mode_set_name(mode);
	164	drm_mode_probed_add(connector, mode);
	165
	166	count = 1;
	167	}
	168
	169	return count;
	170	}
	171
	172	static int exynos_drm_connector_mode_valid(struct drm_connector *connector,
	173	struct drm_display_mode *mode)
	174	{
adb6b159 ID	175	struct exynos_drm_connector *exynos_connector =
	176	to_exynos_connector(connector);
	177	struct exynos_drm_manager *manager = exynos_connector->manager;
74ccc539	178	struct exynos_drm_display_ops *display_ops = manager->display_ops;
1c248b7d ID	179	struct fb_videomode timing;
	180	int ret = MODE_BAD;
	181
	182	DRM_DEBUG_KMS("%s\n", __FILE__);
	183
	184	convert_to_video_timing(&timing, mode);
	185
74ccc539 ID	186	if (display_ops && display_ops->check_timing)
74ccc539 ID	187	if (!display_ops->check_timing(manager->dev, (void *)&timing))
1c248b7d ID	188	ret = MODE_OK;
	189
	190	return ret;
	191	}
	192
	193	struct drm_encoder exynos_drm_best_encoder(struct drm_connector connector)
	194	{
adb6b159 ID	195	struct drm_device *dev = connector->dev;
	196	struct exynos_drm_connector *exynos_connector =
	197	to_exynos_connector(connector);
	198	struct drm_mode_object *obj;
	199	struct drm_encoder *encoder;
	200
1c248b7d ID	201	DRM_DEBUG_KMS("%s\n", __FILE__);
1c248b7d ID	202
adb6b159 ID	203	obj = drm_mode_object_find(dev, exynos_connector->encoder_id,
	204	DRM_MODE_OBJECT_ENCODER);
	205	if (!obj) {
	206	DRM_DEBUG_KMS("Unknown ENCODER ID %d\n",
	207	exynos_connector->encoder_id);
	208	return NULL;
	209	}
	210
	211	encoder = obj_to_encoder(obj);
	212
	213	return encoder;
1c248b7d ID	214	}
	215
	216	static struct drm_connector_helper_funcs exynos_connector_helper_funcs = {
	217	.get_modes = exynos_drm_connector_get_modes,
	218	.mode_valid = exynos_drm_connector_mode_valid,
	219	.best_encoder = exynos_drm_best_encoder,
	220	};
	221
	222	/* get detection status of display device. */
	223	static enum drm_connector_status
	224	exynos_drm_connector_detect(struct drm_connector *connector, bool force)
	225	{
adb6b159 ID	226	struct exynos_drm_connector *exynos_connector =
	227	to_exynos_connector(connector);
	228	struct exynos_drm_manager *manager = exynos_connector->manager;
74ccc539 ID	229	struct exynos_drm_display_ops *display_ops =
74ccc539 ID	230	manager->display_ops;
1c248b7d ID	231	enum drm_connector_status status = connector_status_disconnected;
	232
	233	DRM_DEBUG_KMS("%s\n", __FILE__);
	234
74ccc539 ID	235	if (display_ops && display_ops->is_connected) {
74ccc539 ID	236	if (display_ops->is_connected(manager->dev))
1c248b7d ID	237	status = connector_status_connected;
	238	else
	239	status = connector_status_disconnected;
	240	}
	241
	242	return status;
	243	}
	244
	245	static void exynos_drm_connector_destroy(struct drm_connector *connector)
	246	{
	247	struct exynos_drm_connector *exynos_connector =
	248	to_exynos_connector(connector);
	249
	250	DRM_DEBUG_KMS("%s\n", __FILE__);
	251
	252	drm_sysfs_connector_remove(connector);
	253	drm_connector_cleanup(connector);
	254	kfree(exynos_connector);
	255	}
	256
	257	static struct drm_connector_funcs exynos_connector_funcs = {
	258	.dpms = drm_helper_connector_dpms,
	259	.fill_modes = drm_helper_probe_single_connector_modes,
	260	.detect = exynos_drm_connector_detect,
	261	.destroy = exynos_drm_connector_destroy,
	262	};
	263
	264	struct drm_connector exynos_drm_connector_create(struct drm_device dev,
	265	struct drm_encoder *encoder)
	266	{
	267	struct exynos_drm_connector *exynos_connector;
	268	struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
	269	struct drm_connector *connector;
	270	int type;
	271	int err;
	272
	273	DRM_DEBUG_KMS("%s\n", __FILE__);
	274
	275	exynos_connector = kzalloc(sizeof(*exynos_connector), GFP_KERNEL);
	276	if (!exynos_connector) {
	277	DRM_ERROR("failed to allocate connector\n");
	278	return NULL;
	279	}
	280
	281	connector = &exynos_connector->drm_connector;
	282
74ccc539	283	switch (manager->display_ops->type) {
1c248b7d ID	284	case EXYNOS_DISPLAY_TYPE_HDMI:
1c248b7d ID	285	type = DRM_MODE_CONNECTOR_HDMIA;
1b17b206 SWK	286	connector->interlace_allowed = true;
1b17b206 SWK	287	connector->polled = DRM_CONNECTOR_POLL_HPD;
1c248b7d ID	288	break;
	289	default:
	290	type = DRM_MODE_CONNECTOR_Unknown;
	291	break;
	292	}
	293
	294	drm_connector_init(dev, connector, &exynos_connector_funcs, type);
	295	drm_connector_helper_add(connector, &exynos_connector_helper_funcs);
	296
	297	err = drm_sysfs_connector_add(connector);
	298	if (err)
	299	goto err_connector;
	300
adb6b159 ID	301	exynos_connector->encoder_id = encoder->base.id;
adb6b159 ID	302	exynos_connector->manager = manager;
1c248b7d	303	connector->encoder = encoder;
adb6b159	304
1c248b7d ID	305	err = drm_mode_connector_attach_encoder(connector, encoder);
	306	if (err) {
	307	DRM_ERROR("failed to attach a connector to a encoder\n");
	308	goto err_sysfs;
	309	}
	310
	311	DRM_DEBUG_KMS("connector has been created\n");
	312
	313	return connector;
	314
	315	err_sysfs:
	316	drm_sysfs_connector_remove(connector);
	317	err_connector:
	318	drm_connector_cleanup(connector);
	319	kfree(exynos_connector);
	320	return NULL;
	321	}
	322
	323	MODULE_AUTHOR("Inki Dae <inki.dae@samsung.com>");
	324	MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
	325	MODULE_AUTHOR("Seung-Woo Kim <sw0312.kim@samsung.com>");
	326	MODULE_DESCRIPTION("Samsung SoC DRM Connector Driver");
	327	MODULE_LICENSE("GPL");