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