exynos_drm_connector.c 10.5 KB
Newer Older
1 2 3 4 5 6 7
/*
 * 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>
 *
8 9 10 11
 * This program is free software; you can redistribute  it and/or modify it
 * under  the terms of  the GNU General  Public License as published by the
 * Free Software Foundation;  either version 2 of the  License, or (at your
 * option) any later version.
12 13
 */

14 15
#include <drm/drmP.h>
#include <drm/drm_crtc_helper.h>
16

17
#include <drm/exynos_drm.h>
18 19 20 21 22 23 24 25 26
#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;
27 28
	uint32_t		encoder_id;
	struct exynos_drm_manager *manager;
29
	uint32_t		dpms;
30 31 32 33 34
};

/* convert exynos_video_timings to drm_display_mode */
static inline void
convert_to_display_mode(struct drm_display_mode *mode,
35
			struct exynos_drm_panel_info *panel)
36
{
37
	struct fb_videomode *timing = &panel->timing;
38 39 40
	DRM_DEBUG_KMS("%s\n", __FILE__);

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

	mode->hdisplay = timing->xres;
44
	mode->hsync_start = mode->hdisplay + timing->right_margin;
45
	mode->hsync_end = mode->hsync_start + timing->hsync_len;
46
	mode->htotal = mode->hsync_end + timing->left_margin;
47 48

	mode->vdisplay = timing->yres;
49
	mode->vsync_start = mode->vdisplay + timing->lower_margin;
50
	mode->vsync_end = mode->vsync_start + timing->vsync_len;
51
	mode->vtotal = mode->vsync_end + timing->upper_margin;
52 53
	mode->width_mm = panel->width_mm;
	mode->height_mm = panel->height_mm;
54 55 56 57 58 59

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

	if (timing->vmode & FB_VMODE_DOUBLE)
		mode->flags |= DRM_MODE_FLAG_DBLSCAN;
60 61 62 63 64 65 66 67 68 69 70 71
}

/* 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;
72
	timing->refresh = drm_mode_vrefresh(mode);
73 74

	timing->xres = mode->hdisplay;
75
	timing->right_margin = mode->hsync_start - mode->hdisplay;
76
	timing->hsync_len = mode->hsync_end - mode->hsync_start;
77
	timing->left_margin = mode->htotal - mode->hsync_end;
78 79

	timing->yres = mode->vdisplay;
80
	timing->lower_margin = mode->vsync_start - mode->vdisplay;
81
	timing->vsync_len = mode->vsync_end - mode->vsync_start;
82
	timing->upper_margin = mode->vtotal - mode->vsync_end;
83 84 85 86 87 88 89 90 91 92 93 94

	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)
{
95 96 97
	struct exynos_drm_connector *exynos_connector =
					to_exynos_connector(connector);
	struct exynos_drm_manager *manager = exynos_connector->manager;
98
	struct exynos_drm_display_ops *display_ops = manager->display_ops;
99 100 101 102
	unsigned int count;

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

103 104
	if (!display_ops) {
		DRM_DEBUG_KMS("display_ops is null.\n");
105 106 107 108 109 110 111 112 113 114 115
		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.
	 */
116
	if (display_ops->get_edid) {
117 118 119 120 121 122 123 124 125
		int ret;
		void *edid;

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

126
		ret = display_ops->get_edid(manager->dev, connector,
127 128 129 130 131 132 133 134 135 136
						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);
137
		kfree(edid);
138
	} else {
139
		struct exynos_drm_panel_info *panel;
140 141 142 143 144
		struct drm_display_mode *mode = drm_mode_create(connector->dev);
		if (!mode) {
			DRM_ERROR("failed to create a new display mode.\n");
			return 0;
		}
145

146 147
		if (display_ops->get_panel)
			panel = display_ops->get_panel(manager->dev);
148 149 150 151 152
		else {
			drm_mode_destroy(connector->dev, mode);
			return 0;
		}

153 154 155
		convert_to_display_mode(mode, panel);
		connector->display_info.width_mm = mode->width_mm;
		connector->display_info.height_mm = mode->height_mm;
156 157 158 159 160 161 162 163 164 165 166 167 168 169

		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)
{
170 171 172
	struct exynos_drm_connector *exynos_connector =
					to_exynos_connector(connector);
	struct exynos_drm_manager *manager = exynos_connector->manager;
173
	struct exynos_drm_display_ops *display_ops = manager->display_ops;
174 175 176 177 178 179 180
	struct fb_videomode timing;
	int ret = MODE_BAD;

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

	convert_to_video_timing(&timing, mode);

181 182
	if (display_ops && display_ops->check_timing)
		if (!display_ops->check_timing(manager->dev, (void *)&timing))
183 184 185 186 187
			ret = MODE_OK;

	return ret;
}

