22da2d671297f3ad936a3963d138867fa4c27f28
[sfrench/cifs-2.6.git] / drivers / gpu / drm / rcar-du / rcar_du_vsp.c
1 /*
2  * rcar_du_vsp.h  --  R-Car Display Unit VSP-Based Compositor
3  *
4  * Copyright (C) 2015 Renesas Electronics Corporation
5  *
6  * Contact: Laurent Pinchart (laurent.pinchart@ideasonboard.com)
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  */
13
14 #include <drm/drmP.h>
15 #include <drm/drm_atomic_helper.h>
16 #include <drm/drm_crtc.h>
17 #include <drm/drm_crtc_helper.h>
18 #include <drm/drm_fb_cma_helper.h>
19 #include <drm/drm_gem_cma_helper.h>
20 #include <drm/drm_plane_helper.h>
21
22 #include <linux/of_platform.h>
23 #include <linux/videodev2.h>
24
25 #include <media/vsp1.h>
26
27 #include "rcar_du_drv.h"
28 #include "rcar_du_kms.h"
29 #include "rcar_du_vsp.h"
30
31 void rcar_du_vsp_enable(struct rcar_du_crtc *crtc)
32 {
33         const struct drm_display_mode *mode = &crtc->crtc.state->adjusted_mode;
34         struct rcar_du_device *rcdu = crtc->group->dev;
35         struct vsp1_du_lif_config cfg = {
36                 .width = mode->hdisplay,
37                 .height = mode->vdisplay,
38         };
39         struct rcar_du_plane_state state = {
40                 .state = {
41                         .crtc = &crtc->crtc,
42                         .crtc_x = 0,
43                         .crtc_y = 0,
44                         .crtc_w = mode->hdisplay,
45                         .crtc_h = mode->vdisplay,
46                         .src_x = 0,
47                         .src_y = 0,
48                         .src_w = mode->hdisplay << 16,
49                         .src_h = mode->vdisplay << 16,
50                         .zpos = 0,
51                 },
52                 .format = rcar_du_format_info(DRM_FORMAT_ARGB8888),
53                 .source = RCAR_DU_PLANE_VSPD1,
54                 .alpha = 255,
55                 .colorkey = 0,
56         };
57
58         if (rcdu->info->gen >= 3)
59                 state.hwindex = (crtc->index % 2) ? 2 : 0;
60         else
61                 state.hwindex = crtc->index % 2;
62
63         __rcar_du_plane_setup(crtc->group, &state);
64
65         /* Ensure that the plane source configuration takes effect by requesting
66          * a restart of the group. See rcar_du_plane_atomic_update() for a more
67          * detailed explanation.
68          *
69          * TODO: Check whether this is still needed on Gen3.
70          */
71         crtc->group->need_restart = true;
72
73         vsp1_du_setup_lif(crtc->vsp->vsp, &cfg);
74 }
75
76 void rcar_du_vsp_disable(struct rcar_du_crtc *crtc)
77 {
78         vsp1_du_setup_lif(crtc->vsp->vsp, NULL);
79 }
80
81 void rcar_du_vsp_atomic_begin(struct rcar_du_crtc *crtc)
82 {
83         vsp1_du_atomic_begin(crtc->vsp->vsp);
84 }
85
86 void rcar_du_vsp_atomic_flush(struct rcar_du_crtc *crtc)
87 {
88         vsp1_du_atomic_flush(crtc->vsp->vsp);
89 }
90
91 /* Keep the two tables in sync. */
92 static const u32 formats_kms[] = {
93         DRM_FORMAT_RGB332,
94         DRM_FORMAT_ARGB4444,
95         DRM_FORMAT_XRGB4444,
96         DRM_FORMAT_ARGB1555,
97         DRM_FORMAT_XRGB1555,
98         DRM_FORMAT_RGB565,
99         DRM_FORMAT_BGR888,
100         DRM_FORMAT_RGB888,
101         DRM_FORMAT_BGRA8888,
102         DRM_FORMAT_BGRX8888,
103         DRM_FORMAT_ARGB8888,
104         DRM_FORMAT_XRGB8888,
105         DRM_FORMAT_UYVY,
106         DRM_FORMAT_VYUY,
107         DRM_FORMAT_YUYV,
108         DRM_FORMAT_YVYU,
109         DRM_FORMAT_NV12,
110         DRM_FORMAT_NV21,
111         DRM_FORMAT_NV16,
112         DRM_FORMAT_NV61,
113         DRM_FORMAT_YUV420,
114         DRM_FORMAT_YVU420,
115         DRM_FORMAT_YUV422,
116         DRM_FORMAT_YVU422,
117         DRM_FORMAT_YUV444,
118         DRM_FORMAT_YVU444,
119 };
120
121 static const u32 formats_v4l2[] = {
122         V4L2_PIX_FMT_RGB332,
123         V4L2_PIX_FMT_ARGB444,
124         V4L2_PIX_FMT_XRGB444,
125         V4L2_PIX_FMT_ARGB555,
126         V4L2_PIX_FMT_XRGB555,
127         V4L2_PIX_FMT_RGB565,
128         V4L2_PIX_FMT_RGB24,
129         V4L2_PIX_FMT_BGR24,
130         V4L2_PIX_FMT_ARGB32,
131         V4L2_PIX_FMT_XRGB32,
132         V4L2_PIX_FMT_ABGR32,
133         V4L2_PIX_FMT_XBGR32,
134         V4L2_PIX_FMT_UYVY,
135         V4L2_PIX_FMT_VYUY,
136         V4L2_PIX_FMT_YUYV,
137         V4L2_PIX_FMT_YVYU,
138         V4L2_PIX_FMT_NV12M,
139         V4L2_PIX_FMT_NV21M,
140         V4L2_PIX_FMT_NV16M,
141         V4L2_PIX_FMT_NV61M,
142         V4L2_PIX_FMT_YUV420M,
143         V4L2_PIX_FMT_YVU420M,
144         V4L2_PIX_FMT_YUV422M,
145         V4L2_PIX_FMT_YVU422M,
146         V4L2_PIX_FMT_YUV444M,
147         V4L2_PIX_FMT_YVU444M,
148 };
149
150 static void rcar_du_vsp_plane_setup(struct rcar_du_vsp_plane *plane)
151 {
152         struct rcar_du_vsp_plane_state *state =
153                 to_rcar_vsp_plane_state(plane->plane.state);
154         struct drm_framebuffer *fb = plane->plane.state->fb;
155         struct vsp1_du_atomic_config cfg = {
156                 .pixelformat = 0,
157                 .pitch = fb->pitches[0],
158                 .alpha = state->alpha,
159                 .zpos = state->state.zpos,
160         };
161         unsigned int i;
162
163         cfg.src.left = state->state.src_x >> 16;
164         cfg.src.top = state->state.src_y >> 16;
165         cfg.src.width = state->state.src_w >> 16;
166         cfg.src.height = state->state.src_h >> 16;
167
168         cfg.dst.left = state->state.crtc_x;
169         cfg.dst.top = state->state.crtc_y;
170         cfg.dst.width = state->state.crtc_w;
171         cfg.dst.height = state->state.crtc_h;
172
173         for (i = 0; i < state->format->planes; ++i) {
174                 struct drm_gem_cma_object *gem;
175
176                 gem = drm_fb_cma_get_gem_obj(fb, i);
177                 cfg.mem[i] = gem->paddr + fb->offsets[i];
178         }
179
180         for (i = 0; i < ARRAY_SIZE(formats_kms); ++i) {
181                 if (formats_kms[i] == state->format->fourcc) {
182                         cfg.pixelformat = formats_v4l2[i];
183                         break;
184                 }
185         }
186
187         vsp1_du_atomic_update(plane->vsp->vsp, plane->index, &cfg);
188 }
189
190 static int rcar_du_vsp_plane_atomic_check(struct drm_plane *plane,
191                                           struct drm_plane_state *state)
192 {
193         struct rcar_du_vsp_plane_state *rstate = to_rcar_vsp_plane_state(state);
194         struct rcar_du_vsp_plane *rplane = to_rcar_vsp_plane(plane);
195         struct rcar_du_device *rcdu = rplane->vsp->dev;
196
197         if (!state->fb || !state->crtc) {
198                 rstate->format = NULL;
199                 return 0;
200         }
201
202         if (state->src_w >> 16 != state->crtc_w ||
203             state->src_h >> 16 != state->crtc_h) {
204                 dev_dbg(rcdu->dev, "%s: scaling not supported\n", __func__);
205                 return -EINVAL;
206         }
207
208         rstate->format = rcar_du_format_info(state->fb->pixel_format);
209         if (rstate->format == NULL) {
210                 dev_dbg(rcdu->dev, "%s: unsupported format %08x\n", __func__,
211                         state->fb->pixel_format);
212                 return -EINVAL;
213         }
214
215         return 0;
216 }
217
218 static void rcar_du_vsp_plane_atomic_update(struct drm_plane *plane,
219                                         struct drm_plane_state *old_state)
220 {
221         struct rcar_du_vsp_plane *rplane = to_rcar_vsp_plane(plane);
222
223         if (plane->state->crtc)
224                 rcar_du_vsp_plane_setup(rplane);
225         else
226                 vsp1_du_atomic_update(rplane->vsp->vsp, rplane->index, NULL);
227 }
228
229 static const struct drm_plane_helper_funcs rcar_du_vsp_plane_helper_funcs = {
230         .atomic_check = rcar_du_vsp_plane_atomic_check,
231         .atomic_update = rcar_du_vsp_plane_atomic_update,
232 };
233
234 static struct drm_plane_state *
235 rcar_du_vsp_plane_atomic_duplicate_state(struct drm_plane *plane)
236 {
237         struct rcar_du_vsp_plane_state *state;
238         struct rcar_du_vsp_plane_state *copy;
239
240         if (WARN_ON(!plane->state))
241                 return NULL;
242
243         state = to_rcar_vsp_plane_state(plane->state);
244         copy = kmemdup(state, sizeof(*state), GFP_KERNEL);
245         if (copy == NULL)
246                 return NULL;
247
248         __drm_atomic_helper_plane_duplicate_state(plane, &copy->state);
249
250         return &copy->state;
251 }
252
253 static void rcar_du_vsp_plane_atomic_destroy_state(struct drm_plane *plane,
254                                                    struct drm_plane_state *state)
255 {
256         __drm_atomic_helper_plane_destroy_state(state);
257         kfree(to_rcar_vsp_plane_state(state));
258 }
259
260 static void rcar_du_vsp_plane_reset(struct drm_plane *plane)
261 {
262         struct rcar_du_vsp_plane_state *state;
263
264         if (plane->state) {
265                 rcar_du_vsp_plane_atomic_destroy_state(plane, plane->state);
266                 plane->state = NULL;
267         }
268
269         state = kzalloc(sizeof(*state), GFP_KERNEL);
270         if (state == NULL)
271                 return;
272
273         state->alpha = 255;
274         state->state.zpos = plane->type == DRM_PLANE_TYPE_PRIMARY ? 0 : 1;
275
276         plane->state = &state->state;
277         plane->state->plane = plane;
278 }
279
280 static int rcar_du_vsp_plane_atomic_set_property(struct drm_plane *plane,
281         struct drm_plane_state *state, struct drm_property *property,
282         uint64_t val)
283 {
284         struct rcar_du_vsp_plane_state *rstate = to_rcar_vsp_plane_state(state);
285         struct rcar_du_device *rcdu = to_rcar_vsp_plane(plane)->vsp->dev;
286
287         if (property == rcdu->props.alpha)
288                 rstate->alpha = val;
289         else
290                 return -EINVAL;
291
292         return 0;
293 }
294
295 static int rcar_du_vsp_plane_atomic_get_property(struct drm_plane *plane,
296         const struct drm_plane_state *state, struct drm_property *property,
297         uint64_t *val)
298 {
299         const struct rcar_du_vsp_plane_state *rstate =
300                 container_of(state, const struct rcar_du_vsp_plane_state, state);
301         struct rcar_du_device *rcdu = to_rcar_vsp_plane(plane)->vsp->dev;
302
303         if (property == rcdu->props.alpha)
304                 *val = rstate->alpha;
305         else
306                 return -EINVAL;
307
308         return 0;
309 }
310
311 static const struct drm_plane_funcs rcar_du_vsp_plane_funcs = {
312         .update_plane = drm_atomic_helper_update_plane,
313         .disable_plane = drm_atomic_helper_disable_plane,
314         .reset = rcar_du_vsp_plane_reset,
315         .set_property = drm_atomic_helper_plane_set_property,
316         .destroy = drm_plane_cleanup,
317         .atomic_duplicate_state = rcar_du_vsp_plane_atomic_duplicate_state,
318         .atomic_destroy_state = rcar_du_vsp_plane_atomic_destroy_state,
319         .atomic_set_property = rcar_du_vsp_plane_atomic_set_property,
320         .atomic_get_property = rcar_du_vsp_plane_atomic_get_property,
321 };
322
323 int rcar_du_vsp_init(struct rcar_du_vsp *vsp)
324 {
325         struct rcar_du_device *rcdu = vsp->dev;
326         struct platform_device *pdev;
327         struct device_node *np;
328         unsigned int i;
329         int ret;
330
331         /* Find the VSP device and initialize it. */
332         np = of_parse_phandle(rcdu->dev->of_node, "vsps", vsp->index);
333         if (!np) {
334                 dev_err(rcdu->dev, "vsps node not found\n");
335                 return -ENXIO;
336         }
337
338         pdev = of_find_device_by_node(np);
339         of_node_put(np);
340         if (!pdev)
341                 return -ENXIO;
342
343         vsp->vsp = &pdev->dev;
344
345         ret = vsp1_du_init(vsp->vsp);
346         if (ret < 0)
347                 return ret;
348
349          /* The VSP2D (Gen3) has 5 RPFs, but the VSP1D (Gen2) is limited to
350           * 4 RPFs.
351           */
352         vsp->num_planes = rcdu->info->gen >= 3 ? 5 : 4;
353
354         vsp->planes = devm_kcalloc(rcdu->dev, vsp->num_planes,
355                                    sizeof(*vsp->planes), GFP_KERNEL);
356         if (!vsp->planes)
357                 return -ENOMEM;
358
359         for (i = 0; i < vsp->num_planes; ++i) {
360                 enum drm_plane_type type = i ? DRM_PLANE_TYPE_OVERLAY
361                                          : DRM_PLANE_TYPE_PRIMARY;
362                 struct rcar_du_vsp_plane *plane = &vsp->planes[i];
363
364                 plane->vsp = vsp;
365                 plane->index = i;
366
367                 ret = drm_universal_plane_init(rcdu->ddev, &plane->plane,
368                                                1 << vsp->index,
369                                                &rcar_du_vsp_plane_funcs,
370                                                formats_kms,
371                                                ARRAY_SIZE(formats_kms), type,
372                                                NULL);
373                 if (ret < 0)
374                         return ret;
375
376                 drm_plane_helper_add(&plane->plane,
377                                      &rcar_du_vsp_plane_helper_funcs);
378
379                 if (type == DRM_PLANE_TYPE_PRIMARY)
380                         continue;
381
382                 drm_object_attach_property(&plane->plane.base,
383                                            rcdu->props.alpha, 255);
384                 drm_plane_create_zpos_property(&plane->plane, 1, 1,
385                                                vsp->num_planes - 1);
386         }
387
388         return 0;
389 }