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
= dev
->dev_private
;
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)
553 rcar_du_plane_setup_scanout(rgrp
, state
);
555 if (state
->source
== RCAR_DU_PLANE_VSPD1
) {
556 unsigned int vspd1_sink
= rgrp
->index
? 2 : 0;
558 if (rcdu
->vspd1_sink
!= vspd1_sink
) {
559 rcdu
->vspd1_sink
= vspd1_sink
;
560 rcar_du_set_dpad0_vsp1_routing(rcdu
);
565 int __rcar_du_plane_atomic_check(struct drm_plane
*plane
,
566 struct drm_plane_state
*state
,
567 const struct rcar_du_format_info
**format
)
569 struct drm_device
*dev
= plane
->dev
;
570 struct drm_crtc_state
*crtc_state
;
575 * The visible field is not reset by the DRM core but only
576 * updated by drm_plane_helper_check_state(), set it manually.
578 state
->visible
= false;
583 crtc_state
= drm_atomic_get_crtc_state(state
->state
, state
->crtc
);
584 if (IS_ERR(crtc_state
))
585 return PTR_ERR(crtc_state
);
587 ret
= drm_atomic_helper_check_plane_state(state
, crtc_state
,
588 DRM_PLANE_HELPER_NO_SCALING
,
589 DRM_PLANE_HELPER_NO_SCALING
,
594 if (!state
->visible
) {
599 *format
= rcar_du_format_info(state
->fb
->format
->format
);
600 if (*format
== NULL
) {
601 dev_dbg(dev
->dev
, "%s: unsupported format %08x\n", __func__
,
602 state
->fb
->format
->format
);
609 static int rcar_du_plane_atomic_check(struct drm_plane
*plane
,
610 struct drm_plane_state
*state
)
612 struct rcar_du_plane_state
*rstate
= to_rcar_plane_state(state
);
614 return __rcar_du_plane_atomic_check(plane
, state
, &rstate
->format
);
617 static void rcar_du_plane_atomic_update(struct drm_plane
*plane
,
618 struct drm_plane_state
*old_state
)
620 struct rcar_du_plane
*rplane
= to_rcar_plane(plane
);
621 struct rcar_du_plane_state
*old_rstate
;
622 struct rcar_du_plane_state
*new_rstate
;
624 if (!plane
->state
->visible
)
627 rcar_du_plane_setup(rplane
);
630 * Check whether the source has changed from memory to live source or
631 * from live source to memory. The source has been configured by the
632 * VSPS bit in the PnDDCR4 register. Although the datasheet states that
633 * the bit is updated during vertical blanking, it seems that updates
634 * only occur when the DU group is held in reset through the DSYSR.DRES
635 * bit. We thus need to restart the group if the source changes.
637 old_rstate
= to_rcar_plane_state(old_state
);
638 new_rstate
= to_rcar_plane_state(plane
->state
);
640 if ((old_rstate
->source
== RCAR_DU_PLANE_MEMORY
) !=
641 (new_rstate
->source
== RCAR_DU_PLANE_MEMORY
))
642 rplane
->group
->need_restart
= true;
645 static const struct drm_plane_helper_funcs rcar_du_plane_helper_funcs
= {
646 .atomic_check
= rcar_du_plane_atomic_check
,
647 .atomic_update
= rcar_du_plane_atomic_update
,
650 static struct drm_plane_state
*
651 rcar_du_plane_atomic_duplicate_state(struct drm_plane
*plane
)
653 struct rcar_du_plane_state
*state
;
654 struct rcar_du_plane_state
*copy
;
656 if (WARN_ON(!plane
->state
))
659 state
= to_rcar_plane_state(plane
->state
);
660 copy
= kmemdup(state
, sizeof(*state
), GFP_KERNEL
);
664 __drm_atomic_helper_plane_duplicate_state(plane
, ©
->state
);
669 static void rcar_du_plane_atomic_destroy_state(struct drm_plane
*plane
,
670 struct drm_plane_state
*state
)
672 __drm_atomic_helper_plane_destroy_state(state
);
673 kfree(to_rcar_plane_state(state
));
676 static void rcar_du_plane_reset(struct drm_plane
*plane
)
678 struct rcar_du_plane_state
*state
;
681 rcar_du_plane_atomic_destroy_state(plane
, plane
->state
);
685 state
= kzalloc(sizeof(*state
), GFP_KERNEL
);
689 __drm_atomic_helper_plane_reset(plane
, &state
->state
);
692 state
->source
= RCAR_DU_PLANE_MEMORY
;
693 state
->colorkey
= RCAR_DU_COLORKEY_NONE
;
694 state
->state
.zpos
= plane
->type
== DRM_PLANE_TYPE_PRIMARY
? 0 : 1;
697 static int rcar_du_plane_atomic_set_property(struct drm_plane
*plane
,
698 struct drm_plane_state
*state
,
699 struct drm_property
*property
,
702 struct rcar_du_plane_state
*rstate
= to_rcar_plane_state(state
);
703 struct rcar_du_device
*rcdu
= to_rcar_plane(plane
)->group
->dev
;
705 if (property
== rcdu
->props
.colorkey
)
706 rstate
->colorkey
= val
;
713 static int rcar_du_plane_atomic_get_property(struct drm_plane
*plane
,
714 const struct drm_plane_state
*state
, struct drm_property
*property
,
717 const struct rcar_du_plane_state
*rstate
=
718 container_of(state
, const struct rcar_du_plane_state
, state
);
719 struct rcar_du_device
*rcdu
= to_rcar_plane(plane
)->group
->dev
;
721 if (property
== rcdu
->props
.colorkey
)
722 *val
= rstate
->colorkey
;
729 static const struct drm_plane_funcs rcar_du_plane_funcs
= {
730 .update_plane
= drm_atomic_helper_update_plane
,
731 .disable_plane
= drm_atomic_helper_disable_plane
,
732 .reset
= rcar_du_plane_reset
,
733 .destroy
= drm_plane_cleanup
,
734 .atomic_duplicate_state
= rcar_du_plane_atomic_duplicate_state
,
735 .atomic_destroy_state
= rcar_du_plane_atomic_destroy_state
,
736 .atomic_set_property
= rcar_du_plane_atomic_set_property
,
737 .atomic_get_property
= rcar_du_plane_atomic_get_property
,
740 static const uint32_t formats
[] = {
753 int rcar_du_planes_init(struct rcar_du_group
*rgrp
)
755 struct rcar_du_device
*rcdu
= rgrp
->dev
;
761 * Create one primary plane per CRTC in this group and seven overlay
764 rgrp
->num_planes
= rgrp
->num_crtcs
+ 7;
766 crtcs
= ((1 << rcdu
->num_crtcs
) - 1) & (3 << (2 * rgrp
->index
));
768 for (i
= 0; i
< rgrp
->num_planes
; ++i
) {
769 enum drm_plane_type type
= i
< rgrp
->num_crtcs
770 ? DRM_PLANE_TYPE_PRIMARY
771 : DRM_PLANE_TYPE_OVERLAY
;
772 struct rcar_du_plane
*plane
= &rgrp
->planes
[i
];
776 ret
= drm_universal_plane_init(rcdu
->ddev
, &plane
->plane
, crtcs
,
777 &rcar_du_plane_funcs
, formats
,
783 drm_plane_helper_add(&plane
->plane
,
784 &rcar_du_plane_helper_funcs
);
786 drm_plane_create_alpha_property(&plane
->plane
);
788 if (type
== DRM_PLANE_TYPE_PRIMARY
) {
789 drm_plane_create_zpos_immutable_property(&plane
->plane
,
792 drm_object_attach_property(&plane
->plane
.base
,
793 rcdu
->props
.colorkey
,
794 RCAR_DU_COLORKEY_NONE
);
795 drm_plane_create_zpos_property(&plane
->plane
, 1, 1, 7);