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