Loading...
Note: File does not exist in v3.1.
1/*
2 * rcar_du_plane.c -- R-Car Display Unit Planes
3 *
4 * Copyright (C) 2013-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.h>
16#include <drm/drm_atomic_helper.h>
17#include <drm/drm_crtc.h>
18#include <drm/drm_crtc_helper.h>
19#include <drm/drm_fb_cma_helper.h>
20#include <drm/drm_gem_cma_helper.h>
21#include <drm/drm_plane_helper.h>
22
23#include "rcar_du_drv.h"
24#include "rcar_du_group.h"
25#include "rcar_du_kms.h"
26#include "rcar_du_plane.h"
27#include "rcar_du_regs.h"
28
29/* -----------------------------------------------------------------------------
30 * Atomic hardware plane allocator
31 *
32 * The hardware plane allocator is solely based on the atomic plane states
33 * without keeping any external state to avoid races between .atomic_check()
34 * and .atomic_commit().
35 *
36 * The core idea is to avoid using a free planes bitmask that would need to be
37 * shared between check and commit handlers with a collective knowledge based on
38 * the allocated hardware plane(s) for each KMS plane. The allocator then loops
39 * over all plane states to compute the free planes bitmask, allocates hardware
40 * planes based on that bitmask, and stores the result back in the plane states.
41 *
42 * For this to work we need to access the current state of planes not touched by
43 * the atomic update. To ensure that it won't be modified, we need to lock all
44 * planes using drm_atomic_get_plane_state(). This effectively serializes atomic
45 * updates from .atomic_check() up to completion (when swapping the states if
46 * the check step has succeeded) or rollback (when freeing the states if the
47 * check step has failed).
48 *
49 * Allocation is performed in the .atomic_check() handler and applied
50 * automatically when the core swaps the old and new states.
51 */
52
53static bool rcar_du_plane_needs_realloc(
54 const struct rcar_du_plane_state *old_state,
55 const struct rcar_du_plane_state *new_state)
56{
57 /*
58 * Lowering the number of planes doesn't strictly require reallocation
59 * as the extra hardware plane will be freed when committing, but doing
60 * so could lead to more fragmentation.
61 */
62 if (!old_state->format ||
63 old_state->format->planes != new_state->format->planes)
64 return true;
65
66 /* Reallocate hardware planes if the source has changed. */
67 if (old_state->source != new_state->source)
68 return true;
69
70 return false;
71}
72
73static unsigned int rcar_du_plane_hwmask(struct rcar_du_plane_state *state)
74{
75 unsigned int mask;
76
77 if (state->hwindex == -1)
78 return 0;
79
80 mask = 1 << state->hwindex;
81 if (state->format->planes == 2)
82 mask |= 1 << ((state->hwindex + 1) % 8);
83
84 return mask;
85}
86
87/*
88 * The R8A7790 DU can source frames directly from the VSP1 devices VSPD0 and
89 * VSPD1. VSPD0 feeds DU0/1 plane 0, and VSPD1 feeds either DU2 plane 0 or
90 * DU0/1 plane 1.
91 *
92 * Allocate the correct fixed plane when sourcing frames from VSPD0 or VSPD1,
93 * and allocate planes in reverse index order otherwise to ensure maximum
94 * availability of planes 0 and 1.
95 *
96 * The caller is responsible for ensuring that the requested source is
97 * compatible with the DU revision.
98 */
99static int rcar_du_plane_hwalloc(struct rcar_du_plane *plane,
100 struct rcar_du_plane_state *state,
101 unsigned int free)
102{
103 unsigned int num_planes = state->format->planes;
104 int fixed = -1;
105 int i;
106
107 if (state->source == RCAR_DU_PLANE_VSPD0) {
108 /* VSPD0 feeds plane 0 on DU0/1. */
109 if (plane->group->index != 0)
110 return -EINVAL;
111
112 fixed = 0;
113 } else if (state->source == RCAR_DU_PLANE_VSPD1) {
114 /* VSPD1 feeds plane 1 on DU0/1 or plane 0 on DU2. */
115 fixed = plane->group->index == 0 ? 1 : 0;
116 }
117
118 if (fixed >= 0)
119 return free & (1 << fixed) ? fixed : -EBUSY;
120
121 for (i = RCAR_DU_NUM_HW_PLANES - 1; i >= 0; --i) {
122 if (!(free & (1 << i)))
123 continue;
124
125 if (num_planes == 1 || free & (1 << ((i + 1) % 8)))
126 break;
127 }
128
129 return i < 0 ? -EBUSY : i;
130}
131
132int rcar_du_atomic_check_planes(struct drm_device *dev,
133 struct drm_atomic_state *state)
134{
135 struct rcar_du_device *rcdu = dev->dev_private;
136 unsigned int group_freed_planes[RCAR_DU_MAX_GROUPS] = { 0, };
137 unsigned int group_free_planes[RCAR_DU_MAX_GROUPS] = { 0, };
138 bool needs_realloc = false;
139 unsigned int groups = 0;
140 unsigned int i;
141 struct drm_plane *drm_plane;
142 struct drm_plane_state *old_drm_plane_state;
143 struct drm_plane_state *new_drm_plane_state;
144
145 /* Check if hardware planes need to be reallocated. */
146 for_each_oldnew_plane_in_state(state, drm_plane, old_drm_plane_state,
147 new_drm_plane_state, i) {
148 struct rcar_du_plane_state *old_plane_state;
149 struct rcar_du_plane_state *new_plane_state;
150 struct rcar_du_plane *plane;
151 unsigned int index;
152
153 plane = to_rcar_plane(drm_plane);
154 old_plane_state = to_rcar_plane_state(old_drm_plane_state);
155 new_plane_state = to_rcar_plane_state(new_drm_plane_state);
156
157 dev_dbg(rcdu->dev, "%s: checking plane (%u,%tu)\n", __func__,
158 plane->group->index, plane - plane->group->planes);
159
160 /*
161 * If the plane is being disabled we don't need to go through
162 * the full reallocation procedure. Just mark the hardware
163 * plane(s) as freed.
164 */
165 if (!new_plane_state->format) {
166 dev_dbg(rcdu->dev, "%s: plane is being disabled\n",
167 __func__);
168 index = plane - plane->group->planes;
169 group_freed_planes[plane->group->index] |= 1 << index;
170 new_plane_state->hwindex = -1;
171 continue;
172 }
173
174 /*
175 * If the plane needs to be reallocated mark it as such, and
176 * mark the hardware plane(s) as free.
177 */
178 if (rcar_du_plane_needs_realloc(old_plane_state, new_plane_state)) {
179 dev_dbg(rcdu->dev, "%s: plane needs reallocation\n",
180 __func__);
181 groups |= 1 << plane->group->index;
182 needs_realloc = true;
183
184 index = plane - plane->group->planes;
185 group_freed_planes[plane->group->index] |= 1 << index;
186 new_plane_state->hwindex = -1;
187 }
188 }
189
190 if (!needs_realloc)
191 return 0;
192
193 /*
194 * Grab all plane states for the groups that need reallocation to ensure
195 * locking and avoid racy updates. This serializes the update operation,
196 * but there's not much we can do about it as that's the hardware
197 * design.
198 *
199 * Compute the used planes mask for each group at the same time to avoid
200 * looping over the planes separately later.
201 */
202 while (groups) {
203 unsigned int index = ffs(groups) - 1;
204 struct rcar_du_group *group = &rcdu->groups[index];
205 unsigned int used_planes = 0;
206
207 dev_dbg(rcdu->dev, "%s: finding free planes for group %u\n",
208 __func__, index);
209
210 for (i = 0; i < group->num_planes; ++i) {
211 struct rcar_du_plane *plane = &group->planes[i];
212 struct rcar_du_plane_state *new_plane_state;
213 struct drm_plane_state *s;
214
215 s = drm_atomic_get_plane_state(state, &plane->plane);
216 if (IS_ERR(s))
217 return PTR_ERR(s);
218
219 /*
220 * If the plane has been freed in the above loop its
221 * hardware planes must not be added to the used planes
222 * bitmask. However, the current state doesn't reflect
223 * the free state yet, as we've modified the new state
224 * above. Use the local freed planes list to check for
225 * that condition instead.
226 */
227 if (group_freed_planes[index] & (1 << i)) {
228 dev_dbg(rcdu->dev,
229 "%s: plane (%u,%tu) has been freed, skipping\n",
230 __func__, plane->group->index,
231 plane - plane->group->planes);
232 continue;
233 }
234
235 new_plane_state = to_rcar_plane_state(s);
236 used_planes |= rcar_du_plane_hwmask(new_plane_state);
237
238 dev_dbg(rcdu->dev,
239 "%s: plane (%u,%tu) uses %u hwplanes (index %d)\n",
240 __func__, plane->group->index,
241 plane - plane->group->planes,
242 new_plane_state->format ?
243 new_plane_state->format->planes : 0,
244 new_plane_state->hwindex);
245 }
246
247 group_free_planes[index] = 0xff & ~used_planes;
248 groups &= ~(1 << index);
249
250 dev_dbg(rcdu->dev, "%s: group %u free planes mask 0x%02x\n",
251 __func__, index, group_free_planes[index]);
252 }
253
254 /* Reallocate hardware planes for each plane that needs it. */
255 for_each_oldnew_plane_in_state(state, drm_plane, old_drm_plane_state,
256 new_drm_plane_state, i) {
257 struct rcar_du_plane_state *old_plane_state;
258 struct rcar_du_plane_state *new_plane_state;
259 struct rcar_du_plane *plane;
260 unsigned int crtc_planes;
261 unsigned int free;
262 int idx;
263
264 plane = to_rcar_plane(drm_plane);
265 old_plane_state = to_rcar_plane_state(old_drm_plane_state);
266 new_plane_state = to_rcar_plane_state(new_drm_plane_state);
267
268 dev_dbg(rcdu->dev, "%s: allocating plane (%u,%tu)\n", __func__,
269 plane->group->index, plane - plane->group->planes);
270
271 /*
272 * Skip planes that are being disabled or don't need to be
273 * reallocated.
274 */
275 if (!new_plane_state->format ||
276 !rcar_du_plane_needs_realloc(old_plane_state, new_plane_state))
277 continue;
278
279 /*
280 * Try to allocate the plane from the free planes currently
281 * associated with the target CRTC to avoid restarting the CRTC
282 * group and thus minimize flicker. If it fails fall back to
283 * allocating from all free planes.
284 */
285 crtc_planes = to_rcar_crtc(new_plane_state->state.crtc)->index % 2
286 ? plane->group->dptsr_planes
287 : ~plane->group->dptsr_planes;
288 free = group_free_planes[plane->group->index];
289
290 idx = rcar_du_plane_hwalloc(plane, new_plane_state,
291 free & crtc_planes);
292 if (idx < 0)
293 idx = rcar_du_plane_hwalloc(plane, new_plane_state,
294 free);
295 if (idx < 0) {
296 dev_dbg(rcdu->dev, "%s: no available hardware plane\n",
297 __func__);
298 return idx;
299 }
300
301 dev_dbg(rcdu->dev, "%s: allocated %u hwplanes (index %u)\n",
302 __func__, new_plane_state->format->planes, idx);
303
304 new_plane_state->hwindex = idx;
305
306 group_free_planes[plane->group->index] &=
307 ~rcar_du_plane_hwmask(new_plane_state);
308
309 dev_dbg(rcdu->dev, "%s: group %u free planes mask 0x%02x\n",
310 __func__, plane->group->index,
311 group_free_planes[plane->group->index]);
312 }
313
314 return 0;
315}
316
317/* -----------------------------------------------------------------------------
318 * Plane Setup
319 */
320
321#define RCAR_DU_COLORKEY_NONE (0 << 24)
322#define RCAR_DU_COLORKEY_SOURCE (1 << 24)
323#define RCAR_DU_COLORKEY_MASK (1 << 24)
324
325static void rcar_du_plane_write(struct rcar_du_group *rgrp,
326 unsigned int index, u32 reg, u32 data)
327{
328 rcar_du_write(rgrp->dev, rgrp->mmio_offset + index * PLANE_OFF + reg,
329 data);
330}
331
332static void rcar_du_plane_setup_scanout(struct rcar_du_group *rgrp,
333 const struct rcar_du_plane_state *state)
334{
335 unsigned int src_x = state->state.src.x1 >> 16;
336 unsigned int src_y = state->state.src.y1 >> 16;
337 unsigned int index = state->hwindex;
338 unsigned int pitch;
339 bool interlaced;
340 u32 dma[2];
341
342 interlaced = state->state.crtc->state->adjusted_mode.flags
343 & DRM_MODE_FLAG_INTERLACE;
344
345 if (state->source == RCAR_DU_PLANE_MEMORY) {
346 struct drm_framebuffer *fb = state->state.fb;
347 struct drm_gem_cma_object *gem;
348 unsigned int i;
349
350 if (state->format->planes == 2)
351 pitch = fb->pitches[0];
352 else
353 pitch = fb->pitches[0] * 8 / state->format->bpp;
354
355 for (i = 0; i < state->format->planes; ++i) {
356 gem = drm_fb_cma_get_gem_obj(fb, i);
357 dma[i] = gem->paddr + fb->offsets[i];
358 }
359 } else {
360 pitch = drm_rect_width(&state->state.src) >> 16;
361 dma[0] = 0;
362 dma[1] = 0;
363 }
364
365 /*
366 * Memory pitch (expressed in pixels). Must be doubled for interlaced
367 * operation with 32bpp formats.
368 */
369 rcar_du_plane_write(rgrp, index, PnMWR,
370 (interlaced && state->format->bpp == 32) ?
371 pitch * 2 : pitch);
372
373 /*
374 * The Y position is expressed in raster line units and must be doubled
375 * for 32bpp formats, according to the R8A7790 datasheet. No mention of
376 * doubling the Y position is found in the R8A7779 datasheet, but the
377 * rule seems to apply there as well.
378 *
379 * Despite not being documented, doubling seem not to be needed when
380 * operating in interlaced mode.
381 *
382 * Similarly, for the second plane, NV12 and NV21 formats seem to
383 * require a halved Y position value, in both progressive and interlaced
384 * modes.
385 */
386 rcar_du_plane_write(rgrp, index, PnSPXR, src_x);
387 rcar_du_plane_write(rgrp, index, PnSPYR, src_y *
388 (!interlaced && state->format->bpp == 32 ? 2 : 1));
389
390 rcar_du_plane_write(rgrp, index, PnDSA0R, dma[0]);
391
392 if (state->format->planes == 2) {
393 index = (index + 1) % 8;
394
395 rcar_du_plane_write(rgrp, index, PnMWR, pitch);
396
397 rcar_du_plane_write(rgrp, index, PnSPXR, src_x);
398 rcar_du_plane_write(rgrp, index, PnSPYR, src_y *
399 (state->format->bpp == 16 ? 2 : 1) / 2);
400
401 rcar_du_plane_write(rgrp, index, PnDSA0R, dma[1]);
402 }
403}
404
405static void rcar_du_plane_setup_mode(struct rcar_du_group *rgrp,
406 unsigned int index,
407 const struct rcar_du_plane_state *state)
408{
409 u32 colorkey;
410 u32 pnmr;
411
412 /*
413 * The PnALPHAR register controls alpha-blending in 16bpp formats
414 * (ARGB1555 and XRGB1555).
415 *
416 * For ARGB, set the alpha value to 0, and enable alpha-blending when
417 * the A bit is 0. This maps A=0 to alpha=0 and A=1 to alpha=255.
418 *
419 * For XRGB, set the alpha value to the plane-wide alpha value and
420 * enable alpha-blending regardless of the X bit value.
421 */
422 if (state->format->fourcc != DRM_FORMAT_XRGB1555)
423 rcar_du_plane_write(rgrp, index, PnALPHAR, PnALPHAR_ABIT_0);
424 else
425 rcar_du_plane_write(rgrp, index, PnALPHAR,
426 PnALPHAR_ABIT_X | state->alpha);
427
428 pnmr = PnMR_BM_MD | state->format->pnmr;
429
430 /*
431 * Disable color keying when requested. YUV formats have the
432 * PnMR_SPIM_TP_OFF bit set in their pnmr field, disabling color keying
433 * automatically.
434 */
435 if ((state->colorkey & RCAR_DU_COLORKEY_MASK) == RCAR_DU_COLORKEY_NONE)
436 pnmr |= PnMR_SPIM_TP_OFF;
437
438 /* For packed YUV formats we need to select the U/V order. */
439 if (state->format->fourcc == DRM_FORMAT_YUYV)
440 pnmr |= PnMR_YCDF_YUYV;
441
442 rcar_du_plane_write(rgrp, index, PnMR, pnmr);
443
444 switch (state->format->fourcc) {
445 case DRM_FORMAT_RGB565:
446 colorkey = ((state->colorkey & 0xf80000) >> 8)
447 | ((state->colorkey & 0x00fc00) >> 5)
448 | ((state->colorkey & 0x0000f8) >> 3);
449 rcar_du_plane_write(rgrp, index, PnTC2R, colorkey);
450 break;
451
452 case DRM_FORMAT_ARGB1555:
453 case DRM_FORMAT_XRGB1555:
454 colorkey = ((state->colorkey & 0xf80000) >> 9)
455 | ((state->colorkey & 0x00f800) >> 6)
456 | ((state->colorkey & 0x0000f8) >> 3);
457 rcar_du_plane_write(rgrp, index, PnTC2R, colorkey);
458 break;
459
460 case DRM_FORMAT_XRGB8888:
461 case DRM_FORMAT_ARGB8888:
462 rcar_du_plane_write(rgrp, index, PnTC3R,
463 PnTC3R_CODE | (state->colorkey & 0xffffff));
464 break;
465 }
466}
467
468static void rcar_du_plane_setup_format_gen2(struct rcar_du_group *rgrp,
469 unsigned int index,
470 const struct rcar_du_plane_state *state)
471{
472 u32 ddcr2 = PnDDCR2_CODE;
473 u32 ddcr4;
474
475 /*
476 * Data format
477 *
478 * The data format is selected by the DDDF field in PnMR and the EDF
479 * field in DDCR4.
480 */
481
482 rcar_du_plane_setup_mode(rgrp, index, state);
483
484 if (state->format->planes == 2) {
485 if (state->hwindex != index) {
486 if (state->format->fourcc == DRM_FORMAT_NV12 ||
487 state->format->fourcc == DRM_FORMAT_NV21)
488 ddcr2 |= PnDDCR2_Y420;
489
490 if (state->format->fourcc == DRM_FORMAT_NV21)
491 ddcr2 |= PnDDCR2_NV21;
492
493 ddcr2 |= PnDDCR2_DIVU;
494 } else {
495 ddcr2 |= PnDDCR2_DIVY;
496 }
497 }
498
499 rcar_du_plane_write(rgrp, index, PnDDCR2, ddcr2);
500
501 ddcr4 = state->format->edf | PnDDCR4_CODE;
502 if (state->source != RCAR_DU_PLANE_MEMORY)
503 ddcr4 |= PnDDCR4_VSPS;
504
505 rcar_du_plane_write(rgrp, index, PnDDCR4, ddcr4);
506}
507
508static void rcar_du_plane_setup_format_gen3(struct rcar_du_group *rgrp,
509 unsigned int index,
510 const struct rcar_du_plane_state *state)
511{
512 rcar_du_plane_write(rgrp, index, PnMR,
513 PnMR_SPIM_TP_OFF | state->format->pnmr);
514
515 rcar_du_plane_write(rgrp, index, PnDDCR4,
516 state->format->edf | PnDDCR4_CODE);
517}
518
519static void rcar_du_plane_setup_format(struct rcar_du_group *rgrp,
520 unsigned int index,
521 const struct rcar_du_plane_state *state)
522{
523 struct rcar_du_device *rcdu = rgrp->dev;
524 const struct drm_rect *dst = &state->state.dst;
525
526 if (rcdu->info->gen < 3)
527 rcar_du_plane_setup_format_gen2(rgrp, index, state);
528 else
529 rcar_du_plane_setup_format_gen3(rgrp, index, state);
530
531 /* Destination position and size */
532 rcar_du_plane_write(rgrp, index, PnDSXR, drm_rect_width(dst));
533 rcar_du_plane_write(rgrp, index, PnDSYR, drm_rect_height(dst));
534 rcar_du_plane_write(rgrp, index, PnDPXR, dst->x1);
535 rcar_du_plane_write(rgrp, index, PnDPYR, dst->y1);
536
537 if (rcdu->info->gen < 3) {
538 /* Wrap-around and blinking, disabled */
539 rcar_du_plane_write(rgrp, index, PnWASPR, 0);
540 rcar_du_plane_write(rgrp, index, PnWAMWR, 4095);
541 rcar_du_plane_write(rgrp, index, PnBTR, 0);
542 rcar_du_plane_write(rgrp, index, PnMLR, 0);
543 }
544}
545
546void __rcar_du_plane_setup(struct rcar_du_group *rgrp,
547 const struct rcar_du_plane_state *state)
548{
549 struct rcar_du_device *rcdu = rgrp->dev;
550
551 rcar_du_plane_setup_format(rgrp, state->hwindex, state);
552 if (state->format->planes == 2)
553 rcar_du_plane_setup_format(rgrp, (state->hwindex + 1) % 8,
554 state);
555
556 if (rcdu->info->gen < 3)
557 rcar_du_plane_setup_scanout(rgrp, state);
558
559 if (state->source == RCAR_DU_PLANE_VSPD1) {
560 unsigned int vspd1_sink = rgrp->index ? 2 : 0;
561
562 if (rcdu->vspd1_sink != vspd1_sink) {
563 rcdu->vspd1_sink = vspd1_sink;
564 rcar_du_set_dpad0_vsp1_routing(rcdu);
565 }
566 }
567}
568
569int __rcar_du_plane_atomic_check(struct drm_plane *plane,
570 struct drm_plane_state *state,
571 const struct rcar_du_format_info **format)
572{
573 struct drm_device *dev = plane->dev;
574 struct drm_crtc_state *crtc_state;
575 int ret;
576
577 if (!state->crtc) {
578 /*
579 * The visible field is not reset by the DRM core but only
580 * updated by drm_plane_helper_check_state(), set it manually.
581 */
582 state->visible = false;
583 *format = NULL;
584 return 0;
585 }
586
587 crtc_state = drm_atomic_get_crtc_state(state->state, state->crtc);
588 if (IS_ERR(crtc_state))
589 return PTR_ERR(crtc_state);
590
591 ret = drm_atomic_helper_check_plane_state(state, crtc_state,
592 DRM_PLANE_HELPER_NO_SCALING,
593 DRM_PLANE_HELPER_NO_SCALING,
594 true, true);
595 if (ret < 0)
596 return ret;
597
598 if (!state->visible) {
599 *format = NULL;
600 return 0;
601 }
602
603 *format = rcar_du_format_info(state->fb->format->format);
604 if (*format == NULL) {
605 dev_dbg(dev->dev, "%s: unsupported format %08x\n", __func__,
606 state->fb->format->format);
607 return -EINVAL;
608 }
609
610 return 0;
611}
612
613static int rcar_du_plane_atomic_check(struct drm_plane *plane,
614 struct drm_plane_state *state)
615{
616 struct rcar_du_plane_state *rstate = to_rcar_plane_state(state);
617
618 return __rcar_du_plane_atomic_check(plane, state, &rstate->format);
619}
620
621static void rcar_du_plane_atomic_update(struct drm_plane *plane,
622 struct drm_plane_state *old_state)
623{
624 struct rcar_du_plane *rplane = to_rcar_plane(plane);
625 struct rcar_du_plane_state *old_rstate;
626 struct rcar_du_plane_state *new_rstate;
627
628 if (!plane->state->visible)
629 return;
630
631 rcar_du_plane_setup(rplane);
632
633 /*
634 * Check whether the source has changed from memory to live source or
635 * from live source to memory. The source has been configured by the
636 * VSPS bit in the PnDDCR4 register. Although the datasheet states that
637 * the bit is updated during vertical blanking, it seems that updates
638 * only occur when the DU group is held in reset through the DSYSR.DRES
639 * bit. We thus need to restart the group if the source changes.
640 */
641 old_rstate = to_rcar_plane_state(old_state);
642 new_rstate = to_rcar_plane_state(plane->state);
643
644 if ((old_rstate->source == RCAR_DU_PLANE_MEMORY) !=
645 (new_rstate->source == RCAR_DU_PLANE_MEMORY))
646 rplane->group->need_restart = true;
647}
648
649static const struct drm_plane_helper_funcs rcar_du_plane_helper_funcs = {
650 .atomic_check = rcar_du_plane_atomic_check,
651 .atomic_update = rcar_du_plane_atomic_update,
652};
653
654static struct drm_plane_state *
655rcar_du_plane_atomic_duplicate_state(struct drm_plane *plane)
656{
657 struct rcar_du_plane_state *state;
658 struct rcar_du_plane_state *copy;
659
660 if (WARN_ON(!plane->state))
661 return NULL;
662
663 state = to_rcar_plane_state(plane->state);
664 copy = kmemdup(state, sizeof(*state), GFP_KERNEL);
665 if (copy == NULL)
666 return NULL;
667
668 __drm_atomic_helper_plane_duplicate_state(plane, ©->state);
669
670 return ©->state;
671}
672
673static void rcar_du_plane_atomic_destroy_state(struct drm_plane *plane,
674 struct drm_plane_state *state)
675{
676 __drm_atomic_helper_plane_destroy_state(state);
677 kfree(to_rcar_plane_state(state));
678}
679
680static void rcar_du_plane_reset(struct drm_plane *plane)
681{
682 struct rcar_du_plane_state *state;
683
684 if (plane->state) {
685 rcar_du_plane_atomic_destroy_state(plane, plane->state);
686 plane->state = NULL;
687 }
688
689 state = kzalloc(sizeof(*state), GFP_KERNEL);
690 if (state == NULL)
691 return;
692
693 state->hwindex = -1;
694 state->source = RCAR_DU_PLANE_MEMORY;
695 state->alpha = 255;
696 state->colorkey = RCAR_DU_COLORKEY_NONE;
697 state->state.zpos = plane->type == DRM_PLANE_TYPE_PRIMARY ? 0 : 1;
698
699 plane->state = &state->state;
700 plane->state->plane = plane;
701}
702
703static int rcar_du_plane_atomic_set_property(struct drm_plane *plane,
704 struct drm_plane_state *state,
705 struct drm_property *property,
706 uint64_t val)
707{
708 struct rcar_du_plane_state *rstate = to_rcar_plane_state(state);
709 struct rcar_du_device *rcdu = to_rcar_plane(plane)->group->dev;
710
711 if (property == rcdu->props.alpha)
712 rstate->alpha = val;
713 else if (property == rcdu->props.colorkey)
714 rstate->colorkey = val;
715 else
716 return -EINVAL;
717
718 return 0;
719}
720
721static int rcar_du_plane_atomic_get_property(struct drm_plane *plane,
722 const struct drm_plane_state *state, struct drm_property *property,
723 uint64_t *val)
724{
725 const struct rcar_du_plane_state *rstate =
726 container_of(state, const struct rcar_du_plane_state, state);
727 struct rcar_du_device *rcdu = to_rcar_plane(plane)->group->dev;
728
729 if (property == rcdu->props.alpha)
730 *val = rstate->alpha;
731 else if (property == rcdu->props.colorkey)
732 *val = rstate->colorkey;
733 else
734 return -EINVAL;
735
736 return 0;
737}
738
739static const struct drm_plane_funcs rcar_du_plane_funcs = {
740 .update_plane = drm_atomic_helper_update_plane,
741 .disable_plane = drm_atomic_helper_disable_plane,
742 .reset = rcar_du_plane_reset,
743 .destroy = drm_plane_cleanup,
744 .atomic_duplicate_state = rcar_du_plane_atomic_duplicate_state,
745 .atomic_destroy_state = rcar_du_plane_atomic_destroy_state,
746 .atomic_set_property = rcar_du_plane_atomic_set_property,
747 .atomic_get_property = rcar_du_plane_atomic_get_property,
748};
749
750static const uint32_t formats[] = {
751 DRM_FORMAT_RGB565,
752 DRM_FORMAT_ARGB1555,
753 DRM_FORMAT_XRGB1555,
754 DRM_FORMAT_XRGB8888,
755 DRM_FORMAT_ARGB8888,
756 DRM_FORMAT_UYVY,
757 DRM_FORMAT_YUYV,
758 DRM_FORMAT_NV12,
759 DRM_FORMAT_NV21,
760 DRM_FORMAT_NV16,
761};
762
763int rcar_du_planes_init(struct rcar_du_group *rgrp)
764{
765 struct rcar_du_device *rcdu = rgrp->dev;
766 unsigned int crtcs;
767 unsigned int i;
768 int ret;
769
770 /*
771 * Create one primary plane per CRTC in this group and seven overlay
772 * planes.
773 */
774 rgrp->num_planes = rgrp->num_crtcs + 7;
775
776 crtcs = ((1 << rcdu->num_crtcs) - 1) & (3 << (2 * rgrp->index));
777
778 for (i = 0; i < rgrp->num_planes; ++i) {
779 enum drm_plane_type type = i < rgrp->num_crtcs
780 ? DRM_PLANE_TYPE_PRIMARY
781 : DRM_PLANE_TYPE_OVERLAY;
782 struct rcar_du_plane *plane = &rgrp->planes[i];
783
784 plane->group = rgrp;
785
786 ret = drm_universal_plane_init(rcdu->ddev, &plane->plane, crtcs,
787 &rcar_du_plane_funcs, formats,
788 ARRAY_SIZE(formats),
789 NULL, type, NULL);
790 if (ret < 0)
791 return ret;
792
793 drm_plane_helper_add(&plane->plane,
794 &rcar_du_plane_helper_funcs);
795
796 if (type == DRM_PLANE_TYPE_PRIMARY)
797 continue;
798
799 drm_object_attach_property(&plane->plane.base,
800 rcdu->props.alpha, 255);
801 drm_object_attach_property(&plane->plane.base,
802 rcdu->props.colorkey,
803 RCAR_DU_COLORKEY_NONE);
804 drm_plane_create_zpos_property(&plane->plane, 1, 1, 7);
805 }
806
807 return 0;
808}