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 
313 	/*
314 	 * the edid data comes from user side and it would be set
315 	 * to ctx->raw_edid through specific ioctl.
316 	 */
317 	if (!ctx->raw_edid) {
318 		DRM_DEV_DEBUG_KMS(ctx->dev, "raw_edid is null.\n");
319 		return 0;
320 	}
321 
322 	edid_len = (1 + ctx->raw_edid->extensions) * EDID_LENGTH;
323 	edid = kmemdup(ctx->raw_edid, edid_len, GFP_KERNEL);
324 	if (!edid) {
325 		DRM_DEV_DEBUG_KMS(ctx->dev, "failed to allocate edid\n");
326 		return 0;
327 	}
328 
329 	drm_connector_update_edid_property(connector, edid);
330 
331 	return drm_add_edid_modes(connector, edid);
332 }
333 
334 static const struct drm_connector_helper_funcs vidi_connector_helper_funcs = {
335 	.get_modes = vidi_get_modes,
336 };
337 
338 static int vidi_create_connector(struct drm_encoder *encoder)
339 {
340 	struct vidi_context *ctx = encoder_to_vidi(encoder);
341 	struct drm_connector *connector = &ctx->connector;
342 	int ret;
343 
344 	connector->polled = DRM_CONNECTOR_POLL_HPD;
345 
346 	ret = drm_connector_init(ctx->drm_dev, connector,
347 			&vidi_connector_funcs, DRM_MODE_CONNECTOR_VIRTUAL);
348 	if (ret) {
349 		DRM_DEV_ERROR(ctx->dev,
350 			      "Failed to initialize connector with drm\n");
351 		return ret;
352 	}
353 
354 	drm_connector_helper_add(connector, &vidi_connector_helper_funcs);
355 	drm_connector_attach_encoder(connector, encoder);
356 
357 	return 0;
358 }
359 
360 static void exynos_vidi_mode_set(struct drm_encoder *encoder,
361 			       struct drm_display_mode *mode,
362 			       struct drm_display_mode *adjusted_mode)
363 {
364 }
365 
366 static void exynos_vidi_enable(struct drm_encoder *encoder)
367 {
368 }
369 
370 static void exynos_vidi_disable(struct drm_encoder *encoder)
371 {
372 }
373 
374 static const struct drm_encoder_helper_funcs exynos_vidi_encoder_helper_funcs = {
375 	.mode_set = exynos_vidi_mode_set,
376 	.enable = exynos_vidi_enable,
377 	.disable = exynos_vidi_disable,
378 };
379 
380 static int vidi_bind(struct device *dev, struct device *master, void *data)
381 {
382 	struct vidi_context *ctx = dev_get_drvdata(dev);
383 	struct drm_device *drm_dev = data;
384 	struct drm_encoder *encoder = &ctx->encoder;
385 	struct exynos_drm_plane *exynos_plane;
386 	struct exynos_drm_plane_config plane_config = { 0 };
387 	unsigned int i;
388 	int ret;
389 
390 	ctx->drm_dev = drm_dev;
391 
392 	plane_config.pixel_formats = formats;
393 	plane_config.num_pixel_formats = ARRAY_SIZE(formats);
394 
395 	for (i = 0; i < WINDOWS_NR; i++) {
396 		plane_config.zpos = i;
397 		plane_config.type = vidi_win_types[i];
398 
399 		ret = exynos_plane_init(drm_dev, &ctx->planes[i], i,
400 					&plane_config);
401 		if (ret)
402 			return ret;
403 	}
404 
405 	exynos_plane = &ctx->planes[DEFAULT_WIN];
406 	ctx->crtc = exynos_drm_crtc_create(drm_dev, &exynos_plane->base,
407 			EXYNOS_DISPLAY_TYPE_VIDI, &vidi_crtc_ops, ctx);
408 	if (IS_ERR(ctx->crtc)) {
409 		DRM_DEV_ERROR(dev, "failed to create crtc.\n");
410 		return PTR_ERR(ctx->crtc);
411 	}
412 
413 	drm_simple_encoder_init(drm_dev, encoder, DRM_MODE_ENCODER_TMDS);
414 
415 	drm_encoder_helper_add(encoder, &exynos_vidi_encoder_helper_funcs);
416 
417 	ret = exynos_drm_set_possible_crtcs(encoder, EXYNOS_DISPLAY_TYPE_VIDI);
418 	if (ret < 0)
419 		return ret;
420 
421 	ret = vidi_create_connector(encoder);
422 	if (ret) {
423 		DRM_DEV_ERROR(dev, "failed to create connector ret = %d\n",
424 			      ret);
425 		drm_encoder_cleanup(encoder);
426 		return ret;
427 	}
428 
429 	return 0;
430 }
431 
432 
433 static void vidi_unbind(struct device *dev, struct device *master, void *data)
434 {
435 	struct vidi_context *ctx = dev_get_drvdata(dev);
436 
437 	del_timer_sync(&ctx->timer);
438 }
439 
440 static const struct component_ops vidi_component_ops = {
441 	.bind	= vidi_bind,
442 	.unbind = vidi_unbind,
443 };
444 
445 static int vidi_probe(struct platform_device *pdev)
446 {
447 	struct vidi_context *ctx;
448 	struct device *dev = &pdev->dev;
449 
450 	ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
451 	if (!ctx)
452 		return -ENOMEM;
453 
454 	ctx->dev = dev;
455 
456 	timer_setup(&ctx->timer, vidi_fake_vblank_timer, 0);
457 
458 	mutex_init(&ctx->lock);
459 
460 	platform_set_drvdata(pdev, ctx);
461 
462 	return component_add(dev, &vidi_component_ops);
463 }
464 
465 static int vidi_remove(struct platform_device *pdev)
466 {
467 	struct vidi_context *ctx = platform_get_drvdata(pdev);
468 
469 	if (ctx->raw_edid != (struct edid *)fake_edid_info) {
470 		kfree(ctx->raw_edid);
471 		ctx->raw_edid = NULL;
472 	}
473 
474 	component_del(&pdev->dev, &vidi_component_ops);
475 
476 	return 0;
477 }
478 
479 struct platform_driver vidi_driver = {
480 	.probe		= vidi_probe,
481 	.remove		= vidi_remove,
482 	.driver		= {
483 		.name	= "exynos-drm-vidi",
484 		.owner	= THIS_MODULE,
485 		.dev_groups = vidi_groups,
486 	},
487 };
488