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