blob: f5bbba9ad225263ab72bc78aa696a6193794f1c6 [file] [log] [blame]
Thomas Gleixner2874c5f2019-05-27 08:55:01 +02001// SPDX-License-Identifier: GPL-2.0-or-later
Inki Daeb73d1232012-03-21 10:55:26 +09002/* exynos_drm_vidi.c
3 *
4 * Copyright (C) 2012 Samsung Electronics Co.Ltd
5 * Authors:
6 * Inki Dae <inki.dae@samsung.com>
Inki Daeb73d1232012-03-21 10:55:26 +09007 */
Inki Daeb73d1232012-03-21 10:55:26 +09008
Sam Ravnborg2bda34d72019-06-24 22:06:28 +09009#include <linux/component.h>
Inki Daeb73d1232012-03-21 10:55:26 +090010#include <linux/kernel.h>
Inki Daeb73d1232012-03-21 10:55:26 +090011#include <linux/platform_device.h>
Andrzej Hajda8574e922016-09-23 10:15:23 +020012#include <linux/timer.h>
Inki Daeb73d1232012-03-21 10:55:26 +090013
Gustavo Padovan4ea95262015-06-01 12:04:44 -030014#include <drm/drm_atomic_helper.h>
Daniel Vetterfcd70cd2019-01-17 22:03:34 +010015#include <drm/drm_edid.h>
Ville Syrjälä720cf96d2022-06-14 12:54:49 +030016#include <drm/drm_framebuffer.h>
Daniel Vetterfcd70cd2019-01-17 22:03:34 +010017#include <drm/drm_probe_helper.h>
Thomas Zimmermann3e1fe322020-03-05 16:59:31 +010018#include <drm/drm_simple_kms_helper.h>
Sam Ravnborg2bda34d72019-06-24 22:06:28 +090019#include <drm/drm_vblank.h>
20#include <drm/exynos_drm.h>
Inki Daeb73d1232012-03-21 10:55:26 +090021
Inki Daeb73d1232012-03-21 10:55:26 +090022#include "exynos_drm_crtc.h"
Sam Ravnborg2bda34d72019-06-24 22:06:28 +090023#include "exynos_drm_drv.h"
Marek Szyprowski0488f502015-11-30 14:53:21 +010024#include "exynos_drm_fb.h"
Gustavo Padovan7ee14cd2015-04-03 21:03:40 +090025#include "exynos_drm_plane.h"
Mark Browne30655d2013-08-13 00:46:40 +010026#include "exynos_drm_vidi.h"
Inki Daeb73d1232012-03-21 10:55:26 +090027
Andrzej Hajda8574e922016-09-23 10:15:23 +020028/* VIDI uses fixed refresh rate of 50Hz */
29#define VIDI_REFRESH_TIME (1000 / 50)
30
Inki Daeb73d1232012-03-21 10:55:26 +090031/* vidi has totally three virtual windows. */
32#define WINDOWS_NR 3
33
Sean Paulce6cb552014-01-30 16:38:07 -050034#define ctx_from_connector(c) container_of(c, struct vidi_context, \
35 connector)
Inki Daeb73d1232012-03-21 10:55:26 +090036
Inki Daeb73d1232012-03-21 10:55:26 +090037struct vidi_context {
Gustavo Padovan2b8376c2015-08-15 12:14:08 -030038 struct drm_encoder encoder;
Sean Paul080be03d2014-02-19 21:02:55 +090039 struct drm_device *drm_dev;
Inki Daedf90a642019-04-15 16:35:08 +090040 struct device *dev;
Gustavo Padovan93bca242015-01-18 18:16:23 +090041 struct exynos_drm_crtc *crtc;
Sean Paulce6cb552014-01-30 16:38:07 -050042 struct drm_connector connector;
Gustavo Padovan7ee14cd2015-04-03 21:03:40 +090043 struct exynos_drm_plane planes[WINDOWS_NR];
Inki Daeb73d1232012-03-21 10:55:26 +090044 struct edid *raw_edid;
45 unsigned int clkdiv;
Inki Daeb73d1232012-03-21 10:55:26 +090046 unsigned int connected;
Inki Daeb73d1232012-03-21 10:55:26 +090047 bool suspended;
Andrzej Hajda8574e922016-09-23 10:15:23 +020048 struct timer_list timer;
Inki Daeb73d1232012-03-21 10:55:26 +090049 struct mutex lock;
50};
51
Gustavo Padovan2b8376c2015-08-15 12:14:08 -030052static inline struct vidi_context *encoder_to_vidi(struct drm_encoder *e)
Andrzej Hajda2f26bd72014-11-17 09:54:23 +010053{
Gustavo Padovancf67cc92015-08-11 17:38:06 +090054 return container_of(e, struct vidi_context, encoder);
Andrzej Hajda2f26bd72014-11-17 09:54:23 +010055}
56
Inki Daeb73d1232012-03-21 10:55:26 +090057static 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
Marek Szyprowskifbbb1e12015-08-31 00:53:57 +090082static const uint32_t formats[] = {
83 DRM_FORMAT_XRGB8888,
84 DRM_FORMAT_ARGB8888,
85 DRM_FORMAT_NV12,
86};
87
Marek Szyprowskifd2d2fc2015-11-30 14:53:25 +010088static 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
Gustavo Padovan93bca242015-01-18 18:16:23 +090094static int vidi_enable_vblank(struct exynos_drm_crtc *crtc)
Inki Daeb73d1232012-03-21 10:55:26 +090095{
Gustavo Padovan93bca242015-01-18 18:16:23 +090096 struct vidi_context *ctx = crtc->ctx;
Inki Daeb73d1232012-03-21 10:55:26 +090097
Inki Daeb73d1232012-03-21 10:55:26 +090098 if (ctx->suspended)
99 return -EPERM;
100
Andrzej Hajda8574e922016-09-23 10:15:23 +0200101 mod_timer(&ctx->timer,
102 jiffies + msecs_to_jiffies(VIDI_REFRESH_TIME) - 1);
Inki Dae291257c2012-09-19 11:02:43 +0900103
Inki Daeb73d1232012-03-21 10:55:26 +0900104 return 0;
105}
106
Gustavo Padovan93bca242015-01-18 18:16:23 +0900107static void vidi_disable_vblank(struct exynos_drm_crtc *crtc)
Inki Daeb73d1232012-03-21 10:55:26 +0900108{
Inki Daeb73d1232012-03-21 10:55:26 +0900109}
110
Gustavo Padovan1e1d1392015-08-03 14:39:36 +0900111static void vidi_update_plane(struct exynos_drm_crtc *crtc,
112 struct exynos_drm_plane *plane)
Inki Daeb73d1232012-03-21 10:55:26 +0900113{
Marek Szyprowski0488f502015-11-30 14:53:21 +0100114 struct drm_plane_state *state = plane->base.state;
Gustavo Padovan93bca242015-01-18 18:16:23 +0900115 struct vidi_context *ctx = crtc->ctx;
Marek Szyprowski0488f502015-11-30 14:53:21 +0100116 dma_addr_t addr;
Inki Daeb73d1232012-03-21 10:55:26 +0900117
Inki Daeb73d1232012-03-21 10:55:26 +0900118 if (ctx->suspended)
119 return;
120
Marek Szyprowski0488f502015-11-30 14:53:21 +0100121 addr = exynos_drm_fb_dma_addr(state->fb, 0);
Inki Daedf90a642019-04-15 16:35:08 +0900122 DRM_DEV_DEBUG_KMS(ctx->dev, "dma_addr = %pad\n", &addr);
Inki Daeb73d1232012-03-21 10:55:26 +0900123}
124
Inki Dae11f95482019-12-19 11:07:53 +0900125static void vidi_atomic_enable(struct exynos_drm_crtc *crtc)
Sean Paulaf65c802014-01-30 16:19:27 -0500126{
Gustavo Padovan3cecda02015-06-01 12:04:55 -0300127 struct vidi_context *ctx = crtc->ctx;
Gustavo Padovan7ee14cd2015-04-03 21:03:40 +0900128
Gustavo Padovan3cecda02015-06-01 12:04:55 -0300129 mutex_lock(&ctx->lock);
Sean Paulaf65c802014-01-30 16:19:27 -0500130
Gustavo Padovan3cecda02015-06-01 12:04:55 -0300131 ctx->suspended = false;
Sean Paulaf65c802014-01-30 16:19:27 -0500132
Gustavo Padovan3cecda02015-06-01 12:04:55 -0300133 mutex_unlock(&ctx->lock);
Andrzej Hajda8574e922016-09-23 10:15:23 +0200134
135 drm_crtc_vblank_on(&crtc->base);
Sean Paulaf65c802014-01-30 16:19:27 -0500136}
137
Inki Dae11f95482019-12-19 11:07:53 +0900138static void vidi_atomic_disable(struct exynos_drm_crtc *crtc)
Sean Paulaf65c802014-01-30 16:19:27 -0500139{
Gustavo Padovan93bca242015-01-18 18:16:23 +0900140 struct vidi_context *ctx = crtc->ctx;
Sean Paulaf65c802014-01-30 16:19:27 -0500141
Andrzej Hajda8574e922016-09-23 10:15:23 +0200142 drm_crtc_vblank_off(&crtc->base);
143
Sean Paulaf65c802014-01-30 16:19:27 -0500144 mutex_lock(&ctx->lock);
145
Gustavo Padovan3cecda02015-06-01 12:04:55 -0300146 ctx->suspended = true;
Sean Paulaf65c802014-01-30 16:19:27 -0500147
148 mutex_unlock(&ctx->lock);
149}
150
Krzysztof Kozlowskif3aaf762015-05-07 09:04:45 +0900151static const struct exynos_drm_crtc_ops vidi_crtc_ops = {
Inki Dae11f95482019-12-19 11:07:53 +0900152 .atomic_enable = vidi_atomic_enable,
153 .atomic_disable = vidi_atomic_disable,
Sean Paul1c6244c2014-01-30 16:19:02 -0500154 .enable_vblank = vidi_enable_vblank,
155 .disable_vblank = vidi_disable_vblank,
Gustavo Padovan9cc76102015-08-03 14:38:05 +0900156 .update_plane = vidi_update_plane,
Andrzej Hajdaa3922762017-03-14 09:27:56 +0100157 .atomic_flush = exynos_crtc_handle_event,
Inki Daeb73d1232012-03-21 10:55:26 +0900158};
159
Kees Cooke99e88a2017-10-16 14:43:17 -0700160static void vidi_fake_vblank_timer(struct timer_list *t)
Inki Daeb73d1232012-03-21 10:55:26 +0900161{
Kees Cooke99e88a2017-10-16 14:43:17 -0700162 struct vidi_context *ctx = from_timer(ctx, t, timer);
Inki Daeb73d1232012-03-21 10:55:26 +0900163
Andrzej Hajda8574e922016-09-23 10:15:23 +0200164 if (drm_crtc_handle_vblank(&ctx->crtc->base))
165 mod_timer(&ctx->timer,
166 jiffies + msecs_to_jiffies(VIDI_REFRESH_TIME) - 1);
Inki Daeb73d1232012-03-21 10:55:26 +0900167}
168
Marek Szyprowskic5f2f0c2016-02-03 13:42:47 +0100169static ssize_t vidi_show_connection(struct device *dev,
Inki Daeb73d1232012-03-21 10:55:26 +0900170 struct device_attribute *attr, char *buf)
171{
Andrzej Hajdaf01833c2014-11-17 09:54:16 +0100172 struct vidi_context *ctx = dev_get_drvdata(dev);
Inki Daeb73d1232012-03-21 10:55:26 +0900173 int rc;
Inki Daeb73d1232012-03-21 10:55:26 +0900174
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
Marek Szyprowskic5f2f0c2016-02-03 13:42:47 +0100184static ssize_t vidi_store_connection(struct device *dev,
Inki Daeb73d1232012-03-21 10:55:26 +0900185 struct device_attribute *attr,
186 const char *buf, size_t len)
187{
Andrzej Hajdaf01833c2014-11-17 09:54:16 +0100188 struct vidi_context *ctx = dev_get_drvdata(dev);
Inki Daeb73d1232012-03-21 10:55:26 +0900189 int ret;
190
Inki Daeb73d1232012-03-21 10:55:26 +0900191 ret = kstrtoint(buf, 0, &ctx->connected);
192 if (ret)
193 return ret;
194
195 if (ctx->connected > 1)
196 return -EINVAL;
197
Inki Daed07d39d2012-06-27 16:00:56 +0900198 /* use fake edid data for test. */
199 if (!ctx->raw_edid)
200 ctx->raw_edid = (struct edid *)fake_edid_info;
201
Inki Daed7b84782012-06-27 16:16:26 +0900202 /* 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) {
Inki Dae6be90052019-04-15 16:25:12 +0900204 DRM_DEV_DEBUG_KMS(dev, "edid data is not fake data.\n");
Inki Daed7b84782012-06-27 16:16:26 +0900205 return -EINVAL;
206 }
207
Inki Dae6be90052019-04-15 16:25:12 +0900208 DRM_DEV_DEBUG_KMS(dev, "requested connection.\n");
Inki Daeb73d1232012-03-21 10:55:26 +0900209
Sean Paul080be03d2014-02-19 21:02:55 +0900210 drm_helper_hpd_irq_event(ctx->drm_dev);
Inki Daeb73d1232012-03-21 10:55:26 +0900211
212 return len;
213}
214
215static DEVICE_ATTR(connection, 0644, vidi_show_connection,
216 vidi_store_connection);
217
Emil Velikovf84e1ba2020-05-17 20:36:55 +0100218static struct attribute *vidi_attrs[] = {
219 &dev_attr_connection.attr,
220 NULL,
221};
222ATTRIBUTE_GROUPS(vidi);
223
Inki Daeb73d1232012-03-21 10:55:26 +0900224int vidi_connection_ioctl(struct drm_device *drm_dev, void *data,
225 struct drm_file *file_priv)
226{
Gustavo Padovancf67cc92015-08-11 17:38:06 +0900227 struct vidi_context *ctx = dev_get_drvdata(drm_dev->dev);
Inki Daeb73d1232012-03-21 10:55:26 +0900228 struct drm_exynos_vidi_connection *vidi = data;
229
Inki Daeb73d1232012-03-21 10:55:26 +0900230 if (!vidi) {
Inki Daedf90a642019-04-15 16:35:08 +0900231 DRM_DEV_DEBUG_KMS(ctx->dev,
Inki Dae6be90052019-04-15 16:25:12 +0900232 "user data for vidi is null.\n");
Inki Daeb73d1232012-03-21 10:55:26 +0900233 return -EINVAL;
234 }
235
Inki Daeb73d1232012-03-21 10:55:26 +0900236 if (vidi->connection > 1) {
Inki Daedf90a642019-04-15 16:35:08 +0900237 DRM_DEV_DEBUG_KMS(ctx->dev,
Inki Dae6be90052019-04-15 16:25:12 +0900238 "connection should be 0 or 1.\n");
Inki Daeb73d1232012-03-21 10:55:26 +0900239 return -EINVAL;
240 }
241
Inki Daeb73d1232012-03-21 10:55:26 +0900242 if (ctx->connected == vidi->connection) {
Inki Daedf90a642019-04-15 16:35:08 +0900243 DRM_DEV_DEBUG_KMS(ctx->dev,
Inki Dae6be90052019-04-15 16:25:12 +0900244 "same connection request.\n");
Inki Daeb73d1232012-03-21 10:55:26 +0900245 return -EINVAL;
246 }
247
Inki Daed3b62db2012-06-27 16:36:12 +0900248 if (vidi->connection) {
Marek Szyprowskic5f2f0c2016-02-03 13:42:47 +0100249 struct edid *raw_edid;
250
251 raw_edid = (struct edid *)(unsigned long)vidi->edid;
Seung-Woo Kime7808df2013-01-10 19:35:06 +0900252 if (!drm_edid_is_valid(raw_edid)) {
Inki Daedf90a642019-04-15 16:35:08 +0900253 DRM_DEV_DEBUG_KMS(ctx->dev,
Inki Dae6be90052019-04-15 16:25:12 +0900254 "edid data is invalid.\n");
Inki Daed3b62db2012-06-27 16:36:12 +0900255 return -EINVAL;
256 }
Jani Nikula4ddc7732013-09-27 15:08:29 +0300257 ctx->raw_edid = drm_edid_duplicate(raw_edid);
Inki Daed3b62db2012-06-27 16:36:12 +0900258 if (!ctx->raw_edid) {
Inki Daedf90a642019-04-15 16:35:08 +0900259 DRM_DEV_DEBUG_KMS(ctx->dev,
Inki Dae6be90052019-04-15 16:25:12 +0900260 "failed to allocate raw_edid.\n");
Inki Daed3b62db2012-06-27 16:36:12 +0900261 return -ENOMEM;
262 }
Inki Daed3b62db2012-06-27 16:36:12 +0900263 } 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 }
Inki Daeb73d1232012-03-21 10:55:26 +0900274
275 ctx->connected = vidi->connection;
Sean Paul080be03d2014-02-19 21:02:55 +0900276 drm_helper_hpd_irq_event(ctx->drm_dev);
Inki Daeb73d1232012-03-21 10:55:26 +0900277
278 return 0;
279}
280
Sean Paulce6cb552014-01-30 16:38:07 -0500281static 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
294static void vidi_connector_destroy(struct drm_connector *connector)
295{
296}
297
Ville Syrjälä800ba2b2015-12-15 12:21:06 +0100298static const struct drm_connector_funcs vidi_connector_funcs = {
Sean Paulce6cb552014-01-30 16:38:07 -0500299 .fill_modes = drm_helper_probe_single_connector_modes,
300 .detect = vidi_detect,
301 .destroy = vidi_connector_destroy,
Gustavo Padovan4ea95262015-06-01 12:04:44 -0300302 .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,
Sean Paulce6cb552014-01-30 16:38:07 -0500305};
306
307static 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) {
Inki Daedf90a642019-04-15 16:35:08 +0900318 DRM_DEV_DEBUG_KMS(ctx->dev, "raw_edid is null.\n");
Jani Nikula13d5b042024-03-08 18:03:41 +0200319 return 0;
Sean Paulce6cb552014-01-30 16:38:07 -0500320 }
321
322 edid_len = (1 + ctx->raw_edid->extensions) * EDID_LENGTH;
323 edid = kmemdup(ctx->raw_edid, edid_len, GFP_KERNEL);
324 if (!edid) {
Inki Daedf90a642019-04-15 16:35:08 +0900325 DRM_DEV_DEBUG_KMS(ctx->dev, "failed to allocate edid\n");
Jani Nikula13d5b042024-03-08 18:03:41 +0200326 return 0;
Sean Paulce6cb552014-01-30 16:38:07 -0500327 }
328
Daniel Vetterc555f022018-07-09 10:40:06 +0200329 drm_connector_update_edid_property(connector, edid);
Sean Paulce6cb552014-01-30 16:38:07 -0500330
331 return drm_add_edid_modes(connector, edid);
332}
333
Ville Syrjälä800ba2b2015-12-15 12:21:06 +0100334static const struct drm_connector_helper_funcs vidi_connector_helper_funcs = {
Sean Paulce6cb552014-01-30 16:38:07 -0500335 .get_modes = vidi_get_modes,
Sean Paulce6cb552014-01-30 16:38:07 -0500336};
337
Gustavo Padovan2b8376c2015-08-15 12:14:08 -0300338static int vidi_create_connector(struct drm_encoder *encoder)
Sean Paulce6cb552014-01-30 16:38:07 -0500339{
Gustavo Padovan2b8376c2015-08-15 12:14:08 -0300340 struct vidi_context *ctx = encoder_to_vidi(encoder);
Sean Paulce6cb552014-01-30 16:38:07 -0500341 struct drm_connector *connector = &ctx->connector;
342 int ret;
343
Sean Paulce6cb552014-01-30 16:38:07 -0500344 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) {
Inki Daedf90a642019-04-15 16:35:08 +0900349 DRM_DEV_ERROR(ctx->dev,
Inki Dae6f83d202019-04-15 14:24:36 +0900350 "Failed to initialize connector with drm\n");
Sean Paulce6cb552014-01-30 16:38:07 -0500351 return ret;
352 }
353
354 drm_connector_helper_add(connector, &vidi_connector_helper_funcs);
Daniel Vettercde4c442018-07-09 10:40:07 +0200355 drm_connector_attach_encoder(connector, encoder);
Sean Paulce6cb552014-01-30 16:38:07 -0500356
357 return 0;
358}
359
Gustavo Padovan2b8376c2015-08-15 12:14:08 -0300360static 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
366static void exynos_vidi_enable(struct drm_encoder *encoder)
367{
368}
369
370static void exynos_vidi_disable(struct drm_encoder *encoder)
371{
372}
373
Ville Syrjälä800ba2b2015-12-15 12:21:06 +0100374static const struct drm_encoder_helper_funcs exynos_vidi_encoder_helper_funcs = {
Gustavo Padovan2b8376c2015-08-15 12:14:08 -0300375 .mode_set = exynos_vidi_mode_set,
376 .enable = exynos_vidi_enable,
377 .disable = exynos_vidi_disable,
378};
379
Inki Dae1d50aa9c2014-11-24 14:55:41 +0900380static int vidi_bind(struct device *dev, struct device *master, void *data)
Inki Daef37cd5e2014-05-09 14:25:20 +0900381{
Andrzej Hajdaf01833c2014-11-17 09:54:16 +0100382 struct vidi_context *ctx = dev_get_drvdata(dev);
Inki Dae1d50aa9c2014-11-24 14:55:41 +0900383 struct drm_device *drm_dev = data;
Gustavo Padovan2b8376c2015-08-15 12:14:08 -0300384 struct drm_encoder *encoder = &ctx->encoder;
Gustavo Padovan7ee14cd2015-04-03 21:03:40 +0900385 struct exynos_drm_plane *exynos_plane;
Marek Szyprowskifd2d2fc2015-11-30 14:53:25 +0100386 struct exynos_drm_plane_config plane_config = { 0 };
387 unsigned int i;
Andrzej Hajda1ca582f2017-08-24 15:33:51 +0200388 int ret;
Inki Daef37cd5e2014-05-09 14:25:20 +0900389
Andrzej Hajda29493902017-03-15 15:41:06 +0100390 ctx->drm_dev = drm_dev;
Joonyoung Shim0f04cf82015-01-30 16:43:01 +0900391
Marek Szyprowskifd2d2fc2015-11-30 14:53:25 +0100392 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
Marek Szyprowski40bdfb02015-12-16 13:21:42 +0100399 ret = exynos_plane_init(drm_dev, &ctx->planes[i], i,
Andrzej Hajda2c826072017-03-15 15:41:05 +0100400 &plane_config);
Gustavo Padovan7ee14cd2015-04-03 21:03:40 +0900401 if (ret)
402 return ret;
403 }
404
Gustavo Padovan5d3d0992015-10-12 22:07:48 +0900405 exynos_plane = &ctx->planes[DEFAULT_WIN];
Gustavo Padovan7ee14cd2015-04-03 21:03:40 +0900406 ctx->crtc = exynos_drm_crtc_create(drm_dev, &exynos_plane->base,
Andrzej Hajdad6449512017-05-29 10:05:25 +0900407 EXYNOS_DISPLAY_TYPE_VIDI, &vidi_crtc_ops, ctx);
Gustavo Padovan93bca242015-01-18 18:16:23 +0900408 if (IS_ERR(ctx->crtc)) {
Inki Dae6f83d202019-04-15 14:24:36 +0900409 DRM_DEV_ERROR(dev, "failed to create crtc.\n");
Gustavo Padovan93bca242015-01-18 18:16:23 +0900410 return PTR_ERR(ctx->crtc);
Inki Daef37cd5e2014-05-09 14:25:20 +0900411 }
412
Thomas Zimmermann3e1fe322020-03-05 16:59:31 +0100413 drm_simple_encoder_init(drm_dev, encoder, DRM_MODE_ENCODER_TMDS);
Gustavo Padovan2b8376c2015-08-15 12:14:08 -0300414
415 drm_encoder_helper_add(encoder, &exynos_vidi_encoder_helper_funcs);
416
Andrzej Hajda1ca582f2017-08-24 15:33:51 +0200417 ret = exynos_drm_set_possible_crtcs(encoder, EXYNOS_DISPLAY_TYPE_VIDI);
418 if (ret < 0)
419 return ret;
420
Gustavo Padovan2b8376c2015-08-15 12:14:08 -0300421 ret = vidi_create_connector(encoder);
Gustavo Padovana2986e82015-08-05 20:24:20 -0300422 if (ret) {
Inki Dae6f83d202019-04-15 14:24:36 +0900423 DRM_DEV_ERROR(dev, "failed to create connector ret = %d\n",
424 ret);
Gustavo Padovan2b8376c2015-08-15 12:14:08 -0300425 drm_encoder_cleanup(encoder);
Inki Daef37cd5e2014-05-09 14:25:20 +0900426 return ret;
427 }
428
429 return 0;
430}
431
Inki Dae1d50aa9c2014-11-24 14:55:41 +0900432
433static void vidi_unbind(struct device *dev, struct device *master, void *data)
434{
Andrzej Hajda8574e922016-09-23 10:15:23 +0200435 struct vidi_context *ctx = dev_get_drvdata(dev);
436
437 del_timer_sync(&ctx->timer);
Inki Dae1d50aa9c2014-11-24 14:55:41 +0900438}
439
440static const struct component_ops vidi_component_ops = {
441 .bind = vidi_bind,
442 .unbind = vidi_unbind,
443};
444
Greg Kroah-Hartman56550d92012-12-21 15:09:25 -0800445static int vidi_probe(struct platform_device *pdev)
Inki Daeb73d1232012-03-21 10:55:26 +0900446{
Inki Daeb73d1232012-03-21 10:55:26 +0900447 struct vidi_context *ctx;
Inki Daedf90a642019-04-15 16:35:08 +0900448 struct device *dev = &pdev->dev;
Inki Daeb73d1232012-03-21 10:55:26 +0900449
Inki Daedf90a642019-04-15 16:35:08 +0900450 ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
Inki Daeb73d1232012-03-21 10:55:26 +0900451 if (!ctx)
452 return -ENOMEM;
453
Inki Daedf90a642019-04-15 16:35:08 +0900454 ctx->dev = dev;
Inki Dae1d50aa9c2014-11-24 14:55:41 +0900455
Kees Cooke99e88a2017-10-16 14:43:17 -0700456 timer_setup(&ctx->timer, vidi_fake_vblank_timer, 0);
Inki Daeb73d1232012-03-21 10:55:26 +0900457
Inki Daeb73d1232012-03-21 10:55:26 +0900458 mutex_init(&ctx->lock);
459
Andrzej Hajdaf01833c2014-11-17 09:54:16 +0100460 platform_set_drvdata(pdev, ctx);
Inki Daeb73d1232012-03-21 10:55:26 +0900461
Emil Velikovf84e1ba2020-05-17 20:36:55 +0100462 return component_add(dev, &vidi_component_ops);
Inki Daeb73d1232012-03-21 10:55:26 +0900463}
464
Uwe Kleine-König4fe7a1e2023-11-08 13:09:12 +0900465static void vidi_remove(struct platform_device *pdev)
Inki Daeb73d1232012-03-21 10:55:26 +0900466{
Andrzej Hajdaf01833c2014-11-17 09:54:16 +0100467 struct vidi_context *ctx = platform_get_drvdata(pdev);
Inki Daeb73d1232012-03-21 10:55:26 +0900468
Inki Daed3b62db2012-06-27 16:36:12 +0900469 if (ctx->raw_edid != (struct edid *)fake_edid_info) {
470 kfree(ctx->raw_edid);
471 ctx->raw_edid = NULL;
472 }
473
Inki Dae1d50aa9c2014-11-24 14:55:41 +0900474 component_del(&pdev->dev, &vidi_component_ops);
Inki Daeb73d1232012-03-21 10:55:26 +0900475}
476
Inki Daeb73d1232012-03-21 10:55:26 +0900477struct platform_driver vidi_driver = {
478 .probe = vidi_probe,
Uwe Kleine-König4fe7a1e2023-11-08 13:09:12 +0900479 .remove_new = vidi_remove,
Inki Daeb73d1232012-03-21 10:55:26 +0900480 .driver = {
481 .name = "exynos-drm-vidi",
482 .owner = THIS_MODULE,
Emil Velikovf84e1ba2020-05-17 20:36:55 +0100483 .dev_groups = vidi_groups,
Inki Daeb73d1232012-03-21 10:55:26 +0900484 },
485};