1 /* exynos_drm_vidi.c
2  *
3  * Copyright (C) 2012 Samsung Electronics Co.Ltd
4  * Authors:
5  *	Inki Dae <inki.dae@samsung.com>
6  *
7  * This program is free software; you can redistribute  it and/or modify it
8  * under  the terms of  the GNU General  Public License as published by the
9  * Free Software Foundation;  either version 2 of the  License, or (at your
10  * option) any later version.
11  *
12  */
13 #include <drm/drmP.h>
14 
15 #include <linux/kernel.h>
16 #include <linux/platform_device.h>
17 
18 #include <drm/exynos_drm.h>
19 
20 #include <drm/drm_edid.h>
21 #include <drm/drm_crtc_helper.h>
22 
23 #include "exynos_drm_drv.h"
24 #include "exynos_drm_crtc.h"
25 #include "exynos_drm_encoder.h"
26 #include "exynos_drm_vidi.h"
27 
28 /* vidi has totally three virtual windows. */
29 #define WINDOWS_NR		3
30 
31 #define get_vidi_mgr(dev)	platform_get_drvdata(to_platform_device(dev))
32 #define ctx_from_connector(c)	container_of(c, struct vidi_context, \
33 					connector)
34 
35 struct vidi_win_data {
36 	unsigned int		offset_x;
37 	unsigned int		offset_y;
38 	unsigned int		ovl_width;
39 	unsigned int		ovl_height;
40 	unsigned int		fb_width;
41 	unsigned int		fb_height;
42 	unsigned int		bpp;
43 	dma_addr_t		dma_addr;
44 	unsigned int		buf_offsize;
45 	unsigned int		line_size;	/* bytes */
46 	bool			enabled;
47 };
48 
49 struct vidi_context {
50 	struct drm_device		*drm_dev;
51 	struct drm_crtc			*crtc;
52 	struct drm_encoder		*encoder;
53 	struct drm_connector		connector;
54 	struct vidi_win_data		win_data[WINDOWS_NR];
55 	struct edid			*raw_edid;
56 	unsigned int			clkdiv;
57 	unsigned int			default_win;
58 	unsigned long			irq_flags;
59 	unsigned int			connected;
60 	bool				vblank_on;
61 	bool				suspended;
62 	bool				direct_vblank;
63 	struct work_struct		work;
64 	struct mutex			lock;
65 	int				pipe;
66 };
67 
68 static const char fake_edid_info[] = {
69 	0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x4c, 0x2d, 0x05, 0x05,
70 	0x00, 0x00, 0x00, 0x00, 0x30, 0x12, 0x01, 0x03, 0x80, 0x10, 0x09, 0x78,
71 	0x0a, 0xee, 0x91, 0xa3, 0x54, 0x4c, 0x99, 0x26, 0x0f, 0x50, 0x54, 0xbd,
72 	0xee, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
73 	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x66, 0x21, 0x50, 0xb0, 0x51, 0x00,
74 	0x1b, 0x30, 0x40, 0x70, 0x36, 0x00, 0xa0, 0x5a, 0x00, 0x00, 0x00, 0x1e,
75 	0x01, 0x1d, 0x00, 0x72, 0x51, 0xd0, 0x1e, 0x20, 0x6e, 0x28, 0x55, 0x00,
76 	0xa0, 0x5a, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x18,
77 	0x4b, 0x1a, 0x44, 0x17, 0x00, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
78 	0x00, 0x00, 0x00, 0xfc, 0x00, 0x53, 0x41, 0x4d, 0x53, 0x55, 0x4e, 0x47,
79 	0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x01, 0xbc, 0x02, 0x03, 0x1e, 0xf1,
80 	0x46, 0x84, 0x05, 0x03, 0x10, 0x20, 0x22, 0x23, 0x09, 0x07, 0x07, 0x83,
81 	0x01, 0x00, 0x00, 0xe2, 0x00, 0x0f, 0x67, 0x03, 0x0c, 0x00, 0x10, 0x00,
82 	0xb8, 0x2d, 0x01, 0x1d, 0x80, 0x18, 0x71, 0x1c, 0x16, 0x20, 0x58, 0x2c,
83 	0x25, 0x00, 0xa0, 0x5a, 0x00, 0x00, 0x00, 0x9e, 0x8c, 0x0a, 0xd0, 0x8a,
84 	0x20, 0xe0, 0x2d, 0x10, 0x10, 0x3e, 0x96, 0x00, 0xa0, 0x5a, 0x00, 0x00,
85 	0x00, 0x18, 0x02, 0x3a, 0x80, 0x18, 0x71, 0x38, 0x2d, 0x40, 0x58, 0x2c,
86 	0x45, 0x00, 0xa0, 0x5a, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00,
87 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
88 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
89 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
90 	0x00, 0x00, 0x00, 0x06
91 };
92 
93 static void vidi_apply(struct exynos_drm_manager *mgr)
94 {
95 	struct vidi_context *ctx = mgr->ctx;
96 	struct exynos_drm_manager_ops *mgr_ops = mgr->ops;
97 	struct vidi_win_data *win_data;
98 	int i;
99 
100 	for (i = 0; i < WINDOWS_NR; i++) {
101 		win_data = &ctx->win_data[i];
102 		if (win_data->enabled && (mgr_ops && mgr_ops->win_commit))
103 			mgr_ops->win_commit(mgr, i);
104 	}
105 
106 	if (mgr_ops && mgr_ops->commit)
107 		mgr_ops->commit(mgr);
108 }
109 
110 static void vidi_commit(struct exynos_drm_manager *mgr)
111 {
112 	struct vidi_context *ctx = mgr->ctx;
113 
114 	if (ctx->suspended)
115 		return;
116 }
117 
118 static int vidi_enable_vblank(struct exynos_drm_manager *mgr)
119 {
120 	struct vidi_context *ctx = mgr->ctx;
121 
122 	if (ctx->suspended)
123 		return -EPERM;
124 
125 	if (!test_and_set_bit(0, &ctx->irq_flags))
126 		ctx->vblank_on = true;
127 
128 	ctx->direct_vblank = true;
129 
130 	/*
131 	 * in case of page flip request, vidi_finish_pageflip function
132 	 * will not be called because direct_vblank is true and then
133 	 * that function will be called by manager_ops->win_commit callback
134 	 */
135 	schedule_work(&ctx->work);
136 
137 	return 0;
138 }
139 
140 static void vidi_disable_vblank(struct exynos_drm_manager *mgr)
141 {
142 	struct vidi_context *ctx = mgr->ctx;
143 
144 	if (ctx->suspended)
145 		return;
146 
147 	if (test_and_clear_bit(0, &ctx->irq_flags))
148 		ctx->vblank_on = false;
149 }
150 
151 static void vidi_win_mode_set(struct exynos_drm_manager *mgr,
152 			struct exynos_drm_overlay *overlay)
153 {
154 	struct vidi_context *ctx = mgr->ctx;
155 	struct vidi_win_data *win_data;
156 	int win;
157 	unsigned long offset;
158 
159 	if (!overlay) {
160 		DRM_ERROR("overlay is NULL\n");
161 		return;
162 	}
163 
164 	win = overlay->zpos;
165 	if (win == DEFAULT_ZPOS)
166 		win = ctx->default_win;
167 
168 	if (win < 0 || win >= WINDOWS_NR)
169 		return;
170 
171 	offset = overlay->fb_x * (overlay->bpp >> 3);
172 	offset += overlay->fb_y * overlay->pitch;
173 
174 	DRM_DEBUG_KMS("offset = 0x%lx, pitch = %x\n", offset, overlay->pitch);
175 
176 	win_data = &ctx->win_data[win];
177 
178 	win_data->offset_x = overlay->crtc_x;
179 	win_data->offset_y = overlay->crtc_y;
180 	win_data->ovl_width = overlay->crtc_width;
181 	win_data->ovl_height = overlay->crtc_height;
182 	win_data->fb_width = overlay->fb_width;
183 	win_data->fb_height = overlay->fb_height;
184 	win_data->dma_addr = overlay->dma_addr[0] + offset;
185 	win_data->bpp = overlay->bpp;
186 	win_data->buf_offsize = (overlay->fb_width - overlay->crtc_width) *
187 				(overlay->bpp >> 3);
188 	win_data->line_size = overlay->crtc_width * (overlay->bpp >> 3);
189 
190 	/*
191 	 * some parts of win_data should be transferred to user side
192 	 * through specific ioctl.
193 	 */
194 
195 	DRM_DEBUG_KMS("offset_x = %d, offset_y = %d\n",
196 			win_data->offset_x, win_data->offset_y);
197 	DRM_DEBUG_KMS("ovl_width = %d, ovl_height = %d\n",
198 			win_data->ovl_width, win_data->ovl_height);
199 	DRM_DEBUG_KMS("paddr = 0x%lx\n", (unsigned long)win_data->dma_addr);
200 	DRM_DEBUG_KMS("fb_width = %d, crtc_width = %d\n",
201 			overlay->fb_width, overlay->crtc_width);
202 }
203 
204 static void vidi_win_commit(struct exynos_drm_manager *mgr, int zpos)
205 {
206 	struct vidi_context *ctx = mgr->ctx;
207 	struct vidi_win_data *win_data;
208 	int win = zpos;
209 
210 	if (ctx->suspended)
211 		return;
212 
213 	if (win == DEFAULT_ZPOS)
214 		win = ctx->default_win;
215 
216 	if (win < 0 || win >= WINDOWS_NR)
217 		return;
218 
219 	win_data = &ctx->win_data[win];
220 
221 	win_data->enabled = true;
222 
223 	DRM_DEBUG_KMS("dma_addr = 0x%x\n", win_data->dma_addr);
224 
225 	if (ctx->vblank_on)
226 		schedule_work(&ctx->work);
227 }
228 
229 static void vidi_win_disable(struct exynos_drm_manager *mgr, int zpos)
230 {
231 	struct vidi_context *ctx = mgr->ctx;
232 	struct vidi_win_data *win_data;
233 	int win = zpos;
234 
235 	if (win == DEFAULT_ZPOS)
236 		win = ctx->default_win;
237 
238 	if (win < 0 || win >= WINDOWS_NR)
239 		return;
240 
241 	win_data = &ctx->win_data[win];
242 	win_data->enabled = false;
243 
244 	/* TODO. */
245 }
246 
247 static int vidi_power_on(struct exynos_drm_manager *mgr, bool enable)
248 {
249 	struct vidi_context *ctx = mgr->ctx;
250 
251 	DRM_DEBUG_KMS("%s\n", __FILE__);
252 
253 	if (enable != false && enable != true)
254 		return -EINVAL;
255 
256 	if (enable) {
257 		ctx->suspended = false;
258 
259 		/* if vblank was enabled status, enable it again. */
260 		if (test_and_clear_bit(0, &ctx->irq_flags))
261 			vidi_enable_vblank(mgr);
262 
263 		vidi_apply(mgr);
264 	} else {
265 		ctx->suspended = true;
266 	}
267 
268 	return 0;
269 }
270 
271 static void vidi_dpms(struct exynos_drm_manager *mgr, int mode)
272 {
273 	struct vidi_context *ctx = mgr->ctx;
274 
275 	DRM_DEBUG_KMS("%d\n", mode);
276 
277 	mutex_lock(&ctx->lock);
278 
279 	switch (mode) {
280 	case DRM_MODE_DPMS_ON:
281 		vidi_power_on(mgr, true);
282 		break;
283 	case DRM_MODE_DPMS_STANDBY:
284 	case DRM_MODE_DPMS_SUSPEND:
285 	case DRM_MODE_DPMS_OFF:
286 		vidi_power_on(mgr, false);
287 		break;
288 	default:
289 		DRM_DEBUG_KMS("unspecified mode %d\n", mode);
290 		break;
291 	}
292 
293 	mutex_unlock(&ctx->lock);
294 }
295 
296 static int vidi_mgr_initialize(struct exynos_drm_manager *mgr,
297 			struct drm_device *drm_dev, int pipe)
298 {
299 	struct vidi_context *ctx = mgr->ctx;
300 
301 	DRM_ERROR("vidi initialize ct=%p dev=%p pipe=%d\n", ctx, drm_dev, pipe);
302 
303 	ctx->drm_dev = drm_dev;
304 	ctx->pipe = pipe;
305 
306 	/*
307 	 * enable drm irq mode.
308 	 * - with irq_enabled = 1, we can use the vblank feature.
309 	 *
310 	 * P.S. note that we wouldn't use drm irq handler but
311 	 *	just specific driver own one instead because
312 	 *	drm framework supports only one irq handler.
313 	 */
314 	drm_dev->irq_enabled = 1;
315 
316 	/*
317 	 * with vblank_disable_allowed = 1, vblank interrupt will be disabled
318 	 * by drm timer once a current process gives up ownership of
319 	 * vblank event.(after drm_vblank_put function is called)
320 	 */
321 	drm_dev->vblank_disable_allowed = 1;
322 
323 	return 0;
324 }
325 
326 static struct exynos_drm_manager_ops vidi_manager_ops = {
327 	.initialize = vidi_mgr_initialize,
328 	.dpms = vidi_dpms,
329 	.commit = vidi_commit,
330 	.enable_vblank = vidi_enable_vblank,
331 	.disable_vblank = vidi_disable_vblank,
332 	.win_mode_set = vidi_win_mode_set,
333 	.win_commit = vidi_win_commit,
334 	.win_disable = vidi_win_disable,
335 };
336 
337 static struct exynos_drm_manager vidi_manager = {
338 	.type = EXYNOS_DISPLAY_TYPE_VIDI,
339 	.ops = &vidi_manager_ops,
340 };
341 
342 static void vidi_fake_vblank_handler(struct work_struct *work)
343 {
344 	struct vidi_context *ctx = container_of(work, struct vidi_context,
345 					work);
346 
347 	if (ctx->pipe < 0)
348 		return;
349 
350 	/* refresh rate is about 50Hz. */
351 	usleep_range(16000, 20000);
352 
353 	mutex_lock(&ctx->lock);
354 
355 	if (ctx->direct_vblank) {
356 		drm_handle_vblank(ctx->drm_dev, ctx->pipe);
357 		ctx->direct_vblank = false;
358 		mutex_unlock(&ctx->lock);
359 		return;
360 	}
361 
362 	mutex_unlock(&ctx->lock);
363 
364 	exynos_drm_crtc_finish_pageflip(ctx->drm_dev, ctx->pipe);
365 }
366 
367 static int vidi_show_connection(struct device *dev,
368 				struct device_attribute *attr, char *buf)
369 {
370 	int rc;
371 	struct exynos_drm_manager *mgr = get_vidi_mgr(dev);
372 	struct vidi_context *ctx = mgr->ctx;
373 
374 	mutex_lock(&ctx->lock);
375 
376 	rc = sprintf(buf, "%d\n", ctx->connected);
377 
378 	mutex_unlock(&ctx->lock);
379 
380 	return rc;
381 }
382 
383 static int vidi_store_connection(struct device *dev,
384 				struct device_attribute *attr,
385 				const char *buf, size_t len)
386 {
387 	struct exynos_drm_manager *mgr = get_vidi_mgr(dev);
388 	struct vidi_context *ctx = mgr->ctx;
389 	int ret;
390 
391 	ret = kstrtoint(buf, 0, &ctx->connected);
392 	if (ret)
393 		return ret;
394 
395 	if (ctx->connected > 1)
396 		return -EINVAL;
397 
398 	/* use fake edid data for test. */
399 	if (!ctx->raw_edid)
400 		ctx->raw_edid = (struct edid *)fake_edid_info;
401 
402 	/* if raw_edid isn't same as fake data then it can't be tested. */
403 	if (ctx->raw_edid != (struct edid *)fake_edid_info) {
404 		DRM_DEBUG_KMS("edid data is not fake data.\n");
405 		return -EINVAL;
406 	}
407 
408 	DRM_DEBUG_KMS("requested connection.\n");
409 
410 	drm_helper_hpd_irq_event(ctx->drm_dev);
411 
412 	return len;
413 }
414 
415 static DEVICE_ATTR(connection, 0644, vidi_show_connection,
416 			vidi_store_connection);
417 
418 int vidi_connection_ioctl(struct drm_device *drm_dev, void *data,
419 				struct drm_file *file_priv)
420 {
421 	struct vidi_context *ctx = NULL;
422 	struct drm_encoder *encoder;
423 	struct exynos_drm_display *display;
424 	struct drm_exynos_vidi_connection *vidi = data;
425 
426 	if (!vidi) {
427 		DRM_DEBUG_KMS("user data for vidi is null.\n");
428 		return -EINVAL;
429 	}
430 
431 	if (vidi->connection > 1) {
432 		DRM_DEBUG_KMS("connection should be 0 or 1.\n");
433 		return -EINVAL;
434 	}
435 
436 	list_for_each_entry(encoder, &drm_dev->mode_config.encoder_list,
437 								head) {
438 		display = exynos_drm_get_display(encoder);
439 
440 		if (display->type == EXYNOS_DISPLAY_TYPE_VIDI) {
441 			ctx = display->ctx;
442 			break;
443 		}
444 	}
445 
446 	if (!ctx) {
447 		DRM_DEBUG_KMS("not found virtual device type encoder.\n");
448 		return -EINVAL;
449 	}
450 
451 	if (ctx->connected == vidi->connection) {
452 		DRM_DEBUG_KMS("same connection request.\n");
453 		return -EINVAL;
454 	}
455 
456 	if (vidi->connection) {
457 		struct edid *raw_edid  = (struct edid *)(uint32_t)vidi->edid;
458 		if (!drm_edid_is_valid(raw_edid)) {
459 			DRM_DEBUG_KMS("edid data is invalid.\n");
460 			return -EINVAL;
461 		}
462 		ctx->raw_edid = drm_edid_duplicate(raw_edid);
463 		if (!ctx->raw_edid) {
464 			DRM_DEBUG_KMS("failed to allocate raw_edid.\n");
465 			return -ENOMEM;
466 		}
467 	} else {
468 		/*
469 		 * with connection = 0, free raw_edid
470 		 * only if raw edid data isn't same as fake data.
471 		 */
472 		if (ctx->raw_edid && ctx->raw_edid !=
473 				(struct edid *)fake_edid_info) {
474 			kfree(ctx->raw_edid);
475 			ctx->raw_edid = NULL;
476 		}
477 	}
478 
479 	ctx->connected = vidi->connection;
480 	drm_helper_hpd_irq_event(ctx->drm_dev);
481 
482 	return 0;
483 }
484 
485 static enum drm_connector_status vidi_detect(struct drm_connector *connector,
486 			bool force)
487 {
488 	struct vidi_context *ctx = ctx_from_connector(connector);
489 
490 	/*
491 	 * connection request would come from user side
492 	 * to do hotplug through specific ioctl.
493 	 */
494 	return ctx->connected ? connector_status_connected :
495 			connector_status_disconnected;
496 }
497 
498 static void vidi_connector_destroy(struct drm_connector *connector)
499 {
500 }
501 
502 static struct drm_connector_funcs vidi_connector_funcs = {
503 	.dpms = drm_helper_connector_dpms,
504 	.fill_modes = drm_helper_probe_single_connector_modes,
505 	.detect = vidi_detect,
506 	.destroy = vidi_connector_destroy,
507 };
508 
509 static int vidi_get_modes(struct drm_connector *connector)
510 {
511 	struct vidi_context *ctx = ctx_from_connector(connector);
512 	struct edid *edid;
513 	int edid_len;
514 
515 	/*
516 	 * the edid data comes from user side and it would be set
517 	 * to ctx->raw_edid through specific ioctl.
518 	 */
519 	if (!ctx->raw_edid) {
520 		DRM_DEBUG_KMS("raw_edid is null.\n");
521 		return -EFAULT;
522 	}
523 
524 	edid_len = (1 + ctx->raw_edid->extensions) * EDID_LENGTH;
525 	edid = kmemdup(ctx->raw_edid, edid_len, GFP_KERNEL);
526 	if (!edid) {
527 		DRM_DEBUG_KMS("failed to allocate edid\n");
528 		return -ENOMEM;
529 	}
530 
531 	drm_mode_connector_update_edid_property(connector, edid);
532 
533 	return drm_add_edid_modes(connector, edid);
534 }
535 
536 static int vidi_mode_valid(struct drm_connector *connector,
537 			struct drm_display_mode *mode)
538 {
539 	return MODE_OK;
540 }
541 
542 static struct drm_encoder *vidi_best_encoder(struct drm_connector *connector)
543 {
544 	struct vidi_context *ctx = ctx_from_connector(connector);
545 
546 	return ctx->encoder;
547 }
548 
549 static struct drm_connector_helper_funcs vidi_connector_helper_funcs = {
550 	.get_modes = vidi_get_modes,
551 	.mode_valid = vidi_mode_valid,
552 	.best_encoder = vidi_best_encoder,
553 };
554 
555 static int vidi_create_connector(struct exynos_drm_display *display,
556 				struct drm_encoder *encoder)
557 {
558 	struct vidi_context *ctx = display->ctx;
559 	struct drm_connector *connector = &ctx->connector;
560 	int ret;
561 
562 	ctx->encoder = encoder;
563 	connector->polled = DRM_CONNECTOR_POLL_HPD;
564 
565 	ret = drm_connector_init(ctx->drm_dev, connector,
566 			&vidi_connector_funcs, DRM_MODE_CONNECTOR_VIRTUAL);
567 	if (ret) {
568 		DRM_ERROR("Failed to initialize connector with drm\n");
569 		return ret;
570 	}
571 
572 	drm_connector_helper_add(connector, &vidi_connector_helper_funcs);
573 	drm_sysfs_connector_add(connector);
574 	drm_mode_connector_attach_encoder(connector, encoder);
575 
576 	return 0;
577 }
578 
579 
580 static struct exynos_drm_display_ops vidi_display_ops = {
581 	.create_connector = vidi_create_connector,
582 };
583 
584 static struct exynos_drm_display vidi_display = {
585 	.type = EXYNOS_DISPLAY_TYPE_VIDI,
586 	.ops = &vidi_display_ops,
587 };
588 
589 static int vidi_probe(struct platform_device *pdev)
590 {
591 	struct device *dev = &pdev->dev;
592 	struct vidi_context *ctx;
593 	int ret;
594 
595 	ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
596 	if (!ctx)
597 		return -ENOMEM;
598 
599 	ctx->default_win = 0;
600 
601 	INIT_WORK(&ctx->work, vidi_fake_vblank_handler);
602 
603 	vidi_manager.ctx = ctx;
604 	vidi_display.ctx = ctx;
605 
606 	mutex_init(&ctx->lock);
607 
608 	platform_set_drvdata(pdev, &vidi_manager);
609 
610 	ret = device_create_file(dev, &dev_attr_connection);
611 	if (ret < 0)
612 		DRM_INFO("failed to create connection sysfs.\n");
613 
614 	exynos_drm_manager_register(&vidi_manager);
615 	exynos_drm_display_register(&vidi_display);
616 
617 	return 0;
618 }
619 
620 static int vidi_remove(struct platform_device *pdev)
621 {
622 	struct vidi_context *ctx = platform_get_drvdata(pdev);
623 
624 	exynos_drm_display_unregister(&vidi_display);
625 	exynos_drm_manager_unregister(&vidi_manager);
626 
627 	if (ctx->raw_edid != (struct edid *)fake_edid_info) {
628 		kfree(ctx->raw_edid);
629 		ctx->raw_edid = NULL;
630 	}
631 
632 	return 0;
633 }
634 
635 struct platform_driver vidi_driver = {
636 	.probe		= vidi_probe,
637 	.remove		= vidi_remove,
638 	.driver		= {
639 		.name	= "exynos-drm-vidi",
640 		.owner	= THIS_MODULE,
641 	},
642 };
643