1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* exynos_drm_vidi.c
3  *
4  * Copyright (C) 2012 Samsung Electronics Co.Ltd
5  * Authors:
6  *	Inki Dae <inki.dae@samsung.com>
7  */
8 
9 #include <linux/component.h>
10 #include <linux/kernel.h>
11 #include <linux/platform_device.h>
12 #include <linux/timer.h>
13 
14 #include <drm/drm_atomic_helper.h>
15 #include <drm/drm_edid.h>
16 #include <drm/drm_framebuffer.h>
17 #include <drm/drm_probe_helper.h>
18 #include <drm/drm_simple_kms_helper.h>
19 #include <drm/drm_vblank.h>
20 #include <drm/exynos_drm.h>
21 
22 #include "exynos_drm_crtc.h"
23 #include "exynos_drm_drv.h"
24 #include "exynos_drm_fb.h"
25 #include "exynos_drm_plane.h"
26 #include "exynos_drm_vidi.h"
27 
28 /* VIDI uses fixed refresh rate of 50Hz */
29 #define VIDI_REFRESH_TIME (1000 / 50)
30 
31 /* vidi has totally three virtual windows. */
32 #define WINDOWS_NR		3
33 
34 #define ctx_from_connector(c)	container_of(c, struct vidi_context, \
35 					connector)
36 
37 struct vidi_context {
38 	struct drm_encoder		encoder;
39 	struct drm_device		*drm_dev;
40 	struct device			*dev;
41 	struct exynos_drm_crtc		*crtc;
42 	struct drm_connector		connector;
43 	struct exynos_drm_plane		planes[WINDOWS_NR];
44 	struct edid			*raw_edid;
45 	unsigned int			clkdiv;
46 	unsigned int			connected;
47 	bool				suspended;
48 	struct timer_list		timer;
49 	struct mutex			lock;
50 };
51 
52 static inline struct vidi_context *encoder_to_vidi(struct drm_encoder *e)
53 {
54 	return container_of(e, struct vidi_context, encoder);
55 }
56 
57 static const char fake_edid_info[] = {
58 	0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x4c, 0x2d, 0x05, 0x05,
59 	0x00, 0x00, 0x00, 0x00, 0x30, 0x12, 0x01, 0x03, 0x80, 0x10, 0x09, 0x78,
60 	0x0a, 0xee, 0x91, 0xa3, 0x54, 0x4c, 0x99, 0x26, 0x0f, 0x50, 0x54, 0xbd,
61 	0xee, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
62 	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x66, 0x21, 0x50, 0xb0, 0x51, 0x00,
63 	0x1b, 0x30, 0x40, 0x70, 0x36, 0x00, 0xa0, 0x5a, 0x00, 0x00, 0x00, 0x1e,
64 	0x01, 0x1d, 0x00, 0x72, 0x51, 0xd0, 0x1e, 0x20, 0x6e, 0x28, 0x55, 0x00,
65 	0xa0, 0x5a, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x18,
66 	0x4b, 0x1a, 0x44, 0x17, 0x00, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
67 	0x00, 0x00, 0x00, 0xfc, 0x00, 0x53, 0x41, 0x4d, 0x53, 0x55, 0x4e, 0x47,
68 	0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x01, 0xbc, 0x02, 0x03, 0x1e, 0xf1,
69 	0x46, 0x84, 0x05, 0x03, 0x10, 0x20, 0x22, 0x23, 0x09, 0x07, 0x07, 0x83,
70 	0x01, 0x00, 0x00, 0xe2, 0x00, 0x0f, 0x67, 0x03, 0x0c, 0x00, 0x10, 0x00,
71 	0xb8, 0x2d, 0x01, 0x1d, 0x80, 0x18, 0x71, 0x1c, 0x16, 0x20, 0x58, 0x2c,
72 	0x25, 0x00, 0xa0, 0x5a, 0x00, 0x00, 0x00, 0x9e, 0x8c, 0x0a, 0xd0, 0x8a,
73 	0x20, 0xe0, 0x2d, 0x10, 0x10, 0x3e, 0x96, 0x00, 0xa0, 0x5a, 0x00, 0x00,
74 	0x00, 0x18, 0x02, 0x3a, 0x80, 0x18, 0x71, 0x38, 0x2d, 0x40, 0x58, 0x2c,
75 	0x45, 0x00, 0xa0, 0x5a, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00,
76 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
77 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
78 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
79 	0x00, 0x00, 0x00, 0x06
80 };
81 
82 static const uint32_t formats[] = {
83 	DRM_FORMAT_XRGB8888,
84 	DRM_FORMAT_ARGB8888,
85 	DRM_FORMAT_NV12,
86 };
87 
88 static const enum drm_plane_type vidi_win_types[WINDOWS_NR] = {
89 	DRM_PLANE_TYPE_PRIMARY,
90 	DRM_PLANE_TYPE_OVERLAY,
91 	DRM_PLANE_TYPE_CURSOR,
92 };
93 
94 static int vidi_enable_vblank(struct exynos_drm_crtc *crtc)
95 {
96 	struct vidi_context *ctx = crtc->ctx;
97 
98 	if (ctx->suspended)
99 		return -EPERM;
100 
101 	mod_timer(&ctx->timer,
102 		jiffies + msecs_to_jiffies(VIDI_REFRESH_TIME) - 1);
103 
104 	return 0;
105 }
106 
107 static void vidi_disable_vblank(struct exynos_drm_crtc *crtc)
108 {
109 }
110 
111 static void vidi_update_plane(struct exynos_drm_crtc *crtc,
112 			      struct exynos_drm_plane *plane)
113 {
114 	struct drm_plane_state *state = plane->base.state;
115 	struct vidi_context *ctx = crtc->ctx;
116 	dma_addr_t addr;
117 
118 	if (ctx->suspended)
119 		return;
120 
121 	addr = exynos_drm_fb_dma_addr(state->fb, 0);
122 	DRM_DEV_DEBUG_KMS(ctx->dev, "dma_addr = %pad\n", &addr);
123 }
124 
125 static void vidi_atomic_enable(struct exynos_drm_crtc *crtc)
126 {
127 	struct vidi_context *ctx = crtc->ctx;
128 
129 	mutex_lock(&ctx->lock);
130 
131 	ctx->suspended = false;
132 
133 	mutex_unlock(&ctx->lock);
134 
135 	drm_crtc_vblank_on(&crtc->base);
136 }
137 
138 static void vidi_atomic_disable(struct exynos_drm_crtc *crtc)
139 {
140 	struct vidi_context *ctx = crtc->ctx;
141 
142 	drm_crtc_vblank_off(&crtc->base);
143 
144 	mutex_lock(&ctx->lock);
145 
146 	ctx->suspended = true;
147 
148 	mutex_unlock(&ctx->lock);
149 }
150 
151 static const struct exynos_drm_crtc_ops vidi_crtc_ops = {
152 	.atomic_enable = vidi_atomic_enable,
153 	.atomic_disable = vidi_atomic_disable,
154 	.enable_vblank = vidi_enable_vblank,
155 	.disable_vblank = vidi_disable_vblank,
156 	.update_plane = vidi_update_plane,
157 	.atomic_flush = exynos_crtc_handle_event,
158 };
159 
160 static void vidi_fake_vblank_timer(struct timer_list *t)
161 {
162 	struct vidi_context *ctx = from_timer(ctx, t, timer);
163 
164 	if (drm_crtc_handle_vblank(&ctx->crtc->base))
165 		mod_timer(&ctx->timer,
166 			jiffies + msecs_to_jiffies(VIDI_REFRESH_TIME) - 1);
167 }
168 
169 static ssize_t vidi_show_connection(struct device *dev,
170 				struct device_attribute *attr, char *buf)
171 {
172 	struct vidi_context *ctx = dev_get_drvdata(dev);
173 	int rc;
174 
175 	mutex_lock(&ctx->lock);
176 
177 	rc = sprintf(buf, "%d\n", ctx->connected);
178 
179 	mutex_unlock(&ctx->lock);
180 
181 	return rc;
182 }
183 
184 static ssize_t vidi_store_connection(struct device *dev,
185 				struct device_attribute *attr,
186 				const char *buf, size_t len)
187 {
188 	struct vidi_context *ctx = dev_get_drvdata(dev);
189 	int ret;
190 
191 	ret = kstrtoint(buf, 0, &ctx->connected);
192 	if (ret)
193 		return ret;
194 
195 	if (ctx->connected > 1)
196 		return -EINVAL;
197 
198 	/* use fake edid data for test. */
199 	if (!ctx->raw_edid)
200 		ctx->raw_edid = (struct edid *)fake_edid_info;
201 
202 	/* if raw_edid isn't same as fake data then it can't be tested. */
203 	if (ctx->raw_edid != (struct edid *)fake_edid_info) {
204 		DRM_DEV_DEBUG_KMS(dev, "edid data is not fake data.\n");
205 		return -EINVAL;
206 	}
207 
208 	DRM_DEV_DEBUG_KMS(dev, "requested connection.\n");
209 
210 	drm_helper_hpd_irq_event(ctx->drm_dev);
211 
212 	return len;
213 }
214 
215 static DEVICE_ATTR(connection, 0644, vidi_show_connection,
216 			vidi_store_connection);
217 
218 static struct attribute *vidi_attrs[] = {
219 	&dev_attr_connection.attr,
220 	NULL,
221 };
222 ATTRIBUTE_GROUPS(vidi);
223 
224 int vidi_connection_ioctl(struct drm_device *drm_dev, void *data,
225 				struct drm_file *file_priv)
226 {
227 	struct vidi_context *ctx = dev_get_drvdata(drm_dev->dev);
228 	struct drm_exynos_vidi_connection *vidi = data;
229 
230 	if (!vidi) {
231 		DRM_DEV_DEBUG_KMS(ctx->dev,
232 				  "user data for vidi is null.\n");
233 		return -EINVAL;
234 	}
235 
236 	if (vidi->connection > 1) {
237 		DRM_DEV_DEBUG_KMS(ctx->dev,
238 				  "connection should be 0 or 1.\n");
239 		return -EINVAL;
240 	}
241 
242 	if (ctx->connected == vidi->connection) {
243 		DRM_DEV_DEBUG_KMS(ctx->dev,
244 				  "same connection request.\n");
245 		return -EINVAL;
246 	}
247 
248 	if (vidi->connection) {
249 		struct edid *raw_edid;
250 
251 		raw_edid = (struct edid *)(unsigned long)vidi->edid;
252 		if (!drm_edid_is_valid(raw_edid)) {
253 			DRM_DEV_DEBUG_KMS(ctx->dev,
254 					  "edid data is invalid.\n");
255 			return -EINVAL;
256 		}
257 		ctx->raw_edid = drm_edid_duplicate(raw_edid);
258 		if (!ctx->raw_edid) {
259 			DRM_DEV_DEBUG_KMS(ctx->dev,
260 					  "failed to allocate raw_edid.\n");
261 			return -ENOMEM;
262 		}
263 	} else {
264 		/*
265 		 * with connection = 0, free raw_edid
266 		 * only if raw edid data isn't same as fake data.
267 		 */
268 		if (ctx->raw_edid && ctx->raw_edid !=
269 				(struct edid *)fake_edid_info) {
270 			kfree(ctx->raw_edid);
271 			ctx->raw_edid = NULL;
272 		}
273 	}
274 
275 	ctx->connected = vidi->connection;
276 	drm_helper_hpd_irq_event(ctx->drm_dev);
277 
278 	return 0;
279 }
280 
281 static enum drm_connector_status vidi_detect(struct drm_connector *connector,
282 			bool force)
283 {
284 	struct vidi_context *ctx = ctx_from_connector(connector);
285 
286 	/*
287 	 * connection request would come from user side
288 	 * to do hotplug through specific ioctl.
289 	 */
290 	return ctx->connected ? connector_status_connected :
291 			connector_status_disconnected;
292 }
293 
294 static void vidi_connector_destroy(struct drm_connector *connector)
295 {
296 }
297 
298 static const struct drm_connector_funcs vidi_connector_funcs = {
299 	.fill_modes = drm_helper_probe_single_connector_modes,
300 	.detect = vidi_detect,
301 	.destroy = vidi_connector_destroy,
302 	.reset = drm_atomic_helper_connector_reset,
303 	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
304 	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
305 };
306 
307 static int vidi_get_modes(struct drm_connector *connector)
308 {
309 	struct vidi_context *ctx = ctx_from_connector(connector);
310 	struct edid *edid;
311 	int edid_len;
312 	int count;
313 
314 	/*
315 	 * the edid data comes from user side and it would be set
316 	 * to ctx->raw_edid through specific ioctl.
317 	 */
318 	if (!ctx->raw_edid) {
319 		DRM_DEV_DEBUG_KMS(ctx->dev, "raw_edid is null.\n");
320 		return 0;
321 	}
322 
323 	edid_len = (1 + ctx->raw_edid->extensions) * EDID_LENGTH;
324 	edid = kmemdup(ctx->raw_edid, edid_len, GFP_KERNEL);
325 	if (!edid) {
326 		DRM_DEV_DEBUG_KMS(ctx->dev, "failed to allocate edid\n");
327 		return 0;
328 	}
329 
330 	drm_connector_update_edid_property(connector, edid);
331 
332 	count = drm_add_edid_modes(connector, edid);
333 
334 	kfree(edid);
335 
336 	return count;
337 }
338 
339 static const struct drm_connector_helper_funcs vidi_connector_helper_funcs = {
340 	.get_modes = vidi_get_modes,
341 };
342 
343 static int vidi_create_connector(struct drm_encoder *encoder)
344 {
345 	struct vidi_context *ctx = encoder_to_vidi(encoder);
346 	struct drm_connector *connector = &ctx->connector;
347 	int ret;
348 
349 	connector->polled = DRM_CONNECTOR_POLL_HPD;
350 
351 	ret = drm_connector_init(ctx->drm_dev, connector,
352 			&vidi_connector_funcs, DRM_MODE_CONNECTOR_VIRTUAL);
353 	if (ret) {
354 		DRM_DEV_ERROR(ctx->dev,
355 			      "Failed to initialize connector with drm\n");
356 		return ret;
357 	}
358 
359 	drm_connector_helper_add(connector, &vidi_connector_helper_funcs);
360 	drm_connector_attach_encoder(connector, encoder);
361 
362 	return 0;
363 }
364 
365 static void exynos_vidi_mode_set(struct drm_encoder *encoder,
366 			       struct drm_display_mode *mode,
367 			       struct drm_display_mode *adjusted_mode)
368 {
369 }
370 
371 static void exynos_vidi_enable(struct drm_encoder *encoder)
372 {
373 }
374 
375 static void exynos_vidi_disable(struct drm_encoder *encoder)
376 {
377 }
378 
379 static const struct drm_encoder_helper_funcs exynos_vidi_encoder_helper_funcs = {
380 	.mode_set = exynos_vidi_mode_set,
381 	.enable = exynos_vidi_enable,
382 	.disable = exynos_vidi_disable,
383 };
384 
385 static int vidi_bind(struct device *dev, struct device *master, void *data)
386 {
387 	struct vidi_context *ctx = dev_get_drvdata(dev);
388 	struct drm_device *drm_dev = data;
389 	struct drm_encoder *encoder = &ctx->encoder;
390 	struct exynos_drm_plane *exynos_plane;
391 	struct exynos_drm_plane_config plane_config = { 0 };
392 	unsigned int i;
393 	int ret;
394 
395 	ctx->drm_dev = drm_dev;
396 
397 	plane_config.pixel_formats = formats;
398 	plane_config.num_pixel_formats = ARRAY_SIZE(formats);
399 
400 	for (i = 0; i < WINDOWS_NR; i++) {
401 		plane_config.zpos = i;
402 		plane_config.type = vidi_win_types[i];
403 
404 		ret = exynos_plane_init(drm_dev, &ctx->planes[i], i,
405 					&plane_config);
406 		if (ret)
407 			return ret;
408 	}
409 
410 	exynos_plane = &ctx->planes[DEFAULT_WIN];
411 	ctx->crtc = exynos_drm_crtc_create(drm_dev, &exynos_plane->base,
412 			EXYNOS_DISPLAY_TYPE_VIDI, &vidi_crtc_ops, ctx);
413 	if (IS_ERR(ctx->crtc)) {
414 		DRM_DEV_ERROR(dev, "failed to create crtc.\n");
415 		return PTR_ERR(ctx->crtc);
416 	}
417 
418 	drm_simple_encoder_init(drm_dev, encoder, DRM_MODE_ENCODER_TMDS);
419 
420 	drm_encoder_helper_add(encoder, &exynos_vidi_encoder_helper_funcs);
421 
422 	ret = exynos_drm_set_possible_crtcs(encoder, EXYNOS_DISPLAY_TYPE_VIDI);
423 	if (ret < 0)
424 		return ret;
425 
426 	ret = vidi_create_connector(encoder);
427 	if (ret) {
428 		DRM_DEV_ERROR(dev, "failed to create connector ret = %d\n",
429 			      ret);
430 		drm_encoder_cleanup(encoder);
431 		return ret;
432 	}
433 
434 	return 0;
435 }
436 
437 
438 static void vidi_unbind(struct device *dev, struct device *master, void *data)
439 {
440 	struct vidi_context *ctx = dev_get_drvdata(dev);
441 
442 	del_timer_sync(&ctx->timer);
443 }
444 
445 static const struct component_ops vidi_component_ops = {
446 	.bind	= vidi_bind,
447 	.unbind = vidi_unbind,
448 };
449 
450 static int vidi_probe(struct platform_device *pdev)
451 {
452 	struct vidi_context *ctx;
453 	struct device *dev = &pdev->dev;
454 
455 	ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
456 	if (!ctx)
457 		return -ENOMEM;
458 
459 	ctx->dev = dev;
460 
461 	timer_setup(&ctx->timer, vidi_fake_vblank_timer, 0);
462 
463 	mutex_init(&ctx->lock);
464 
465 	platform_set_drvdata(pdev, ctx);
466 
467 	return component_add(dev, &vidi_component_ops);
468 }
469 
470 static int vidi_remove(struct platform_device *pdev)
471 {
472 	struct vidi_context *ctx = platform_get_drvdata(pdev);
473 
474 	if (ctx->raw_edid != (struct edid *)fake_edid_info) {
475 		kfree(ctx->raw_edid);
476 		ctx->raw_edid = NULL;
477 	}
478 
479 	component_del(&pdev->dev, &vidi_component_ops);
480 
481 	return 0;
482 }
483 
484 struct platform_driver vidi_driver = {
485 	.probe		= vidi_probe,
486 	.remove		= vidi_remove,
487 	.driver		= {
488 		.name	= "exynos-drm-vidi",
489 		.owner	= THIS_MODULE,
490 		.dev_groups = vidi_groups,
491 	},
492 };
493