tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/*
2 * Copyright (C) 2011 Samsung Electronics Co.Ltd
3 * Authors: Joonyoung Shim <jy0922.shim@samsung.com>
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License as published by the
7 * Free Software Foundation; either version 2 of the License, or (at your
8 * option) any later version.
9 *
10 */
11
12#include <drm/drmP.h>
13
14#include <drm/exynos_drm.h>
15#include <drm/drm_plane_helper.h>
16#include <drm/drm_atomic_helper.h>
17#include "exynos_drm_drv.h"
18#include "exynos_drm_crtc.h"
19#include "exynos_drm_fb.h"
20#include "exynos_drm_gem.h"
21#include "exynos_drm_plane.h"
22
23static const uint32_t formats[] = {
24 DRM_FORMAT_XRGB8888,
25 DRM_FORMAT_ARGB8888,
26 DRM_FORMAT_NV12,
27};
28
29/*
30 * This function is to get X or Y size shown via screen. This needs length and
31 * start position of CRTC.
32 *
33 * <--- length --->
34 * CRTC ----------------
35 * ^ start ^ end
36 *
37 * There are six cases from a to f.
38 *
39 * <----- SCREEN ----->
40 * 0 last
41 * ----------|------------------|----------
42 * CRTCs
43 * a -------
44 * b -------
45 * c --------------------------
46 * d --------
47 * e -------
48 * f -------
49 */
50static int exynos_plane_get_size(int start, unsigned length, unsigned last)
51{
52 int end = start + length;
53 int size = 0;
54
55 if (start <= 0) {
56 if (end > 0)
57 size = min_t(unsigned, end, last);
58 } else if (start <= last) {
59 size = min_t(unsigned, last - start, length);
60 }
61
62 return size;
63}
64
65static void exynos_plane_mode_set(struct drm_plane *plane,
66 struct drm_crtc *crtc,
67 struct drm_framebuffer *fb,
68 int crtc_x, int crtc_y,
69 unsigned int crtc_w, unsigned int crtc_h,
70 uint32_t src_x, uint32_t src_y,
71 uint32_t src_w, uint32_t src_h)
72{
73 struct exynos_drm_plane *exynos_plane = to_exynos_plane(plane);
74 struct drm_display_mode *mode = &crtc->state->adjusted_mode;
75 unsigned int actual_w;
76 unsigned int actual_h;
77
78 actual_w = exynos_plane_get_size(crtc_x, crtc_w, mode->hdisplay);
79 actual_h = exynos_plane_get_size(crtc_y, crtc_h, mode->vdisplay);
80
81 if (crtc_x < 0) {
82 if (actual_w)
83 src_x -= crtc_x;
84 crtc_x = 0;
85 }
86
87 if (crtc_y < 0) {
88 if (actual_h)
89 src_y -= crtc_y;
90 crtc_y = 0;
91 }
92
93 /* set ratio */
94 exynos_plane->h_ratio = (src_w << 16) / crtc_w;
95 exynos_plane->v_ratio = (src_h << 16) / crtc_h;
96
97 /* set drm framebuffer data. */
98 exynos_plane->src_x = src_x;
99 exynos_plane->src_y = src_y;
100 exynos_plane->src_width = (actual_w * exynos_plane->h_ratio) >> 16;
101 exynos_plane->src_height = (actual_h * exynos_plane->v_ratio) >> 16;
102 exynos_plane->fb_width = fb->width;
103 exynos_plane->fb_height = fb->height;
104 exynos_plane->bpp = fb->bits_per_pixel;
105 exynos_plane->pitch = fb->pitches[0];
106 exynos_plane->pixel_format = fb->pixel_format;
107
108 /* set plane range to be displayed. */
109 exynos_plane->crtc_x = crtc_x;
110 exynos_plane->crtc_y = crtc_y;
111 exynos_plane->crtc_width = actual_w;
112 exynos_plane->crtc_height = actual_h;
113
114 /* set drm mode data. */
115 exynos_plane->mode_width = mode->hdisplay;
116 exynos_plane->mode_height = mode->vdisplay;
117 exynos_plane->refresh = mode->vrefresh;
118 exynos_plane->scan_flag = mode->flags;
119
120 DRM_DEBUG_KMS("plane : offset_x/y(%d,%d), width/height(%d,%d)",
121 exynos_plane->crtc_x, exynos_plane->crtc_y,
122 exynos_plane->crtc_width, exynos_plane->crtc_height);
123
124 plane->crtc = crtc;
125}
126
127static struct drm_plane_funcs exynos_plane_funcs = {
128 .update_plane = drm_atomic_helper_update_plane,
129 .disable_plane = drm_atomic_helper_disable_plane,
130 .destroy = drm_plane_cleanup,
131 .reset = drm_atomic_helper_plane_reset,
132 .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
133 .atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
134};
135
136static int exynos_plane_atomic_check(struct drm_plane *plane,
137 struct drm_plane_state *state)
138{
139 struct exynos_drm_plane *exynos_plane = to_exynos_plane(plane);
140 int nr;
141 int i;
142
143 if (!state->fb)
144 return 0;
145
146 nr = exynos_drm_fb_get_buf_cnt(state->fb);
147 for (i = 0; i < nr; i++) {
148 struct exynos_drm_gem_buf *buffer =
149 exynos_drm_fb_buffer(state->fb, i);
150
151 if (!buffer) {
152 DRM_DEBUG_KMS("buffer is null\n");
153 return -EFAULT;
154 }
155
156 exynos_plane->dma_addr[i] = buffer->dma_addr +
157 state->fb->offsets[i];
158
159 DRM_DEBUG_KMS("buffer: %d, dma_addr = 0x%lx\n",
160 i, (unsigned long)exynos_plane->dma_addr[i]);
161 }
162
163 return 0;
164}
165
166static void exynos_plane_atomic_update(struct drm_plane *plane,
167 struct drm_plane_state *old_state)
168{
169 struct drm_plane_state *state = plane->state;
170 struct exynos_drm_crtc *exynos_crtc = to_exynos_crtc(state->crtc);
171 struct exynos_drm_plane *exynos_plane = to_exynos_plane(plane);
172
173 if (!state->crtc)
174 return;
175
176 exynos_plane_mode_set(plane, state->crtc, state->fb,
177 state->crtc_x, state->crtc_y,
178 state->crtc_w, state->crtc_h,
179 state->src_x >> 16, state->src_y >> 16,
180 state->src_w >> 16, state->src_h >> 16);
181
182 if (exynos_crtc->ops->win_commit)
183 exynos_crtc->ops->win_commit(exynos_crtc, exynos_plane->zpos);
184}
185
186static void exynos_plane_atomic_disable(struct drm_plane *plane,
187 struct drm_plane_state *old_state)
188{
189 struct exynos_drm_plane *exynos_plane = to_exynos_plane(plane);
190 struct exynos_drm_crtc *exynos_crtc = to_exynos_crtc(old_state->crtc);
191
192 if (!old_state->crtc)
193 return;
194
195 if (exynos_crtc->ops->win_disable)
196 exynos_crtc->ops->win_disable(exynos_crtc,
197 exynos_plane->zpos);
198}
199
200static const struct drm_plane_helper_funcs plane_helper_funcs = {
201 .atomic_check = exynos_plane_atomic_check,
202 .atomic_update = exynos_plane_atomic_update,
203 .atomic_disable = exynos_plane_atomic_disable,
204};
205
206static void exynos_plane_attach_zpos_property(struct drm_plane *plane,
207 unsigned int zpos)
208{
209 struct drm_device *dev = plane->dev;
210 struct exynos_drm_private *dev_priv = dev->dev_private;
211 struct drm_property *prop;
212
213 prop = dev_priv->plane_zpos_property;
214 if (!prop) {
215 prop = drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE,
216 "zpos", 0, MAX_PLANE - 1);
217 if (!prop)
218 return;
219
220 dev_priv->plane_zpos_property = prop;
221 }
222
223 drm_object_attach_property(&plane->base, prop, zpos);
224}
225
226int exynos_plane_init(struct drm_device *dev,
227 struct exynos_drm_plane *exynos_plane,
228 unsigned long possible_crtcs, enum drm_plane_type type,
229 unsigned int zpos)
230{
231 int err;
232
233 err = drm_universal_plane_init(dev, &exynos_plane->base, possible_crtcs,
234 &exynos_plane_funcs, formats,
235 ARRAY_SIZE(formats), type);
236 if (err) {
237 DRM_ERROR("failed to initialize plane\n");
238 return err;
239 }
240
241 drm_plane_helper_add(&exynos_plane->base, &plane_helper_funcs);
242
243 exynos_plane->zpos = zpos;
244
245 if (type == DRM_PLANE_TYPE_OVERLAY)
246 exynos_plane_attach_zpos_property(&exynos_plane->base, zpos);
247
248 return 0;
249}