Thomas Gleixner | 2874c5f | 2019-05-27 08:55:01 +0200 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 2 | /* exynos_drm_vidi.c |
| 3 | * |
| 4 | * Copyright (C) 2012 Samsung Electronics Co.Ltd |
| 5 | * Authors: |
| 6 | * Inki Dae <inki.dae@samsung.com> |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 7 | */ |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 8 | |
Sam Ravnborg | 2bda34d7 | 2019-06-24 22:06:28 +0900 | [diff] [blame] | 9 | #include <linux/component.h> |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 10 | #include <linux/kernel.h> |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 11 | #include <linux/platform_device.h> |
Andrzej Hajda | 8574e92 | 2016-09-23 10:15:23 +0200 | [diff] [blame] | 12 | #include <linux/timer.h> |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 13 | |
Gustavo Padovan | 4ea9526 | 2015-06-01 12:04:44 -0300 | [diff] [blame] | 14 | #include <drm/drm_atomic_helper.h> |
Daniel Vetter | fcd70cd | 2019-01-17 22:03:34 +0100 | [diff] [blame] | 15 | #include <drm/drm_edid.h> |
Ville Syrjälä | 720cf96d | 2022-06-14 12:54:49 +0300 | [diff] [blame] | 16 | #include <drm/drm_framebuffer.h> |
Daniel Vetter | fcd70cd | 2019-01-17 22:03:34 +0100 | [diff] [blame] | 17 | #include <drm/drm_probe_helper.h> |
Thomas Zimmermann | 3e1fe32 | 2020-03-05 16:59:31 +0100 | [diff] [blame] | 18 | #include <drm/drm_simple_kms_helper.h> |
Sam Ravnborg | 2bda34d7 | 2019-06-24 22:06:28 +0900 | [diff] [blame] | 19 | #include <drm/drm_vblank.h> |
| 20 | #include <drm/exynos_drm.h> |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 21 | |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 22 | #include "exynos_drm_crtc.h" |
Sam Ravnborg | 2bda34d7 | 2019-06-24 22:06:28 +0900 | [diff] [blame] | 23 | #include "exynos_drm_drv.h" |
Marek Szyprowski | 0488f50 | 2015-11-30 14:53:21 +0100 | [diff] [blame] | 24 | #include "exynos_drm_fb.h" |
Gustavo Padovan | 7ee14cd | 2015-04-03 21:03:40 +0900 | [diff] [blame] | 25 | #include "exynos_drm_plane.h" |
Mark Brown | e30655d | 2013-08-13 00:46:40 +0100 | [diff] [blame] | 26 | #include "exynos_drm_vidi.h" |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 27 | |
Andrzej Hajda | 8574e92 | 2016-09-23 10:15:23 +0200 | [diff] [blame] | 28 | /* VIDI uses fixed refresh rate of 50Hz */ |
| 29 | #define VIDI_REFRESH_TIME (1000 / 50) |
| 30 | |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 31 | /* vidi has totally three virtual windows. */ |
| 32 | #define WINDOWS_NR 3 |
| 33 | |
Sean Paul | ce6cb55 | 2014-01-30 16:38:07 -0500 | [diff] [blame] | 34 | #define ctx_from_connector(c) container_of(c, struct vidi_context, \ |
| 35 | connector) |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 36 | |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 37 | struct vidi_context { |
Gustavo Padovan | 2b8376c | 2015-08-15 12:14:08 -0300 | [diff] [blame] | 38 | struct drm_encoder encoder; |
Sean Paul | 080be03d | 2014-02-19 21:02:55 +0900 | [diff] [blame] | 39 | struct drm_device *drm_dev; |
Inki Dae | df90a64 | 2019-04-15 16:35:08 +0900 | [diff] [blame] | 40 | struct device *dev; |
Gustavo Padovan | 93bca24 | 2015-01-18 18:16:23 +0900 | [diff] [blame] | 41 | struct exynos_drm_crtc *crtc; |
Sean Paul | ce6cb55 | 2014-01-30 16:38:07 -0500 | [diff] [blame] | 42 | struct drm_connector connector; |
Gustavo Padovan | 7ee14cd | 2015-04-03 21:03:40 +0900 | [diff] [blame] | 43 | struct exynos_drm_plane planes[WINDOWS_NR]; |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 44 | struct edid *raw_edid; |
| 45 | unsigned int clkdiv; |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 46 | unsigned int connected; |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 47 | bool suspended; |
Andrzej Hajda | 8574e92 | 2016-09-23 10:15:23 +0200 | [diff] [blame] | 48 | struct timer_list timer; |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 49 | struct mutex lock; |
| 50 | }; |
| 51 | |
Gustavo Padovan | 2b8376c | 2015-08-15 12:14:08 -0300 | [diff] [blame] | 52 | static inline struct vidi_context *encoder_to_vidi(struct drm_encoder *e) |
Andrzej Hajda | 2f26bd7 | 2014-11-17 09:54:23 +0100 | [diff] [blame] | 53 | { |
Gustavo Padovan | cf67cc9 | 2015-08-11 17:38:06 +0900 | [diff] [blame] | 54 | return container_of(e, struct vidi_context, encoder); |
Andrzej Hajda | 2f26bd7 | 2014-11-17 09:54:23 +0100 | [diff] [blame] | 55 | } |
| 56 | |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 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 | |
Marek Szyprowski | fbbb1e1 | 2015-08-31 00:53:57 +0900 | [diff] [blame] | 82 | static const uint32_t formats[] = { |
| 83 | DRM_FORMAT_XRGB8888, |
| 84 | DRM_FORMAT_ARGB8888, |
| 85 | DRM_FORMAT_NV12, |
| 86 | }; |
| 87 | |
Marek Szyprowski | fd2d2fc | 2015-11-30 14:53:25 +0100 | [diff] [blame] | 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 | |
Gustavo Padovan | 93bca24 | 2015-01-18 18:16:23 +0900 | [diff] [blame] | 94 | static int vidi_enable_vblank(struct exynos_drm_crtc *crtc) |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 95 | { |
Gustavo Padovan | 93bca24 | 2015-01-18 18:16:23 +0900 | [diff] [blame] | 96 | struct vidi_context *ctx = crtc->ctx; |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 97 | |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 98 | if (ctx->suspended) |
| 99 | return -EPERM; |
| 100 | |
Andrzej Hajda | 8574e92 | 2016-09-23 10:15:23 +0200 | [diff] [blame] | 101 | mod_timer(&ctx->timer, |
| 102 | jiffies + msecs_to_jiffies(VIDI_REFRESH_TIME) - 1); |
Inki Dae | 291257c | 2012-09-19 11:02:43 +0900 | [diff] [blame] | 103 | |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 104 | return 0; |
| 105 | } |
| 106 | |
Gustavo Padovan | 93bca24 | 2015-01-18 18:16:23 +0900 | [diff] [blame] | 107 | static void vidi_disable_vblank(struct exynos_drm_crtc *crtc) |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 108 | { |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 109 | } |
| 110 | |
Gustavo Padovan | 1e1d139 | 2015-08-03 14:39:36 +0900 | [diff] [blame] | 111 | static void vidi_update_plane(struct exynos_drm_crtc *crtc, |
| 112 | struct exynos_drm_plane *plane) |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 113 | { |
Marek Szyprowski | 0488f50 | 2015-11-30 14:53:21 +0100 | [diff] [blame] | 114 | struct drm_plane_state *state = plane->base.state; |
Gustavo Padovan | 93bca24 | 2015-01-18 18:16:23 +0900 | [diff] [blame] | 115 | struct vidi_context *ctx = crtc->ctx; |
Marek Szyprowski | 0488f50 | 2015-11-30 14:53:21 +0100 | [diff] [blame] | 116 | dma_addr_t addr; |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 117 | |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 118 | if (ctx->suspended) |
| 119 | return; |
| 120 | |
Marek Szyprowski | 0488f50 | 2015-11-30 14:53:21 +0100 | [diff] [blame] | 121 | addr = exynos_drm_fb_dma_addr(state->fb, 0); |
Inki Dae | df90a64 | 2019-04-15 16:35:08 +0900 | [diff] [blame] | 122 | DRM_DEV_DEBUG_KMS(ctx->dev, "dma_addr = %pad\n", &addr); |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 123 | } |
| 124 | |
Inki Dae | 11f9548 | 2019-12-19 11:07:53 +0900 | [diff] [blame] | 125 | static void vidi_atomic_enable(struct exynos_drm_crtc *crtc) |
Sean Paul | af65c80 | 2014-01-30 16:19:27 -0500 | [diff] [blame] | 126 | { |
Gustavo Padovan | 3cecda0 | 2015-06-01 12:04:55 -0300 | [diff] [blame] | 127 | struct vidi_context *ctx = crtc->ctx; |
Gustavo Padovan | 7ee14cd | 2015-04-03 21:03:40 +0900 | [diff] [blame] | 128 | |
Gustavo Padovan | 3cecda0 | 2015-06-01 12:04:55 -0300 | [diff] [blame] | 129 | mutex_lock(&ctx->lock); |
Sean Paul | af65c80 | 2014-01-30 16:19:27 -0500 | [diff] [blame] | 130 | |
Gustavo Padovan | 3cecda0 | 2015-06-01 12:04:55 -0300 | [diff] [blame] | 131 | ctx->suspended = false; |
Sean Paul | af65c80 | 2014-01-30 16:19:27 -0500 | [diff] [blame] | 132 | |
Gustavo Padovan | 3cecda0 | 2015-06-01 12:04:55 -0300 | [diff] [blame] | 133 | mutex_unlock(&ctx->lock); |
Andrzej Hajda | 8574e92 | 2016-09-23 10:15:23 +0200 | [diff] [blame] | 134 | |
| 135 | drm_crtc_vblank_on(&crtc->base); |
Sean Paul | af65c80 | 2014-01-30 16:19:27 -0500 | [diff] [blame] | 136 | } |
| 137 | |
Inki Dae | 11f9548 | 2019-12-19 11:07:53 +0900 | [diff] [blame] | 138 | static void vidi_atomic_disable(struct exynos_drm_crtc *crtc) |
Sean Paul | af65c80 | 2014-01-30 16:19:27 -0500 | [diff] [blame] | 139 | { |
Gustavo Padovan | 93bca24 | 2015-01-18 18:16:23 +0900 | [diff] [blame] | 140 | struct vidi_context *ctx = crtc->ctx; |
Sean Paul | af65c80 | 2014-01-30 16:19:27 -0500 | [diff] [blame] | 141 | |
Andrzej Hajda | 8574e92 | 2016-09-23 10:15:23 +0200 | [diff] [blame] | 142 | drm_crtc_vblank_off(&crtc->base); |
| 143 | |
Sean Paul | af65c80 | 2014-01-30 16:19:27 -0500 | [diff] [blame] | 144 | mutex_lock(&ctx->lock); |
| 145 | |
Gustavo Padovan | 3cecda0 | 2015-06-01 12:04:55 -0300 | [diff] [blame] | 146 | ctx->suspended = true; |
Sean Paul | af65c80 | 2014-01-30 16:19:27 -0500 | [diff] [blame] | 147 | |
| 148 | mutex_unlock(&ctx->lock); |
| 149 | } |
| 150 | |
Krzysztof Kozlowski | f3aaf76 | 2015-05-07 09:04:45 +0900 | [diff] [blame] | 151 | static const struct exynos_drm_crtc_ops vidi_crtc_ops = { |
Inki Dae | 11f9548 | 2019-12-19 11:07:53 +0900 | [diff] [blame] | 152 | .atomic_enable = vidi_atomic_enable, |
| 153 | .atomic_disable = vidi_atomic_disable, |
Sean Paul | 1c6244c | 2014-01-30 16:19:02 -0500 | [diff] [blame] | 154 | .enable_vblank = vidi_enable_vblank, |
| 155 | .disable_vblank = vidi_disable_vblank, |
Gustavo Padovan | 9cc7610 | 2015-08-03 14:38:05 +0900 | [diff] [blame] | 156 | .update_plane = vidi_update_plane, |
Andrzej Hajda | a392276 | 2017-03-14 09:27:56 +0100 | [diff] [blame] | 157 | .atomic_flush = exynos_crtc_handle_event, |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 158 | }; |
| 159 | |
Kees Cook | e99e88a | 2017-10-16 14:43:17 -0700 | [diff] [blame] | 160 | static void vidi_fake_vblank_timer(struct timer_list *t) |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 161 | { |
Kees Cook | e99e88a | 2017-10-16 14:43:17 -0700 | [diff] [blame] | 162 | struct vidi_context *ctx = from_timer(ctx, t, timer); |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 163 | |
Andrzej Hajda | 8574e92 | 2016-09-23 10:15:23 +0200 | [diff] [blame] | 164 | if (drm_crtc_handle_vblank(&ctx->crtc->base)) |
| 165 | mod_timer(&ctx->timer, |
| 166 | jiffies + msecs_to_jiffies(VIDI_REFRESH_TIME) - 1); |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 167 | } |
| 168 | |
Marek Szyprowski | c5f2f0c | 2016-02-03 13:42:47 +0100 | [diff] [blame] | 169 | static ssize_t vidi_show_connection(struct device *dev, |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 170 | struct device_attribute *attr, char *buf) |
| 171 | { |
Andrzej Hajda | f01833c | 2014-11-17 09:54:16 +0100 | [diff] [blame] | 172 | struct vidi_context *ctx = dev_get_drvdata(dev); |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 173 | int rc; |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 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 | |
Marek Szyprowski | c5f2f0c | 2016-02-03 13:42:47 +0100 | [diff] [blame] | 184 | static ssize_t vidi_store_connection(struct device *dev, |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 185 | struct device_attribute *attr, |
| 186 | const char *buf, size_t len) |
| 187 | { |
Andrzej Hajda | f01833c | 2014-11-17 09:54:16 +0100 | [diff] [blame] | 188 | struct vidi_context *ctx = dev_get_drvdata(dev); |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 189 | int ret; |
| 190 | |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 191 | ret = kstrtoint(buf, 0, &ctx->connected); |
| 192 | if (ret) |
| 193 | return ret; |
| 194 | |
| 195 | if (ctx->connected > 1) |
| 196 | return -EINVAL; |
| 197 | |
Inki Dae | d07d39d | 2012-06-27 16:00:56 +0900 | [diff] [blame] | 198 | /* use fake edid data for test. */ |
| 199 | if (!ctx->raw_edid) |
| 200 | ctx->raw_edid = (struct edid *)fake_edid_info; |
| 201 | |
Inki Dae | d7b8478 | 2012-06-27 16:16:26 +0900 | [diff] [blame] | 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) { |
Inki Dae | 6be9005 | 2019-04-15 16:25:12 +0900 | [diff] [blame] | 204 | DRM_DEV_DEBUG_KMS(dev, "edid data is not fake data.\n"); |
Inki Dae | d7b8478 | 2012-06-27 16:16:26 +0900 | [diff] [blame] | 205 | return -EINVAL; |
| 206 | } |
| 207 | |
Inki Dae | 6be9005 | 2019-04-15 16:25:12 +0900 | [diff] [blame] | 208 | DRM_DEV_DEBUG_KMS(dev, "requested connection.\n"); |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 209 | |
Sean Paul | 080be03d | 2014-02-19 21:02:55 +0900 | [diff] [blame] | 210 | drm_helper_hpd_irq_event(ctx->drm_dev); |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 211 | |
| 212 | return len; |
| 213 | } |
| 214 | |
| 215 | static DEVICE_ATTR(connection, 0644, vidi_show_connection, |
| 216 | vidi_store_connection); |
| 217 | |
Emil Velikov | f84e1ba | 2020-05-17 20:36:55 +0100 | [diff] [blame] | 218 | static struct attribute *vidi_attrs[] = { |
| 219 | &dev_attr_connection.attr, |
| 220 | NULL, |
| 221 | }; |
| 222 | ATTRIBUTE_GROUPS(vidi); |
| 223 | |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 224 | int vidi_connection_ioctl(struct drm_device *drm_dev, void *data, |
| 225 | struct drm_file *file_priv) |
| 226 | { |
Gustavo Padovan | cf67cc9 | 2015-08-11 17:38:06 +0900 | [diff] [blame] | 227 | struct vidi_context *ctx = dev_get_drvdata(drm_dev->dev); |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 228 | struct drm_exynos_vidi_connection *vidi = data; |
| 229 | |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 230 | if (!vidi) { |
Inki Dae | df90a64 | 2019-04-15 16:35:08 +0900 | [diff] [blame] | 231 | DRM_DEV_DEBUG_KMS(ctx->dev, |
Inki Dae | 6be9005 | 2019-04-15 16:25:12 +0900 | [diff] [blame] | 232 | "user data for vidi is null.\n"); |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 233 | return -EINVAL; |
| 234 | } |
| 235 | |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 236 | if (vidi->connection > 1) { |
Inki Dae | df90a64 | 2019-04-15 16:35:08 +0900 | [diff] [blame] | 237 | DRM_DEV_DEBUG_KMS(ctx->dev, |
Inki Dae | 6be9005 | 2019-04-15 16:25:12 +0900 | [diff] [blame] | 238 | "connection should be 0 or 1.\n"); |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 239 | return -EINVAL; |
| 240 | } |
| 241 | |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 242 | if (ctx->connected == vidi->connection) { |
Inki Dae | df90a64 | 2019-04-15 16:35:08 +0900 | [diff] [blame] | 243 | DRM_DEV_DEBUG_KMS(ctx->dev, |
Inki Dae | 6be9005 | 2019-04-15 16:25:12 +0900 | [diff] [blame] | 244 | "same connection request.\n"); |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 245 | return -EINVAL; |
| 246 | } |
| 247 | |
Inki Dae | d3b62db | 2012-06-27 16:36:12 +0900 | [diff] [blame] | 248 | if (vidi->connection) { |
Marek Szyprowski | c5f2f0c | 2016-02-03 13:42:47 +0100 | [diff] [blame] | 249 | struct edid *raw_edid; |
| 250 | |
| 251 | raw_edid = (struct edid *)(unsigned long)vidi->edid; |
Seung-Woo Kim | e7808df | 2013-01-10 19:35:06 +0900 | [diff] [blame] | 252 | if (!drm_edid_is_valid(raw_edid)) { |
Inki Dae | df90a64 | 2019-04-15 16:35:08 +0900 | [diff] [blame] | 253 | DRM_DEV_DEBUG_KMS(ctx->dev, |
Inki Dae | 6be9005 | 2019-04-15 16:25:12 +0900 | [diff] [blame] | 254 | "edid data is invalid.\n"); |
Inki Dae | d3b62db | 2012-06-27 16:36:12 +0900 | [diff] [blame] | 255 | return -EINVAL; |
| 256 | } |
Jani Nikula | 4ddc773 | 2013-09-27 15:08:29 +0300 | [diff] [blame] | 257 | ctx->raw_edid = drm_edid_duplicate(raw_edid); |
Inki Dae | d3b62db | 2012-06-27 16:36:12 +0900 | [diff] [blame] | 258 | if (!ctx->raw_edid) { |
Inki Dae | df90a64 | 2019-04-15 16:35:08 +0900 | [diff] [blame] | 259 | DRM_DEV_DEBUG_KMS(ctx->dev, |
Inki Dae | 6be9005 | 2019-04-15 16:25:12 +0900 | [diff] [blame] | 260 | "failed to allocate raw_edid.\n"); |
Inki Dae | d3b62db | 2012-06-27 16:36:12 +0900 | [diff] [blame] | 261 | return -ENOMEM; |
| 262 | } |
Inki Dae | d3b62db | 2012-06-27 16:36:12 +0900 | [diff] [blame] | 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 | } |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 274 | |
| 275 | ctx->connected = vidi->connection; |
Sean Paul | 080be03d | 2014-02-19 21:02:55 +0900 | [diff] [blame] | 276 | drm_helper_hpd_irq_event(ctx->drm_dev); |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 277 | |
| 278 | return 0; |
| 279 | } |
| 280 | |
Sean Paul | ce6cb55 | 2014-01-30 16:38:07 -0500 | [diff] [blame] | 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 | |
Ville Syrjälä | 800ba2b | 2015-12-15 12:21:06 +0100 | [diff] [blame] | 298 | static const struct drm_connector_funcs vidi_connector_funcs = { |
Sean Paul | ce6cb55 | 2014-01-30 16:38:07 -0500 | [diff] [blame] | 299 | .fill_modes = drm_helper_probe_single_connector_modes, |
| 300 | .detect = vidi_detect, |
| 301 | .destroy = vidi_connector_destroy, |
Gustavo Padovan | 4ea9526 | 2015-06-01 12:04:44 -0300 | [diff] [blame] | 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, |
Sean Paul | ce6cb55 | 2014-01-30 16:38:07 -0500 | [diff] [blame] | 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) { |
Inki Dae | df90a64 | 2019-04-15 16:35:08 +0900 | [diff] [blame] | 318 | DRM_DEV_DEBUG_KMS(ctx->dev, "raw_edid is null.\n"); |
Jani Nikula | 13d5b04 | 2024-03-08 18:03:41 +0200 | [diff] [blame] | 319 | return 0; |
Sean Paul | ce6cb55 | 2014-01-30 16:38:07 -0500 | [diff] [blame] | 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) { |
Inki Dae | df90a64 | 2019-04-15 16:35:08 +0900 | [diff] [blame] | 325 | DRM_DEV_DEBUG_KMS(ctx->dev, "failed to allocate edid\n"); |
Jani Nikula | 13d5b04 | 2024-03-08 18:03:41 +0200 | [diff] [blame] | 326 | return 0; |
Sean Paul | ce6cb55 | 2014-01-30 16:38:07 -0500 | [diff] [blame] | 327 | } |
| 328 | |
Daniel Vetter | c555f02 | 2018-07-09 10:40:06 +0200 | [diff] [blame] | 329 | drm_connector_update_edid_property(connector, edid); |
Sean Paul | ce6cb55 | 2014-01-30 16:38:07 -0500 | [diff] [blame] | 330 | |
| 331 | return drm_add_edid_modes(connector, edid); |
| 332 | } |
| 333 | |
Ville Syrjälä | 800ba2b | 2015-12-15 12:21:06 +0100 | [diff] [blame] | 334 | static const struct drm_connector_helper_funcs vidi_connector_helper_funcs = { |
Sean Paul | ce6cb55 | 2014-01-30 16:38:07 -0500 | [diff] [blame] | 335 | .get_modes = vidi_get_modes, |
Sean Paul | ce6cb55 | 2014-01-30 16:38:07 -0500 | [diff] [blame] | 336 | }; |
| 337 | |
Gustavo Padovan | 2b8376c | 2015-08-15 12:14:08 -0300 | [diff] [blame] | 338 | static int vidi_create_connector(struct drm_encoder *encoder) |
Sean Paul | ce6cb55 | 2014-01-30 16:38:07 -0500 | [diff] [blame] | 339 | { |
Gustavo Padovan | 2b8376c | 2015-08-15 12:14:08 -0300 | [diff] [blame] | 340 | struct vidi_context *ctx = encoder_to_vidi(encoder); |
Sean Paul | ce6cb55 | 2014-01-30 16:38:07 -0500 | [diff] [blame] | 341 | struct drm_connector *connector = &ctx->connector; |
| 342 | int ret; |
| 343 | |
Sean Paul | ce6cb55 | 2014-01-30 16:38:07 -0500 | [diff] [blame] | 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) { |
Inki Dae | df90a64 | 2019-04-15 16:35:08 +0900 | [diff] [blame] | 349 | DRM_DEV_ERROR(ctx->dev, |
Inki Dae | 6f83d20 | 2019-04-15 14:24:36 +0900 | [diff] [blame] | 350 | "Failed to initialize connector with drm\n"); |
Sean Paul | ce6cb55 | 2014-01-30 16:38:07 -0500 | [diff] [blame] | 351 | return ret; |
| 352 | } |
| 353 | |
| 354 | drm_connector_helper_add(connector, &vidi_connector_helper_funcs); |
Daniel Vetter | cde4c44 | 2018-07-09 10:40:07 +0200 | [diff] [blame] | 355 | drm_connector_attach_encoder(connector, encoder); |
Sean Paul | ce6cb55 | 2014-01-30 16:38:07 -0500 | [diff] [blame] | 356 | |
| 357 | return 0; |
| 358 | } |
| 359 | |
Gustavo Padovan | 2b8376c | 2015-08-15 12:14:08 -0300 | [diff] [blame] | 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 | |
Ville Syrjälä | 800ba2b | 2015-12-15 12:21:06 +0100 | [diff] [blame] | 374 | static const struct drm_encoder_helper_funcs exynos_vidi_encoder_helper_funcs = { |
Gustavo Padovan | 2b8376c | 2015-08-15 12:14:08 -0300 | [diff] [blame] | 375 | .mode_set = exynos_vidi_mode_set, |
| 376 | .enable = exynos_vidi_enable, |
| 377 | .disable = exynos_vidi_disable, |
| 378 | }; |
| 379 | |
Inki Dae | 1d50aa9c | 2014-11-24 14:55:41 +0900 | [diff] [blame] | 380 | static int vidi_bind(struct device *dev, struct device *master, void *data) |
Inki Dae | f37cd5e | 2014-05-09 14:25:20 +0900 | [diff] [blame] | 381 | { |
Andrzej Hajda | f01833c | 2014-11-17 09:54:16 +0100 | [diff] [blame] | 382 | struct vidi_context *ctx = dev_get_drvdata(dev); |
Inki Dae | 1d50aa9c | 2014-11-24 14:55:41 +0900 | [diff] [blame] | 383 | struct drm_device *drm_dev = data; |
Gustavo Padovan | 2b8376c | 2015-08-15 12:14:08 -0300 | [diff] [blame] | 384 | struct drm_encoder *encoder = &ctx->encoder; |
Gustavo Padovan | 7ee14cd | 2015-04-03 21:03:40 +0900 | [diff] [blame] | 385 | struct exynos_drm_plane *exynos_plane; |
Marek Szyprowski | fd2d2fc | 2015-11-30 14:53:25 +0100 | [diff] [blame] | 386 | struct exynos_drm_plane_config plane_config = { 0 }; |
| 387 | unsigned int i; |
Andrzej Hajda | 1ca582f | 2017-08-24 15:33:51 +0200 | [diff] [blame] | 388 | int ret; |
Inki Dae | f37cd5e | 2014-05-09 14:25:20 +0900 | [diff] [blame] | 389 | |
Andrzej Hajda | 2949390 | 2017-03-15 15:41:06 +0100 | [diff] [blame] | 390 | ctx->drm_dev = drm_dev; |
Joonyoung Shim | 0f04cf8 | 2015-01-30 16:43:01 +0900 | [diff] [blame] | 391 | |
Marek Szyprowski | fd2d2fc | 2015-11-30 14:53:25 +0100 | [diff] [blame] | 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 | |
Marek Szyprowski | 40bdfb0 | 2015-12-16 13:21:42 +0100 | [diff] [blame] | 399 | ret = exynos_plane_init(drm_dev, &ctx->planes[i], i, |
Andrzej Hajda | 2c82607 | 2017-03-15 15:41:05 +0100 | [diff] [blame] | 400 | &plane_config); |
Gustavo Padovan | 7ee14cd | 2015-04-03 21:03:40 +0900 | [diff] [blame] | 401 | if (ret) |
| 402 | return ret; |
| 403 | } |
| 404 | |
Gustavo Padovan | 5d3d099 | 2015-10-12 22:07:48 +0900 | [diff] [blame] | 405 | exynos_plane = &ctx->planes[DEFAULT_WIN]; |
Gustavo Padovan | 7ee14cd | 2015-04-03 21:03:40 +0900 | [diff] [blame] | 406 | ctx->crtc = exynos_drm_crtc_create(drm_dev, &exynos_plane->base, |
Andrzej Hajda | d644951 | 2017-05-29 10:05:25 +0900 | [diff] [blame] | 407 | EXYNOS_DISPLAY_TYPE_VIDI, &vidi_crtc_ops, ctx); |
Gustavo Padovan | 93bca24 | 2015-01-18 18:16:23 +0900 | [diff] [blame] | 408 | if (IS_ERR(ctx->crtc)) { |
Inki Dae | 6f83d20 | 2019-04-15 14:24:36 +0900 | [diff] [blame] | 409 | DRM_DEV_ERROR(dev, "failed to create crtc.\n"); |
Gustavo Padovan | 93bca24 | 2015-01-18 18:16:23 +0900 | [diff] [blame] | 410 | return PTR_ERR(ctx->crtc); |
Inki Dae | f37cd5e | 2014-05-09 14:25:20 +0900 | [diff] [blame] | 411 | } |
| 412 | |
Thomas Zimmermann | 3e1fe32 | 2020-03-05 16:59:31 +0100 | [diff] [blame] | 413 | drm_simple_encoder_init(drm_dev, encoder, DRM_MODE_ENCODER_TMDS); |
Gustavo Padovan | 2b8376c | 2015-08-15 12:14:08 -0300 | [diff] [blame] | 414 | |
| 415 | drm_encoder_helper_add(encoder, &exynos_vidi_encoder_helper_funcs); |
| 416 | |
Andrzej Hajda | 1ca582f | 2017-08-24 15:33:51 +0200 | [diff] [blame] | 417 | ret = exynos_drm_set_possible_crtcs(encoder, EXYNOS_DISPLAY_TYPE_VIDI); |
| 418 | if (ret < 0) |
| 419 | return ret; |
| 420 | |
Gustavo Padovan | 2b8376c | 2015-08-15 12:14:08 -0300 | [diff] [blame] | 421 | ret = vidi_create_connector(encoder); |
Gustavo Padovan | a2986e8 | 2015-08-05 20:24:20 -0300 | [diff] [blame] | 422 | if (ret) { |
Inki Dae | 6f83d20 | 2019-04-15 14:24:36 +0900 | [diff] [blame] | 423 | DRM_DEV_ERROR(dev, "failed to create connector ret = %d\n", |
| 424 | ret); |
Gustavo Padovan | 2b8376c | 2015-08-15 12:14:08 -0300 | [diff] [blame] | 425 | drm_encoder_cleanup(encoder); |
Inki Dae | f37cd5e | 2014-05-09 14:25:20 +0900 | [diff] [blame] | 426 | return ret; |
| 427 | } |
| 428 | |
| 429 | return 0; |
| 430 | } |
| 431 | |
Inki Dae | 1d50aa9c | 2014-11-24 14:55:41 +0900 | [diff] [blame] | 432 | |
| 433 | static void vidi_unbind(struct device *dev, struct device *master, void *data) |
| 434 | { |
Andrzej Hajda | 8574e92 | 2016-09-23 10:15:23 +0200 | [diff] [blame] | 435 | struct vidi_context *ctx = dev_get_drvdata(dev); |
| 436 | |
| 437 | del_timer_sync(&ctx->timer); |
Inki Dae | 1d50aa9c | 2014-11-24 14:55:41 +0900 | [diff] [blame] | 438 | } |
| 439 | |
| 440 | static const struct component_ops vidi_component_ops = { |
| 441 | .bind = vidi_bind, |
| 442 | .unbind = vidi_unbind, |
| 443 | }; |
| 444 | |
Greg Kroah-Hartman | 56550d9 | 2012-12-21 15:09:25 -0800 | [diff] [blame] | 445 | static int vidi_probe(struct platform_device *pdev) |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 446 | { |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 447 | struct vidi_context *ctx; |
Inki Dae | df90a64 | 2019-04-15 16:35:08 +0900 | [diff] [blame] | 448 | struct device *dev = &pdev->dev; |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 449 | |
Inki Dae | df90a64 | 2019-04-15 16:35:08 +0900 | [diff] [blame] | 450 | ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL); |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 451 | if (!ctx) |
| 452 | return -ENOMEM; |
| 453 | |
Inki Dae | df90a64 | 2019-04-15 16:35:08 +0900 | [diff] [blame] | 454 | ctx->dev = dev; |
Inki Dae | 1d50aa9c | 2014-11-24 14:55:41 +0900 | [diff] [blame] | 455 | |
Kees Cook | e99e88a | 2017-10-16 14:43:17 -0700 | [diff] [blame] | 456 | timer_setup(&ctx->timer, vidi_fake_vblank_timer, 0); |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 457 | |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 458 | mutex_init(&ctx->lock); |
| 459 | |
Andrzej Hajda | f01833c | 2014-11-17 09:54:16 +0100 | [diff] [blame] | 460 | platform_set_drvdata(pdev, ctx); |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 461 | |
Emil Velikov | f84e1ba | 2020-05-17 20:36:55 +0100 | [diff] [blame] | 462 | return component_add(dev, &vidi_component_ops); |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 463 | } |
| 464 | |
Uwe Kleine-König | 4fe7a1e | 2023-11-08 13:09:12 +0900 | [diff] [blame] | 465 | static void vidi_remove(struct platform_device *pdev) |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 466 | { |
Andrzej Hajda | f01833c | 2014-11-17 09:54:16 +0100 | [diff] [blame] | 467 | struct vidi_context *ctx = platform_get_drvdata(pdev); |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 468 | |
Inki Dae | d3b62db | 2012-06-27 16:36:12 +0900 | [diff] [blame] | 469 | if (ctx->raw_edid != (struct edid *)fake_edid_info) { |
| 470 | kfree(ctx->raw_edid); |
| 471 | ctx->raw_edid = NULL; |
| 472 | } |
| 473 | |
Inki Dae | 1d50aa9c | 2014-11-24 14:55:41 +0900 | [diff] [blame] | 474 | component_del(&pdev->dev, &vidi_component_ops); |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 475 | } |
| 476 | |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 477 | struct platform_driver vidi_driver = { |
| 478 | .probe = vidi_probe, |
Uwe Kleine-König | 4fe7a1e | 2023-11-08 13:09:12 +0900 | [diff] [blame] | 479 | .remove_new = vidi_remove, |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 480 | .driver = { |
| 481 | .name = "exynos-drm-vidi", |
| 482 | .owner = THIS_MODULE, |
Emil Velikov | f84e1ba | 2020-05-17 20:36:55 +0100 | [diff] [blame] | 483 | .dev_groups = vidi_groups, |
Inki Dae | b73d123 | 2012-03-21 10:55:26 +0900 | [diff] [blame] | 484 | }, |
| 485 | }; |