1 // SPDX-License-Identifier: GPL-2.0+
3 * rcar_du_plane.c -- R-Car Display Unit Planes
5 * Copyright (C) 2013-2015 Renesas Electronics Corporation
7 * Contact: Laurent Pinchart (laurent.pinchart@ideasonboard.com)
10 #include <drm/drm_atomic.h>
11 #include <drm/drm_atomic_helper.h>
12 #include <drm/drm_crtc.h>
13 #include <drm/drm_device.h>
14 #include <drm/drm_fb_cma_helper.h>
15 #include <drm/drm_fourcc.h>
16 #include <drm/drm_gem_cma_helper.h>
17 #include <drm/drm_plane_helper.h>
19 #include "rcar_du_drv.h"
20 #include "rcar_du_group.h"
21 #include "rcar_du_kms.h"
22 #include "rcar_du_plane.h"
23 #include "rcar_du_regs.h"
25 /* -----------------------------------------------------------------------------
26 * Atomic hardware plane allocator
28 * The hardware plane allocator is solely based on the atomic plane states
29 * without keeping any external state to avoid races between .atomic_check()
30 * and .atomic_commit().
32 * The core idea is to avoid using a free planes bitmask that would need to be
33 * shared between check and commit handlers with a collective knowledge based on
34 * the allocated hardware plane(s) for each KMS plane. The allocator then loops
35 * over all plane states to compute the free planes bitmask, allocates hardware
36 * planes based on that bitmask, and stores the result back in the plane states.
38 * For this to work we need to access the current state of planes not touched by
39 * the atomic update. To ensure that it won't be modified, we need to lock all
40 * planes using drm_atomic_get_plane_state(). This effectively serializes atomic
41 * updates from .atomic_check() up to completion (when swapping the states if
42 * the check step has succeeded) or rollback (when freeing the states if the
43 * check step has failed).
45 * Allocation is performed in the .atomic_check() handler and applied
46 * automatically when the core swaps the old and new states.
49 static bool rcar_du_plane_needs_realloc(
50 const struct rcar_du_plane_state *old_state,
51 const struct rcar_du_plane_state *new_state)
54 * Lowering the number of planes doesn't strictly require reallocation
55 * as the extra hardware plane will be freed when committing, but doing
56 * so could lead to more fragmentation.
58 if (!old_state->format ||
59 old_state->format->planes != new_state->format->planes)
62 /* Reallocate hardware planes if the source has changed. */
63 if (old_state->source != new_state->source)
69 static unsigned int rcar_du_plane_hwmask(struct rcar_du_plane_state *state)
73 if (state->hwindex == -1)
76 mask = 1 << state->hwindex;
77 if (state->format->planes == 2)
78 mask |= 1 << ((state->hwindex + 1) % 8);
84 * The R8A7790 DU can source frames directly from the VSP1 devices VSPD0 and
85 * VSPD1. VSPD0 feeds DU0/1 plane 0, and VSPD1 feeds either DU2 plane 0 or
88 * Allocate the correct fixed plane when sourcing frames from VSPD0 or VSPD1,
89 * and allocate planes in reverse index order otherwise to ensure maximum
90 * availability of planes 0 and 1.
92 * The caller is responsible for ensuring that the requested source is
93 * compatible with the DU revision.
95 static int rcar_du_plane_hwalloc(struct rcar_du_plane *plane,
96 struct rcar_du_plane_state *state,
99 unsigned int num_planes = state->format->planes;
103 if (state->source == RCAR_DU_PLANE_VSPD0) {
104 /* VSPD0 feeds plane 0 on DU0/1. */
105 if (plane->group->index != 0)
109 } else if (state->source == RCAR_DU_PLANE_VSPD1) {
110 /* VSPD1 feeds plane 1 on DU0/1 or plane 0 on DU2. */
111 fixed = plane->group->index == 0 ? 1 : 0;
115 return free & (1 << fixed) ? fixed : -EBUSY;
117 for (i = RCAR_DU_NUM_HW_PLANES - 1; i >= 0; --i) {
118 if (!(free & (1 << i)))
121 if (num_planes == 1 || free & (1 << ((i + 1) % 8)))
125 return i < 0 ? -EBUSY : i;
128 int rcar_du_atomic_check_planes(struct drm_device *dev,
129 struct drm_atomic_state *state)
131 struct rcar_du_device *rcdu = to_rcar_du_device(dev);
132 unsigned int group_freed_planes[RCAR_DU_MAX_GROUPS] = { 0, };
133 unsigned int group_free_planes[RCAR_DU_MAX_GROUPS] = { 0, };
134 bool needs_realloc = false;
135 unsigned int groups = 0;
137 struct drm_plane *drm_plane;
138 struct drm_plane_state *old_drm_plane_state;
139 struct drm_plane_state *new_drm_plane_state;
141 /* Check if hardware planes need to be reallocated. */
142 for_each_oldnew_plane_in_state(state, drm_plane, old_drm_plane_state,
143 new_drm_plane_state, i) {
144 struct rcar_du_plane_state *old_plane_state;
145 struct rcar_du_plane_state *new_plane_state;
146 struct rcar_du_plane *plane;
149 plane = to_rcar_plane(drm_plane);
150 old_plane_state = to_rcar_plane_state(old_drm_plane_state);
151 new_plane_state = to_rcar_plane_state(new_drm_plane_state);
153 dev_dbg(rcdu->dev, "%s: checking plane (%u,%tu)\n", __func__,
154 plane->group->index, plane - plane->group->planes);
157 * If the plane is being disabled we don't need to go through
158 * the full reallocation procedure. Just mark the hardware
161 if (!new_plane_state->format) {
162 dev_dbg(rcdu->dev, "%s: plane is being disabled\n",
164 index = plane - plane->group->planes;
165 group_freed_planes[plane->group->index] |= 1 << index;
166 new_plane_state->hwindex = -1;
171 * If the plane needs to be reallocated mark it as such, and
172 * mark the hardware plane(s) as free.
174 if (rcar_du_plane_needs_realloc(old_plane_state, new_plane_state)) {
175 dev_dbg(rcdu->dev, "%s: plane needs reallocation\n",
177 groups |= 1 << plane->group->index;
178 needs_realloc = true;
180 index = plane - plane->group->planes;
181 group_freed_planes[plane->group->index] |= 1 << index;
182 new_plane_state->hwindex = -1;
190 * Grab all plane states for the groups that need reallocation to ensure
191 * locking and avoid racy updates. This serializes the update operation,
192 * but there's not much we can do about it as that's the hardware
195 * Compute the used planes mask for each group at the same time to avoid
196 * looping over the planes separately later.
199 unsigned int index = ffs(groups) - 1;
200 struct rcar_du_group *group = &rcdu->groups[index];
201 unsigned int used_planes = 0;
203 dev_dbg(rcdu->dev, "%s: finding free planes for group %u\n",
206 for (i = 0; i < group->num_planes; ++i) {
207 struct rcar_du_plane *plane = &group->planes[i];
208 struct rcar_du_plane_state *new_plane_state;
209 struct drm_plane_state *s;
211 s = drm_atomic_get_plane_state(state, &plane->plane);
216 * If the plane has been freed in the above loop its
217 * hardware planes must not be added to the used planes
218 * bitmask. However, the current state doesn't reflect
219 * the free state yet, as we've modified the new state
220 * above. Use the local freed planes list to check for
221 * that condition instead.
223 if (group_freed_planes[index] & (1 << i)) {
225 "%s: plane (%u,%tu) has been freed, skipping\n",
226 __func__, plane->group->index,
227 plane - plane->group->planes);
231 new_plane_state = to_rcar_plane_state(s);
232 used_planes |= rcar_du_plane_hwmask(new_plane_state);
235 "%s: plane (%u,%tu) uses %u hwplanes (index %d)\n",
236 __func__, plane->group->index,
237 plane - plane->group->planes,
238 new_plane_state->format ?
239 new_plane_state->format->planes : 0,
240 new_plane_state->hwindex);
243 group_free_planes[index] = 0xff & ~used_planes;
244 groups &= ~(1 << index);
246 dev_dbg(rcdu->dev, "%s: group %u free planes mask 0x%02x\n",
247 __func__, index, group_free_planes[index]);
250 /* Reallocate hardware planes for each plane that needs it. */
251 for_each_oldnew_plane_in_state(state, drm_plane, old_drm_plane_state,
252 new_drm_plane_state, i) {
253 struct rcar_du_plane_state *old_plane_state;
254 struct rcar_du_plane_state *new_plane_state;
255 struct rcar_du_plane *plane;
256 unsigned int crtc_planes;
260 plane = to_rcar_plane(drm_plane);
261 old_plane_state = to_rcar_plane_state(old_drm_plane_state);
262 new_plane_state = to_rcar_plane_state(new_drm_plane_state);
264 dev_dbg(rcdu->dev, "%s: allocating plane (%u,%tu)\n", __func__,
265 plane->group->index, plane - plane->group->planes);
268 * Skip planes that are being disabled or don't need to be
271 if (!new_plane_state->format ||
272 !rcar_du_plane_needs_realloc(old_plane_state, new_plane_state))
276 * Try to allocate the plane from the free planes currently
277 * associated with the target CRTC to avoid restarting the CRTC
278 * group and thus minimize flicker. If it fails fall back to
279 * allocating from all free planes.
281 crtc_planes = to_rcar_crtc(new_plane_state->state.crtc)->index % 2
282 ? plane->group->dptsr_planes
283 : ~plane->group->dptsr_planes;
284 free = group_free_planes[plane->group->index];
286 idx = rcar_du_plane_hwalloc(plane, new_plane_state,
289 idx = rcar_du_plane_hwalloc(plane, new_plane_state,
292 dev_dbg(rcdu->dev, "%s: no available hardware plane\n",
297 dev_dbg(rcdu->dev, "%s: allocated %u hwplanes (index %u)\n",
298 __func__, new_plane_state->format->planes, idx);
300 new_plane_state->hwindex = idx;
302 group_free_planes[plane->group->index] &=
303 ~rcar_du_plane_hwmask(new_plane_state);
305 dev_dbg(rcdu->dev, "%s: group %u free planes mask 0x%02x\n",
306 __func__, plane->group->index,
307 group_free_planes[plane->group->index]);
313 /* -----------------------------------------------------------------------------
317 #define RCAR_DU_COLORKEY_NONE (0 << 24)
318 #define RCAR_DU_COLORKEY_SOURCE (1 << 24)
319 #define RCAR_DU_COLORKEY_MASK (1 << 24)
321 static void rcar_du_plane_write(struct rcar_du_group *rgrp,
322 unsigned int index, u32 reg, u32 data)
324 rcar_du_write(rgrp->dev, rgrp->mmio_offset + index * PLANE_OFF + reg,
328 static void rcar_du_plane_setup_scanout(struct rcar_du_group *rgrp,
329 const struct rcar_du_plane_state *state)
331 unsigned int src_x = state->state.src.x1 >> 16;
332 unsigned int src_y = state->state.src.y1 >> 16;
333 unsigned int index = state->hwindex;
338 interlaced = state->state.crtc->state->adjusted_mode.flags
339 & DRM_MODE_FLAG_INTERLACE;
341 if (state->source == RCAR_DU_PLANE_MEMORY) {
342 struct drm_framebuffer *fb = state->state.fb;
343 struct drm_gem_cma_object *gem;
346 if (state->format->planes == 2)
347 pitch = fb->pitches[0];
349 pitch = fb->pitches[0] * 8 / state->format->bpp;
351 for (i = 0; i < state->format->planes; ++i) {
352 gem = drm_fb_cma_get_gem_obj(fb, i);
353 dma[i] = gem->paddr + fb->offsets[i];
356 pitch = drm_rect_width(&state->state.src) >> 16;
362 * Memory pitch (expressed in pixels). Must be doubled for interlaced
363 * operation with 32bpp formats.
365 rcar_du_plane_write(rgrp, index, PnMWR,
366 (interlaced && state->format->bpp == 32) ?
370 * The Y position is expressed in raster line units and must be doubled
371 * for 32bpp formats, according to the R8A7790 datasheet. No mention of
372 * doubling the Y position is found in the R8A7779 datasheet, but the
373 * rule seems to apply there as well.
375 * Despite not being documented, doubling seem not to be needed when
376 * operating in interlaced mode.
378 * Similarly, for the second plane, NV12 and NV21 formats seem to
379 * require a halved Y position value, in both progressive and interlaced
382 rcar_du_plane_write(rgrp, index, PnSPXR, src_x);
383 rcar_du_plane_write(rgrp, index, PnSPYR, src_y *
384 (!interlaced && state->format->bpp == 32 ? 2 : 1));
386 rcar_du_plane_write(rgrp, index, PnDSA0R, dma[0]);
388 if (state->format->planes == 2) {
389 index = (index + 1) % 8;
391 rcar_du_plane_write(rgrp, index, PnMWR, pitch);
393 rcar_du_plane_write(rgrp, index, PnSPXR, src_x);
394 rcar_du_plane_write(rgrp, index, PnSPYR, src_y *
395 (state->format->bpp == 16 ? 2 : 1) / 2);
397 rcar_du_plane_write(rgrp, index, PnDSA0R, dma[1]);
401 static void rcar_du_plane_setup_mode(struct rcar_du_group *rgrp,
403 const struct rcar_du_plane_state *state)
409 * The PnALPHAR register controls alpha-blending in 16bpp formats
410 * (ARGB1555 and XRGB1555).
412 * For ARGB, set the alpha value to 0, and enable alpha-blending when
413 * the A bit is 0. This maps A=0 to alpha=0 and A=1 to alpha=255.
415 * For XRGB, set the alpha value to the plane-wide alpha value and
416 * enable alpha-blending regardless of the X bit value.
418 if (state->format->fourcc != DRM_FORMAT_XRGB1555)
419 rcar_du_plane_write(rgrp, index, PnALPHAR, PnALPHAR_ABIT_0);
421 rcar_du_plane_write(rgrp, index, PnALPHAR,
422 PnALPHAR_ABIT_X | state->state.alpha >> 8);
424 pnmr = PnMR_BM_MD | state->format->pnmr;
427 * Disable color keying when requested. YUV formats have the
428 * PnMR_SPIM_TP_OFF bit set in their pnmr field, disabling color keying
431 if ((state->colorkey & RCAR_DU_COLORKEY_MASK) == RCAR_DU_COLORKEY_NONE)
432 pnmr |= PnMR_SPIM_TP_OFF;
434 /* For packed YUV formats we need to select the U/V order. */
435 if (state->format->fourcc == DRM_FORMAT_YUYV)
436 pnmr |= PnMR_YCDF_YUYV;
438 rcar_du_plane_write(rgrp, index, PnMR, pnmr);
440 switch (state->format->fourcc) {
441 case DRM_FORMAT_RGB565:
442 colorkey = ((state->colorkey & 0xf80000) >> 8)
443 | ((state->colorkey & 0x00fc00) >> 5)
444 | ((state->colorkey & 0x0000f8) >> 3);
445 rcar_du_plane_write(rgrp, index, PnTC2R, colorkey);
448 case DRM_FORMAT_ARGB1555:
449 case DRM_FORMAT_XRGB1555:
450 colorkey = ((state->colorkey & 0xf80000) >> 9)
451 | ((state->colorkey & 0x00f800) >> 6)
452 | ((state->colorkey & 0x0000f8) >> 3);
453 rcar_du_plane_write(rgrp, index, PnTC2R, colorkey);
456 case DRM_FORMAT_XRGB8888:
457 case DRM_FORMAT_ARGB8888:
458 rcar_du_plane_write(rgrp, index, PnTC3R,
459 PnTC3R_CODE | (state->colorkey & 0xffffff));
464 static void rcar_du_plane_setup_format_gen2(struct rcar_du_group *rgrp,
466 const struct rcar_du_plane_state *state)
468 u32 ddcr2 = PnDDCR2_CODE;
474 * The data format is selected by the DDDF field in PnMR and the EDF
478 rcar_du_plane_setup_mode(rgrp, index, state);
480 if (state->format->planes == 2) {
481 if (state->hwindex != index) {
482 if (state->format->fourcc == DRM_FORMAT_NV12 ||
483 state->format->fourcc == DRM_FORMAT_NV21)
484 ddcr2 |= PnDDCR2_Y420;
486 if (state->format->fourcc == DRM_FORMAT_NV21)
487 ddcr2 |= PnDDCR2_NV21;
489 ddcr2 |= PnDDCR2_DIVU;
491 ddcr2 |= PnDDCR2_DIVY;
495 rcar_du_plane_write(rgrp, index, PnDDCR2, ddcr2);
497 ddcr4 = state->format->edf | PnDDCR4_CODE;
498 if (state->source != RCAR_DU_PLANE_MEMORY)
499 ddcr4 |= PnDDCR4_VSPS;
501 rcar_du_plane_write(rgrp, index, PnDDCR4, ddcr4);
504 static void rcar_du_plane_setup_format_gen3(struct rcar_du_group *rgrp,
506 const struct rcar_du_plane_state *state)
508 rcar_du_plane_write(rgrp, index, PnMR,
509 PnMR_SPIM_TP_OFF | state->format->pnmr);
511 rcar_du_plane_write(rgrp, index, PnDDCR4,
512 state->format->edf | PnDDCR4_CODE);
515 static void rcar_du_plane_setup_format(struct rcar_du_group *rgrp,
517 const struct rcar_du_plane_state *state)
519 struct rcar_du_device *rcdu = rgrp->dev;
520 const struct drm_rect *dst = &state->state.dst;
522 if (rcdu->info->gen < 3)
523 rcar_du_plane_setup_format_gen2(rgrp, index, state);
525 rcar_du_plane_setup_format_gen3(rgrp, index, state);
527 /* Destination position and size */
528 rcar_du_plane_write(rgrp, index, PnDSXR, drm_rect_width(dst));
529 rcar_du_plane_write(rgrp, index, PnDSYR, drm_rect_height(dst));
530 rcar_du_plane_write(rgrp, index, PnDPXR, dst->x1);
531 rcar_du_plane_write(rgrp, index, PnDPYR, dst->y1);
533 if (rcdu->info->gen < 3) {
534 /* Wrap-around and blinking, disabled */
535 rcar_du_plane_write(rgrp, index, PnWASPR, 0);
536 rcar_du_plane_write(rgrp, index, PnWAMWR, 4095);
537 rcar_du_plane_write(rgrp, index, PnBTR, 0);
538 rcar_du_plane_write(rgrp, index, PnMLR, 0);
542 void __rcar_du_plane_setup(struct rcar_du_group *rgrp,
543 const struct rcar_du_plane_state *state)
545 struct rcar_du_device *rcdu = rgrp->dev;
547 rcar_du_plane_setup_format(rgrp, state->hwindex, state);
548 if (state->format->planes == 2)
549 rcar_du_plane_setup_format(rgrp, (state->hwindex + 1) % 8,
552 if (rcdu->info->gen >= 3)
555 rcar_du_plane_setup_scanout(rgrp, state);
557 if (state->source == RCAR_DU_PLANE_VSPD1) {
558 unsigned int vspd1_sink = rgrp->index ? 2 : 0;
560 if (rcdu->vspd1_sink != vspd1_sink) {
561 rcdu->vspd1_sink = vspd1_sink;
562 rcar_du_set_dpad0_vsp1_routing(rcdu);
565 * Changes to the VSP1 sink take effect on DRES and thus
566 * need a restart of the group.
568 rgrp->need_restart = true;
573 int __rcar_du_plane_atomic_check(struct drm_plane *plane,
574 struct drm_plane_state *state,
575 const struct rcar_du_format_info **format)
577 struct drm_device *dev = plane->dev;
578 struct drm_crtc_state *crtc_state;
583 * The visible field is not reset by the DRM core but only
584 * updated by drm_plane_helper_check_state(), set it manually.
586 state->visible = false;
591 crtc_state = drm_atomic_get_crtc_state(state->state, state->crtc);
592 if (IS_ERR(crtc_state))
593 return PTR_ERR(crtc_state);
595 ret = drm_atomic_helper_check_plane_state(state, crtc_state,
596 DRM_PLANE_HELPER_NO_SCALING,
597 DRM_PLANE_HELPER_NO_SCALING,
602 if (!state->visible) {
607 *format = rcar_du_format_info(state->fb->format->format);
608 if (*format == NULL) {
609 dev_dbg(dev->dev, "%s: unsupported format %08x\n", __func__,
610 state->fb->format->format);
617 static int rcar_du_plane_atomic_check(struct drm_plane *plane,
618 struct drm_atomic_state *state)
620 struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
622 struct rcar_du_plane_state *rstate = to_rcar_plane_state(new_plane_state);
624 return __rcar_du_plane_atomic_check(plane, new_plane_state,
628 static void rcar_du_plane_atomic_update(struct drm_plane *plane,
629 struct drm_atomic_state *state)
631 struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state, plane);
632 struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state, plane);
633 struct rcar_du_plane *rplane = to_rcar_plane(plane);
634 struct rcar_du_plane_state *old_rstate;
635 struct rcar_du_plane_state *new_rstate;
637 if (!new_state->visible)
640 rcar_du_plane_setup(rplane);
643 * Check whether the source has changed from memory to live source or
644 * from live source to memory. The source has been configured by the
645 * VSPS bit in the PnDDCR4 register. Although the datasheet states that
646 * the bit is updated during vertical blanking, it seems that updates
647 * only occur when the DU group is held in reset through the DSYSR.DRES
648 * bit. We thus need to restart the group if the source changes.
650 old_rstate = to_rcar_plane_state(old_state);
651 new_rstate = to_rcar_plane_state(new_state);
653 if ((old_rstate->source == RCAR_DU_PLANE_MEMORY) !=
654 (new_rstate->source == RCAR_DU_PLANE_MEMORY))
655 rplane->group->need_restart = true;
658 static const struct drm_plane_helper_funcs rcar_du_plane_helper_funcs = {
659 .atomic_check = rcar_du_plane_atomic_check,
660 .atomic_update = rcar_du_plane_atomic_update,
663 static struct drm_plane_state *
664 rcar_du_plane_atomic_duplicate_state(struct drm_plane *plane)
666 struct rcar_du_plane_state *state;
667 struct rcar_du_plane_state *copy;
669 if (WARN_ON(!plane->state))
672 state = to_rcar_plane_state(plane->state);
673 copy = kmemdup(state, sizeof(*state), GFP_KERNEL);
677 __drm_atomic_helper_plane_duplicate_state(plane, ©->state);
682 static void rcar_du_plane_atomic_destroy_state(struct drm_plane *plane,
683 struct drm_plane_state *state)
685 __drm_atomic_helper_plane_destroy_state(state);
686 kfree(to_rcar_plane_state(state));
689 static void rcar_du_plane_reset(struct drm_plane *plane)
691 struct rcar_du_plane_state *state;
694 rcar_du_plane_atomic_destroy_state(plane, plane->state);
698 state = kzalloc(sizeof(*state), GFP_KERNEL);
702 __drm_atomic_helper_plane_reset(plane, &state->state);
705 state->source = RCAR_DU_PLANE_MEMORY;
706 state->colorkey = RCAR_DU_COLORKEY_NONE;
709 static int rcar_du_plane_atomic_set_property(struct drm_plane *plane,
710 struct drm_plane_state *state,
711 struct drm_property *property,
714 struct rcar_du_plane_state *rstate = to_rcar_plane_state(state);
715 struct rcar_du_device *rcdu = to_rcar_plane(plane)->group->dev;
717 if (property == rcdu->props.colorkey)
718 rstate->colorkey = val;
725 static int rcar_du_plane_atomic_get_property(struct drm_plane *plane,
726 const struct drm_plane_state *state, struct drm_property *property,
729 const struct rcar_du_plane_state *rstate =
730 container_of(state, const struct rcar_du_plane_state, state);
731 struct rcar_du_device *rcdu = to_rcar_plane(plane)->group->dev;
733 if (property == rcdu->props.colorkey)
734 *val = rstate->colorkey;
741 static const struct drm_plane_funcs rcar_du_plane_funcs = {
742 .update_plane = drm_atomic_helper_update_plane,
743 .disable_plane = drm_atomic_helper_disable_plane,
744 .reset = rcar_du_plane_reset,
745 .destroy = drm_plane_cleanup,
746 .atomic_duplicate_state = rcar_du_plane_atomic_duplicate_state,
747 .atomic_destroy_state = rcar_du_plane_atomic_destroy_state,
748 .atomic_set_property = rcar_du_plane_atomic_set_property,
749 .atomic_get_property = rcar_du_plane_atomic_get_property,
752 static const uint32_t formats[] = {
765 int rcar_du_planes_init(struct rcar_du_group *rgrp)
767 struct rcar_du_device *rcdu = rgrp->dev;
773 * Create one primary plane per CRTC in this group and seven overlay
776 rgrp->num_planes = rgrp->num_crtcs + 7;
778 crtcs = ((1 << rcdu->num_crtcs) - 1) & (3 << (2 * rgrp->index));
780 for (i = 0; i < rgrp->num_planes; ++i) {
781 enum drm_plane_type type = i < rgrp->num_crtcs
782 ? DRM_PLANE_TYPE_PRIMARY
783 : DRM_PLANE_TYPE_OVERLAY;
784 struct rcar_du_plane *plane = &rgrp->planes[i];
788 ret = drm_universal_plane_init(&rcdu->ddev, &plane->plane,
789 crtcs, &rcar_du_plane_funcs,
790 formats, ARRAY_SIZE(formats),
795 drm_plane_helper_add(&plane->plane,
796 &rcar_du_plane_helper_funcs);
798 drm_plane_create_alpha_property(&plane->plane);
800 if (type == DRM_PLANE_TYPE_PRIMARY) {
801 drm_plane_create_zpos_immutable_property(&plane->plane,
804 drm_object_attach_property(&plane->plane.base,
805 rcdu->props.colorkey,
806 RCAR_DU_COLORKEY_NONE);
807 drm_plane_create_zpos_property(&plane->plane, 1, 1, 7);