drivers/gpu/drm/rcar-du/rcar_du_plane.c

   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
  53 static 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
  73 static 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  */
  99 static 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
 132 int 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
 325 static 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
 332 static 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_x >> 16;
 336         unsigned int src_y = state->state.src_y >> 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 = state->state.src_w >> 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
 405 static 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
 468 static 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
 508 static 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
 519 static 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
 525         if (rcdu->info->gen < 3)
 526                 rcar_du_plane_setup_format_gen2(rgrp, index, state);
 527         else
 528                 rcar_du_plane_setup_format_gen3(rgrp, index, state);
 529
 530         /* Destination position and size */
 531         rcar_du_plane_write(rgrp, index, PnDSXR, state->state.crtc_w);
 532         rcar_du_plane_write(rgrp, index, PnDSYR, state->state.crtc_h);
 533         rcar_du_plane_write(rgrp, index, PnDPXR, state->state.crtc_x);
 534         rcar_du_plane_write(rgrp, index, PnDPYR, state->state.crtc_y);
 535
 536         if (rcdu->info->gen < 3) {
 537                 /* Wrap-around and blinking, disabled */
 538                 rcar_du_plane_write(rgrp, index, PnWASPR, 0);
 539                 rcar_du_plane_write(rgrp, index, PnWAMWR, 4095);
 540                 rcar_du_plane_write(rgrp, index, PnBTR, 0);
 541                 rcar_du_plane_write(rgrp, index, PnMLR, 0);
 542         }
 543 }
 544
 545 void __rcar_du_plane_setup(struct rcar_du_group *rgrp,
 546                            const struct rcar_du_plane_state *state)
 547 {
 548         struct rcar_du_device *rcdu = rgrp->dev;
 549
 550         rcar_du_plane_setup_format(rgrp, state->hwindex, state);
 551         if (state->format->planes == 2)
 552                 rcar_du_plane_setup_format(rgrp, (state->hwindex + 1) % 8,
 553                                            state);
 554
 555         if (rcdu->info->gen < 3)
 556                 rcar_du_plane_setup_scanout(rgrp, state);
 557
 558         if (state->source == RCAR_DU_PLANE_VSPD1) {
 559                 unsigned int vspd1_sink = rgrp->index ? 2 : 0;
 560
 561                 if (rcdu->vspd1_sink != vspd1_sink) {
 562                         rcdu->vspd1_sink = vspd1_sink;
 563                         rcar_du_set_dpad0_vsp1_routing(rcdu);
 564                 }
 565         }
 566 }
 567
 568 static int rcar_du_plane_atomic_check(struct drm_plane *plane,
 569                                       struct drm_plane_state *state)
 570 {
 571         struct rcar_du_plane_state *rstate = to_rcar_plane_state(state);
 572         struct rcar_du_plane *rplane = to_rcar_plane(plane);
 573         struct rcar_du_device *rcdu = rplane->group->dev;
 574
 575         if (!state->fb || !state->crtc) {
 576                 rstate->format = NULL;
 577                 return 0;
 578         }
 579
 580         if (state->src_w >> 16 != state->crtc_w ||
 581             state->src_h >> 16 != state->crtc_h) {
 582                 dev_dbg(rcdu->dev, "%s: scaling not supported\n", __func__);
 583                 return -EINVAL;
 584         }
 585
 586         rstate->format = rcar_du_format_info(state->fb->format->format);
 587         if (rstate->format == NULL) {
 588                 dev_dbg(rcdu->dev, "%s: unsupported format %08x\n", __func__,
 589                         state->fb->format->format);
 590                 return -EINVAL;
 591         }
 592
 593         return 0;
 594 }
 595
 596 static void rcar_du_plane_atomic_update(struct drm_plane *plane,
 597                                         struct drm_plane_state *old_state)
 598 {
 599         struct rcar_du_plane *rplane = to_rcar_plane(plane);
 600         struct rcar_du_plane_state *old_rstate;
 601         struct rcar_du_plane_state *new_rstate;
 602
 603         if (!plane->state->crtc)
 604                 return;
 605
 606         rcar_du_plane_setup(rplane);
 607
 608         /*
 609          * Check whether the source has changed from memory to live source or
 610          * from live source to memory. The source has been configured by the
 611          * VSPS bit in the PnDDCR4 register. Although the datasheet states that
 612          * the bit is updated during vertical blanking, it seems that updates
 613          * only occur when the DU group is held in reset through the DSYSR.DRES
 614          * bit. We thus need to restart the group if the source changes.
 615          */
 616         old_rstate = to_rcar_plane_state(old_state);
 617         new_rstate = to_rcar_plane_state(plane->state);
 618
 619         if ((old_rstate->source == RCAR_DU_PLANE_MEMORY) !=
 620             (new_rstate->source == RCAR_DU_PLANE_MEMORY))
 621                 rplane->group->need_restart = true;
 622 }
 623
 624 static const struct drm_plane_helper_funcs rcar_du_plane_helper_funcs = {
 625         .atomic_check = rcar_du_plane_atomic_check,
 626         .atomic_update = rcar_du_plane_atomic_update,
 627 };
 628
 629 static struct drm_plane_state *
 630 rcar_du_plane_atomic_duplicate_state(struct drm_plane *plane)
 631 {
 632         struct rcar_du_plane_state *state;
 633         struct rcar_du_plane_state *copy;
 634
 635         if (WARN_ON(!plane->state))
 636                 return NULL;
 637
 638         state = to_rcar_plane_state(plane->state);
 639         copy = kmemdup(state, sizeof(*state), GFP_KERNEL);
 640         if (copy == NULL)
 641                 return NULL;
 642
 643         __drm_atomic_helper_plane_duplicate_state(plane, &copy->state);
 644
 645         return &copy->state;
 646 }
 647
 648 static void rcar_du_plane_atomic_destroy_state(struct drm_plane *plane,
 649                                                struct drm_plane_state *state)
 650 {
 651         __drm_atomic_helper_plane_destroy_state(state);
 652         kfree(to_rcar_plane_state(state));
 653 }
 654
 655 static void rcar_du_plane_reset(struct drm_plane *plane)
 656 {
 657         struct rcar_du_plane_state *state;
 658
 659         if (plane->state) {
 660                 rcar_du_plane_atomic_destroy_state(plane, plane->state);
 661                 plane->state = NULL;
 662         }
 663
 664         state = kzalloc(sizeof(*state), GFP_KERNEL);
 665         if (state == NULL)
 666                 return;
 667
 668         state->hwindex = -1;
 669         state->source = RCAR_DU_PLANE_MEMORY;
 670         state->alpha = 255;
 671         state->colorkey = RCAR_DU_COLORKEY_NONE;
 672         state->state.zpos = plane->type == DRM_PLANE_TYPE_PRIMARY ? 0 : 1;
 673
 674         plane->state = &state->state;
 675         plane->state->plane = plane;
 676 }
 677
 678 static int rcar_du_plane_atomic_set_property(struct drm_plane *plane,
 679                                              struct drm_plane_state *state,
 680                                              struct drm_property *property,
 681                                              uint64_t val)
 682 {
 683         struct rcar_du_plane_state *rstate = to_rcar_plane_state(state);
 684         struct rcar_du_device *rcdu = to_rcar_plane(plane)->group->dev;
 685
 686         if (property == rcdu->props.alpha)
 687                 rstate->alpha = val;
 688         else if (property == rcdu->props.colorkey)
 689                 rstate->colorkey = val;
 690         else
 691                 return -EINVAL;
 692
 693         return 0;
 694 }
 695
 696 static int rcar_du_plane_atomic_get_property(struct drm_plane *plane,
 697         const struct drm_plane_state *state, struct drm_property *property,
 698         uint64_t *val)
 699 {
 700         const struct rcar_du_plane_state *rstate =
 701                 container_of(state, const struct rcar_du_plane_state, state);
 702         struct rcar_du_device *rcdu = to_rcar_plane(plane)->group->dev;
 703
 704         if (property == rcdu->props.alpha)
 705                 *val = rstate->alpha;
 706         else if (property == rcdu->props.colorkey)
 707                 *val = rstate->colorkey;
 708         else
 709                 return -EINVAL;
 710
 711         return 0;
 712 }
 713
 714 static const struct drm_plane_funcs rcar_du_plane_funcs = {
 715         .update_plane = drm_atomic_helper_update_plane,
 716         .disable_plane = drm_atomic_helper_disable_plane,
 717         .reset = rcar_du_plane_reset,
 718         .destroy = drm_plane_cleanup,
 719         .atomic_duplicate_state = rcar_du_plane_atomic_duplicate_state,
 720         .atomic_destroy_state = rcar_du_plane_atomic_destroy_state,
 721         .atomic_set_property = rcar_du_plane_atomic_set_property,
 722         .atomic_get_property = rcar_du_plane_atomic_get_property,
 723 };
 724
 725 static const uint32_t formats[] = {
 726         DRM_FORMAT_RGB565,
 727         DRM_FORMAT_ARGB1555,
 728         DRM_FORMAT_XRGB1555,
 729         DRM_FORMAT_XRGB8888,
 730         DRM_FORMAT_ARGB8888,
 731         DRM_FORMAT_UYVY,
 732         DRM_FORMAT_YUYV,
 733         DRM_FORMAT_NV12,
 734         DRM_FORMAT_NV21,
 735         DRM_FORMAT_NV16,
 736 };
 737
 738 int rcar_du_planes_init(struct rcar_du_group *rgrp)
 739 {
 740         struct rcar_du_device *rcdu = rgrp->dev;
 741         unsigned int crtcs;
 742         unsigned int i;
 743         int ret;
 744
 745          /*
 746           * Create one primary plane per CRTC in this group and seven overlay
 747           * planes.
 748           */
 749         rgrp->num_planes = rgrp->num_crtcs + 7;
 750
 751         crtcs = ((1 << rcdu->num_crtcs) - 1) & (3 << (2 * rgrp->index));
 752
 753         for (i = 0; i < rgrp->num_planes; ++i) {
 754                 enum drm_plane_type type = i < rgrp->num_crtcs
 755                                          ? DRM_PLANE_TYPE_PRIMARY
 756                                          : DRM_PLANE_TYPE_OVERLAY;
 757                 struct rcar_du_plane *plane = &rgrp->planes[i];
 758
 759                 plane->group = rgrp;
 760
 761                 ret = drm_universal_plane_init(rcdu->ddev, &plane->plane, crtcs,
 762                                                &rcar_du_plane_funcs, formats,
 763                                                ARRAY_SIZE(formats),
 764                                                NULL, type, NULL);
 765                 if (ret < 0)
 766                         return ret;
 767
 768                 drm_plane_helper_add(&plane->plane,
 769                                      &rcar_du_plane_helper_funcs);
 770
 771                 if (type == DRM_PLANE_TYPE_PRIMARY)
 772                         continue;
 773
 774                 drm_object_attach_property(&plane->plane.base,
 775                                            rcdu->props.alpha, 255);
 776                 drm_object_attach_property(&plane->plane.base,
 777                                            rcdu->props.colorkey,
 778                                            RCAR_DU_COLORKEY_NONE);
 779                 drm_plane_create_zpos_property(&plane->plane, 1, 1, 7);
 780         }
 781
 782         return 0;
 783 }