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
 37struct 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	const struct drm_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
 52static inline struct vidi_context *encoder_to_vidi(struct drm_encoder *e)
 53{
 54	return container_of(e, struct vidi_context, encoder);
 55}
 56
 57static 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
 82static const uint32_t formats[] = {
 83	DRM_FORMAT_XRGB8888,
 84	DRM_FORMAT_ARGB8888,
 85	DRM_FORMAT_NV12,
 86};
 87
 88static 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
 94static 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
107static void vidi_disable_vblank(struct exynos_drm_crtc *crtc)
108{
109}
110
111static 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
125static 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
138static 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
151static 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
160static 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
169static 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
184static 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	/*
199	 * Use fake edid data for test. If raw_edid is set then it can't be
200	 * tested.
201	 */
202	if (ctx->raw_edid) {
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
214static DEVICE_ATTR(connection, 0644, vidi_show_connection,
215			vidi_store_connection);
216
217static struct attribute *vidi_attrs[] = {
218	&dev_attr_connection.attr,
219	NULL,
220};
221ATTRIBUTE_GROUPS(vidi);
222
223int 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		const struct drm_edid *drm_edid;
249		const struct edid *raw_edid;
250		size_t size;
251
252		raw_edid = (const struct edid *)(unsigned long)vidi->edid;
253		size = (raw_edid->extensions + 1) * EDID_LENGTH;
254
255		drm_edid = drm_edid_alloc(raw_edid, size);
256		if (!drm_edid)
257			return -ENOMEM;
258
259		if (!drm_edid_valid(drm_edid)) {
260			drm_edid_free(drm_edid);
261			DRM_DEV_DEBUG_KMS(ctx->dev,
262					  "edid data is invalid.\n");
263			return -EINVAL;
264		}
265		ctx->raw_edid = drm_edid;
266	} else {
267		/* with connection = 0, free raw_edid */
268		drm_edid_free(ctx->raw_edid);
269		ctx->raw_edid = NULL;
270	}
271
272	ctx->connected = vidi->connection;
273	drm_helper_hpd_irq_event(ctx->drm_dev);
274
275	return 0;
276}
277
278static enum drm_connector_status vidi_detect(struct drm_connector *connector,
279			bool force)
280{
281	struct vidi_context *ctx = ctx_from_connector(connector);
282
283	/*
284	 * connection request would come from user side
285	 * to do hotplug through specific ioctl.
286	 */
287	return ctx->connected ? connector_status_connected :
288			connector_status_disconnected;
289}
290
291static void vidi_connector_destroy(struct drm_connector *connector)
292{
293}
294
295static const struct drm_connector_funcs vidi_connector_funcs = {
296	.fill_modes = drm_helper_probe_single_connector_modes,
297	.detect = vidi_detect,
298	.destroy = vidi_connector_destroy,
299	.reset = drm_atomic_helper_connector_reset,
300	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
301	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
302};
303
304static int vidi_get_modes(struct drm_connector *connector)
305{
306	struct vidi_context *ctx = ctx_from_connector(connector);
307	const struct drm_edid *drm_edid;
308	int count;
309
310	if (ctx->raw_edid)
311		drm_edid = drm_edid_dup(ctx->raw_edid);
312	else
313		drm_edid = drm_edid_alloc(fake_edid_info, sizeof(fake_edid_info));
314
315	if (!drm_edid)
316		return 0;
317
318	drm_edid_connector_update(connector, drm_edid);
319
320	count = drm_edid_connector_add_modes(connector);
321
322	drm_edid_free(drm_edid);
323
324	return count;
325}
326
327static const struct drm_connector_helper_funcs vidi_connector_helper_funcs = {
328	.get_modes = vidi_get_modes,
329};
330
331static int vidi_create_connector(struct drm_encoder *encoder)
332{
333	struct vidi_context *ctx = encoder_to_vidi(encoder);
334	struct drm_connector *connector = &ctx->connector;
335	int ret;
336
337	connector->polled = DRM_CONNECTOR_POLL_HPD;
338
339	ret = drm_connector_init(ctx->drm_dev, connector,
340			&vidi_connector_funcs, DRM_MODE_CONNECTOR_VIRTUAL);
341	if (ret) {
342		DRM_DEV_ERROR(ctx->dev,
343			      "Failed to initialize connector with drm\n");
344		return ret;
345	}
346
347	drm_connector_helper_add(connector, &vidi_connector_helper_funcs);
348	drm_connector_attach_encoder(connector, encoder);
349
350	return 0;
351}
352
353static void exynos_vidi_mode_set(struct drm_encoder *encoder,
354			       struct drm_display_mode *mode,
355			       struct drm_display_mode *adjusted_mode)
356{
357}
358
359static void exynos_vidi_enable(struct drm_encoder *encoder)
360{
361}
362
363static void exynos_vidi_disable(struct drm_encoder *encoder)
364{
365}
366
367static const struct drm_encoder_helper_funcs exynos_vidi_encoder_helper_funcs = {
368	.mode_set = exynos_vidi_mode_set,
369	.enable = exynos_vidi_enable,
370	.disable = exynos_vidi_disable,
371};
372
373static int vidi_bind(struct device *dev, struct device *master, void *data)
374{
375	struct vidi_context *ctx = dev_get_drvdata(dev);
376	struct drm_device *drm_dev = data;
377	struct drm_encoder *encoder = &ctx->encoder;
378	struct exynos_drm_plane *exynos_plane;
379	struct exynos_drm_plane_config plane_config = { 0 };
380	unsigned int i;
381	int ret;
382
383	ctx->drm_dev = drm_dev;
384
385	plane_config.pixel_formats = formats;
386	plane_config.num_pixel_formats = ARRAY_SIZE(formats);
387
388	for (i = 0; i < WINDOWS_NR; i++) {
389		plane_config.zpos = i;
390		plane_config.type = vidi_win_types[i];
391
392		ret = exynos_plane_init(drm_dev, &ctx->planes[i], i,
393					&plane_config);
394		if (ret)
395			return ret;
396	}
397
398	exynos_plane = &ctx->planes[DEFAULT_WIN];
399	ctx->crtc = exynos_drm_crtc_create(drm_dev, &exynos_plane->base,
400			EXYNOS_DISPLAY_TYPE_VIDI, &vidi_crtc_ops, ctx);
401	if (IS_ERR(ctx->crtc)) {
402		DRM_DEV_ERROR(dev, "failed to create crtc.\n");
403		return PTR_ERR(ctx->crtc);
404	}
405
406	drm_simple_encoder_init(drm_dev, encoder, DRM_MODE_ENCODER_TMDS);
407
408	drm_encoder_helper_add(encoder, &exynos_vidi_encoder_helper_funcs);
409
410	ret = exynos_drm_set_possible_crtcs(encoder, EXYNOS_DISPLAY_TYPE_VIDI);
411	if (ret < 0)
412		return ret;
413
414	ret = vidi_create_connector(encoder);
415	if (ret) {
416		DRM_DEV_ERROR(dev, "failed to create connector ret = %d\n",
417			      ret);
418		drm_encoder_cleanup(encoder);
419		return ret;
420	}
421
422	return 0;
423}
424
425
426static void vidi_unbind(struct device *dev, struct device *master, void *data)
427{
428	struct vidi_context *ctx = dev_get_drvdata(dev);
429
430	del_timer_sync(&ctx->timer);
431}
432
433static const struct component_ops vidi_component_ops = {
434	.bind	= vidi_bind,
435	.unbind = vidi_unbind,
436};
437
438static int vidi_probe(struct platform_device *pdev)
439{
440	struct vidi_context *ctx;
441	struct device *dev = &pdev->dev;
442
443	ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
444	if (!ctx)
445		return -ENOMEM;
446
447	ctx->dev = dev;
448
449	timer_setup(&ctx->timer, vidi_fake_vblank_timer, 0);
450
451	mutex_init(&ctx->lock);
452
453	platform_set_drvdata(pdev, ctx);
454
455	return component_add(dev, &vidi_component_ops);
456}
457
458static void vidi_remove(struct platform_device *pdev)
459{
460	struct vidi_context *ctx = platform_get_drvdata(pdev);
461
462	drm_edid_free(ctx->raw_edid);
463	ctx->raw_edid = NULL;
464
465	component_del(&pdev->dev, &vidi_component_ops);
466}
467
468struct platform_driver vidi_driver = {
469	.probe		= vidi_probe,
470	.remove		= vidi_remove,
471	.driver		= {
472		.name	= "exynos-drm-vidi",
473		.dev_groups = vidi_groups,
474	},
475};