188
struct drm_encoder *exynos_drm_best_encoder(struct drm_connector *connector)
189
{
190 191 192 193 194 195
	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;

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

198 199 200 201 202 203 204 205 206 207 208
	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;
209 210 211 212 213 214 215 216
}

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,
};

217 218
void exynos_drm_display_power(struct drm_connector *connector, int mode)
{
219
	struct drm_encoder *encoder = exynos_drm_best_encoder(connector);
220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253
	struct exynos_drm_connector *exynos_connector;
	struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
	struct exynos_drm_display_ops *display_ops = manager->display_ops;

	exynos_connector = to_exynos_connector(connector);

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

	if (display_ops && display_ops->power_on)
		display_ops->power_on(manager->dev, mode);

	exynos_connector->dpms = mode;
}

static void exynos_drm_connector_dpms(struct drm_connector *connector,
					int mode)
{
	DRM_DEBUG_KMS("%s\n", __FILE__);

	/*
	 * in case that drm_crtc_helper_set_mode() is called,
	 * encoder/crtc->funcs->dpms() will be just returned
	 * because they already were DRM_MODE_DPMS_ON so only
	 * exynos_drm_display_power() will be called.
	 */
	drm_helper_connector_dpms(connector, mode);

	exynos_drm_display_power(connector, mode);

}

254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276
static int exynos_drm_connector_fill_modes(struct drm_connector *connector,
				unsigned int max_width, unsigned int max_height)
{
	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;
	unsigned int width, height;

	width = max_width;
	height = max_height;

	/*
	 * 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->dev, &width, &height);

	return drm_helper_probe_single_connector_modes(connector, width,
							height);
}

277 278 279 280
/* get detection status of display device. */
static enum drm_connector_status
exynos_drm_connector_detect(struct drm_connector *connector, bool force)
{
281 282 283
	struct exynos_drm_connector *exynos_connector =
					to_exynos_connector(connector);
	struct exynos_drm_manager *manager = exynos_connector->manager;
284 285
	struct exynos_drm_display_ops *display_ops =
					manager->display_ops;
286 287 288 289
	enum drm_connector_status status = connector_status_disconnected;

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

290 291
	if (display_ops && display_ops->is_connected) {
		if (display_ops->is_connected(manager->dev))
292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312
			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 = {
313
	.dpms		= exynos_drm_connector_dpms,
314
	.fill_modes	= exynos_drm_connector_fill_modes,
315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337
	.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;

338
	switch (manager->display_ops->type) {
339 340
	case EXYNOS_DISPLAY_TYPE_HDMI:
		type = DRM_MODE_CONNECTOR_HDMIA;
341 342
		connector->interlace_allowed = true;
		connector->polled = DRM_CONNECTOR_POLL_HPD;
343
		break;
344 345 346 347
	case EXYNOS_DISPLAY_TYPE_VIDI:
		type = DRM_MODE_CONNECTOR_VIRTUAL;
		connector->polled = DRM_CONNECTOR_POLL_HPD;
		break;
348 349 350 351 352 353 354 355 356 357 358 359
	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;

360 361
	exynos_connector->encoder_id = encoder->base.id;
	exynos_connector->manager = manager;
362
	exynos_connector->dpms = DRM_MODE_DPMS_OFF;
I
Inki Dae 已提交
363
	connector->dpms = DRM_MODE_DPMS_OFF;
364
	connector->encoder = encoder;
365

366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382
	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;
}