linux/drivers/gpu/drm/rcar-du/rcar_du_plane.c
<<
>>
Prefs
   1/*
   2 * rcar_du_plane.c  --  R-Car Display Unit Planes
   3 *
   4 * Copyright (C) 2013-2015 Renesas Electronics Corporation
   5 *
   6 * Contact: Laurent Pinchart (laurent.pinchart@ideasonboard.com)
   7 *
   8 * This program is free software; you can redistribute it and/or modify
   9 * it under the terms of the GNU General Public License as published by
  10 * the Free Software Foundation; either version 2 of the License, or
  11 * (at your option) any later version.
  12 */
  13
  14#include <drm/drmP.h>
  15#include <drm/drm_atomic.h>
  16#include <drm/drm_atomic_helper.h>
  17#include <drm/drm_crtc.h>
  18#include <drm/drm_crtc_helper.h>
  19#include <drm/drm_fb_cma_helper.h>
  20#include <drm/drm_gem_cma_helper.h>
  21#include <drm/drm_plane_helper.h>
  22
  23#include "rcar_du_drv.h"
  24#include "rcar_du_group.h"
  25#include "rcar_du_kms.h"
  26#include "rcar_du_plane.h"
  27#include "rcar_du_regs.h"
  28
  29/* -----------------------------------------------------------------------------
  30 * Atomic hardware plane allocator
  31 *
  32 * The hardware plane allocator is solely based on the atomic plane states
  33 * without keeping any external state to avoid races between .atomic_check()
  34 * and .atomic_commit().
  35 *
  36 * The core idea is to avoid using a free planes bitmask that would need to be
  37 * shared between check and commit handlers with a collective knowledge based on
  38 * the allocated hardware plane(s) for each KMS plane. The allocator then loops
  39 * over all plane states to compute the free planes bitmask, allocates hardware
  40 * planes based on that bitmask, and stores the result back in the plane states.
  41 *
  42 * For this to work we need to access the current state of planes not touched by
  43 * the atomic update. To ensure that it won't be modified, we need to lock all
  44 * planes using drm_atomic_get_plane_state(). This effectively serializes atomic
  45 * updates from .atomic_check() up to completion (when swapping the states if
  46 * the check step has succeeded) or rollback (when freeing the states if the
  47 * check step has failed).
  48 *
  49 * Allocation is performed in the .atomic_check() handler and applied
  50 * automatically when the core swaps the old and new states.
  51 */
  52
  53static bool rcar_du_plane_needs_realloc(
  54                                const struct rcar_du_plane_state *old_state,
  55                                const struct rcar_du_plane_state *new_state)
  56{
  57        /*
  58         * Lowering the number of planes doesn't strictly require reallocation
  59         * as the extra hardware plane will be freed when committing, but doing
  60         * so could lead to more fragmentation.
  61         */
  62        if (!old_state->format ||
  63            old_state->format->planes != new_state->format->planes)
  64                return true;
  65
  66        /* Reallocate hardware planes if the source has changed. */
  67        if (old_state->source != new_state->source)
  68                return true;
  69
  70        return false;
  71}
  72
  73static unsigned int rcar_du_plane_hwmask(struct rcar_du_plane_state *state)
  74{
  75        unsigned int mask;
  76
  77        if (state->hwindex == -1)
  78                return 0;
  79
  80        mask = 1 << state->hwindex;
  81        if (state->format->planes == 2)
  82                mask |= 1 << ((state->hwindex + 1) % 8);
  83
  84        return mask;
  85}
  86
  87/*
  88 * The R8A7790 DU can source frames directly from the VSP1 devices VSPD0 and
  89 * VSPD1. VSPD0 feeds DU0/1 plane 0, and VSPD1 feeds either DU2 plane 0 or
  90 * DU0/1 plane 1.
  91 *
  92 * Allocate the correct fixed plane when sourcing frames from VSPD0 or VSPD1,
  93 * and allocate planes in reverse index order otherwise to ensure maximum
  94 * availability of planes 0 and 1.
  95 *
  96 * The caller is responsible for ensuring that the requested source is
  97 * compatible with the DU revision.
  98 */
  99static int rcar_du_plane_hwalloc(struct rcar_du_plane *plane,
 100                                 struct rcar_du_plane_state *state,
 101                                 unsigned int free)
 102{
 103        unsigned int num_planes = state->format->planes;
 104        int fixed = -1;
 105        int i;
 106
 107        if (state->source == RCAR_DU_PLANE_VSPD0) {
 108                /* VSPD0 feeds plane 0 on DU0/1. */
 109                if (plane->group->index != 0)
 110                        return -EINVAL;
 111
 112                fixed = 0;
 113        } else if (state->source == RCAR_DU_PLANE_VSPD1) {
 114                /* VSPD1 feeds plane 1 on DU0/1 or plane 0 on DU2. */
 115                fixed = plane->group->index == 0 ? 1 : 0;
 116        }
 117
 118        if (fixed >= 0)
 119                return free & (1 << fixed) ? fixed : -EBUSY;
 120
 121        for (i = RCAR_DU_NUM_HW_PLANES - 1; i >= 0; --i) {
 122                if (!(free & (1 << i)))
 123                        continue;
 124
 125                if (num_planes == 1 || free & (1 << ((i + 1) % 8)))
 126                        break;
 127        }
 128
 129        return i < 0 ? -EBUSY : i;
 130}
 131
 132int rcar_du_atomic_check_planes(struct drm_device *dev,
 133                                struct drm_atomic_state *state)
 134{
 135        struct rcar_du_device *rcdu = dev->dev_private;
 136        unsigned int group_freed_planes[RCAR_DU_MAX_GROUPS] = { 0, };
 137        unsigned int group_free_planes[RCAR_DU_MAX_GROUPS] = { 0, };
 138        bool needs_realloc = false;
 139        unsigned int groups = 0;
 140        unsigned int i;
 141        struct drm_plane *drm_plane;
 142        struct drm_plane_state *old_drm_plane_state;
 143        struct drm_plane_state *new_drm_plane_state;
 144
 145        /* Check if hardware planes need to be reallocated. */
 146        for_each_oldnew_plane_in_state(state, drm_plane, old_drm_plane_state,
 147                                       new_drm_plane_state, i) {
 148                struct rcar_du_plane_state *old_plane_state;
 149                struct rcar_du_plane_state *new_plane_state;
 150                struct rcar_du_plane *plane;
 151                unsigned int index;
 152
 153                plane = to_rcar_plane(drm_plane);
 154                old_plane_state = to_rcar_plane_state(old_drm_plane_state);
 155                new_plane_state = to_rcar_plane_state(new_drm_plane_state);
 156
 157                dev_dbg(rcdu->dev, "%s: checking plane (%u,%tu)\n", __func__,
 158                        plane->group->index, plane - plane->group->planes);
 159
 160                /*
 161                 * If the plane is being disabled we don't need to go through
 162                 * the full reallocation procedure. Just mark the hardware
 163                 * plane(s) as freed.
 164                 */
 165                if (!new_plane_state->format) {
 166                        dev_dbg(rcdu->dev, "%s: plane is being disabled\n",
 167                                __func__);
 168                        index = plane - plane->group->planes;
 169                        group_freed_planes[plane->group->index] |= 1 << index;
 170                        new_plane_state->hwindex = -1;
 171                        continue;
 172                }
 173
 174                /*
 175                 * If the plane needs to be reallocated mark it as such, and
 176                 * mark the hardware plane(s) as free.
 177                 */
 178                if (rcar_du_plane_needs_realloc(old_plane_state, new_plane_state)) {
 179                        dev_dbg(rcdu->dev, "%s: plane needs reallocation\n",
 180                                __func__);
 181                        groups |= 1 << plane->group->index;
 182                        needs_realloc = true;
 183
 184                        index = plane - plane->group->planes;
 185                        group_freed_planes[plane->group->index] |= 1 << index;
 186                        new_plane_state->hwindex = -1;
 187                }
 188        }
 189
 190        if (!needs_realloc)
 191                return 0;
 192
 193        /*
 194         * Grab all plane states for the groups that need reallocation to ensure
 195         * locking and avoid racy updates. This serializes the update operation,
 196         * but there's not much we can do about it as that's the hardware
 197         * design.
 198         *
 199         * Compute the used planes mask for each group at the same time to avoid
 200         * looping over the planes separately later.
 201         */
 202        while (groups) {
 203                unsigned int index = ffs(groups) - 1;
 204                struct rcar_du_group *group = &rcdu->groups[index];
 205                unsigned int used_planes = 0;
 206
 207                dev_dbg(rcdu->dev, "%s: finding free planes for group %u\n",
 208                        __func__, index);
 209
 210                for (i = 0; i < group->num_planes; ++i) {
 211                        struct rcar_du_plane *plane = &group->planes[i];
 212                        struct rcar_du_plane_state *new_plane_state;
 213                        struct drm_plane_state *s;
 214
 215                        s = drm_atomic_get_plane_state(state, &plane->plane);
 216                        if (IS_ERR(s))
 217                                return PTR_ERR(s);
 218
 219                        /*
 220                         * If the plane has been freed in the above loop its
 221                         * hardware planes must not be added to the used planes
 222                         * bitmask. However, the current state doesn't reflect
 223                         * the free state yet, as we've modified the new state
 224                         * above. Use the local freed planes list to check for
 225                         * that condition instead.
 226                         */
 227                        if (group_freed_planes[index] & (1 << i)) {
 228                                dev_dbg(rcdu->dev,
 229                                        "%s: plane (%u,%tu) has been freed, skipping\n",
 230                                        __func__, plane->group->index,
 231                                        plane - plane->group->planes);
 232                                continue;
 233                        }
 234
 235                        new_plane_state = to_rcar_plane_state(s);
 236                        used_planes |= rcar_du_plane_hwmask(new_plane_state);
 237
 238                        dev_dbg(rcdu->dev,
 239                                "%s: plane (%u,%tu) uses %u hwplanes (index %d)\n",
 240                                __func__, plane->group->index,
 241                                plane - plane->group->planes,
 242                                new_plane_state->format ?
 243                                new_plane_state->format->planes : 0,
 244                                new_plane_state->hwindex);
 245                }
 246
 247                group_free_planes[index] = 0xff & ~used_planes;
 248                groups &= ~(1 << index);
 249
 250                dev_dbg(rcdu->dev, "%s: group %u free planes mask 0x%02x\n",
 251                        __func__, index, group_free_planes[index]);
 252        }
 253
 254        /* Reallocate hardware planes for each plane that needs it. */
 255        for_each_oldnew_plane_in_state(state, drm_plane, old_drm_plane_state,
 256                                       new_drm_plane_state, i) {
 257                struct rcar_du_plane_state *old_plane_state;
 258                struct rcar_du_plane_state *new_plane_state;
 259                struct rcar_du_plane *plane;
 260                unsigned int crtc_planes;
 261                unsigned int free;
 262                int idx;
 263
 264                plane = to_rcar_plane(drm_plane);
 265                old_plane_state = to_rcar_plane_state(old_drm_plane_state);
 266                new_plane_state = to_rcar_plane_state(new_drm_plane_state);
 267
 268                dev_dbg(rcdu->dev, "%s: allocating plane (%u,%tu)\n", __func__,
 269                        plane->group->index, plane - plane->group->planes);
 270
 271                /*
 272                 * Skip planes that are being disabled or don't need to be
 273                 * reallocated.
 274                 */
 275                if (!new_plane_state->format ||
 276                    !rcar_du_plane_needs_realloc(old_plane_state, new_plane_state))
 277                        continue;
 278
 279                /*
 280                 * Try to allocate the plane from the free planes currently
 281                 * associated with the target CRTC to avoid restarting the CRTC
 282                 * group and thus minimize flicker. If it fails fall back to
 283                 * allocating from all free planes.
 284                 */
 285                crtc_planes = to_rcar_crtc(new_plane_state->state.crtc)->index % 2
 286                            ? plane->group->dptsr_planes
 287                            : ~plane->group->dptsr_planes;
 288                free = group_free_planes[plane->group->index];
 289
 290                idx = rcar_du_plane_hwalloc(plane, new_plane_state,
 291                                            free & crtc_planes);
 292                if (idx < 0)
 293                        idx = rcar_du_plane_hwalloc(plane, new_plane_state,
 294                                                    free);
 295                if (idx < 0) {
 296                        dev_dbg(rcdu->dev, "%s: no available hardware plane\n",
 297                                __func__);
 298                        return idx;
 299                }
 300
 301                dev_dbg(rcdu->dev, "%s: allocated %u hwplanes (index %u)\n",
 302                        __func__, new_plane_state->format->planes, idx);
 303
 304                new_plane_state->hwindex = idx;
 305
 306                group_free_planes[plane->group->index] &=
 307                        ~rcar_du_plane_hwmask(new_plane_state);
 308
 309                dev_dbg(rcdu->dev, "%s: group %u free planes mask 0x%02x\n",
 310                        __func__, plane->group->index,
 311                        group_free_planes[plane->group->index]);
 312        }
 313
 314        return 0;
 315}
 316
 317/* -----------------------------------------------------------------------------
 318 * Plane Setup
 319 */
 320
 321#define RCAR_DU_COLORKEY_NONE           (0 << 24)
 322#define RCAR_DU_COLORKEY_SOURCE         (1 << 24)
 323#define RCAR_DU_COLORKEY_MASK           (1 << 24)
 324
 325static void rcar_du_plane_write(struct rcar_du_group *rgrp,
 326                                unsigned int index, u32 reg, u32 data)
 327{
 328        rcar_du_write(rgrp->dev, rgrp->mmio_offset + index * PLANE_OFF + reg,
 329                      data);
 330}
 331
 332static void rcar_du_plane_setup_scanout(struct rcar_du_group *rgrp,
 333                                        const struct rcar_du_plane_state *state)
 334{
 335        unsigned int src_x = state->state.src_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
 405static void rcar_du_plane_setup_mode(struct rcar_du_group *rgrp,
 406                                     unsigned int index,
 407                                     const struct rcar_du_plane_state *state)
 408{
 409        u32 colorkey;
 410        u32 pnmr;
 411
 412        /*
 413         * The PnALPHAR register controls alpha-blending in 16bpp formats
 414         * (ARGB1555 and XRGB1555).
 415         *
 416         * For ARGB, set the alpha value to 0, and enable alpha-blending when
 417         * the A bit is 0. This maps A=0 to alpha=0 and A=1 to alpha=255.
 418         *
 419         * For XRGB, set the alpha value to the plane-wide alpha value and
 420         * enable alpha-blending regardless of the X bit value.
 421         */
 422        if (state->format->fourcc != DRM_FORMAT_XRGB1555)
 423                rcar_du_plane_write(rgrp, index, PnALPHAR, PnALPHAR_ABIT_0);
 424        else
 425                rcar_du_plane_write(rgrp, index, PnALPHAR,
 426                                    PnALPHAR_ABIT_X | state->alpha);
 427
 428        pnmr = PnMR_BM_MD | state->format->pnmr;
 429
 430        /*
 431         * Disable color keying when requested. YUV formats have the
 432         * PnMR_SPIM_TP_OFF bit set in their pnmr field, disabling color keying
 433         * automatically.
 434         */
 435        if ((state->colorkey & RCAR_DU_COLORKEY_MASK) == RCAR_DU_COLORKEY_NONE)
 436                pnmr |= PnMR_SPIM_TP_OFF;
 437
 438        /* For packed YUV formats we need to select the U/V order. */
 439        if (state->format->fourcc == DRM_FORMAT_YUYV)
 440                pnmr |= PnMR_YCDF_YUYV;
 441
 442        rcar_du_plane_write(rgrp, index, PnMR, pnmr);
 443
 444        switch (state->format->fourcc) {
 445        case DRM_FORMAT_RGB565:
 446                colorkey = ((state->colorkey & 0xf80000) >> 8)
 447                         | ((state->colorkey & 0x00fc00) >> 5)
 448                         | ((state->colorkey & 0x0000f8) >> 3);
 449                rcar_du_plane_write(rgrp, index, PnTC2R, colorkey);
 450                break;
 451
 452        case DRM_FORMAT_ARGB1555:
 453        case DRM_FORMAT_XRGB1555:
 454                colorkey = ((state->colorkey & 0xf80000) >> 9)
 455                         | ((state->colorkey & 0x00f800) >> 6)
 456                         | ((state->colorkey & 0x0000f8) >> 3);
 457                rcar_du_plane_write(rgrp, index, PnTC2R, colorkey);
 458                break;
 459
 460        case DRM_FORMAT_XRGB8888:
 461        case DRM_FORMAT_ARGB8888:
 462                rcar_du_plane_write(rgrp, index, PnTC3R,
 463                                    PnTC3R_CODE | (state->colorkey & 0xffffff));
 464                break;
 465        }
 466}
 467
 468static void rcar_du_plane_setup_format_gen2(struct rcar_du_group *rgrp,
 469                                            unsigned int index,
 470                                            const struct rcar_du_plane_state *state)
 471{
 472        u32 ddcr2 = PnDDCR2_CODE;
 473        u32 ddcr4;
 474
 475        /*
 476         * Data format
 477         *
 478         * The data format is selected by the DDDF field in PnMR and the EDF
 479         * field in DDCR4.
 480         */
 481
 482        rcar_du_plane_setup_mode(rgrp, index, state);
 483
 484        if (state->format->planes == 2) {
 485                if (state->hwindex != index) {
 486                        if (state->format->fourcc == DRM_FORMAT_NV12 ||
 487                            state->format->fourcc == DRM_FORMAT_NV21)
 488                                ddcr2 |= PnDDCR2_Y420;
 489
 490                        if (state->format->fourcc == DRM_FORMAT_NV21)
 491                                ddcr2 |= PnDDCR2_NV21;
 492
 493                        ddcr2 |= PnDDCR2_DIVU;
 494                } else {
 495                        ddcr2 |= PnDDCR2_DIVY;
 496                }
 497        }
 498
 499        rcar_du_plane_write(rgrp, index, PnDDCR2, ddcr2);
 500
 501        ddcr4 = state->format->edf | PnDDCR4_CODE;
 502        if (state->source != RCAR_DU_PLANE_MEMORY)
 503                ddcr4 |= PnDDCR4_VSPS;
 504
 505        rcar_du_plane_write(rgrp, index, PnDDCR4, ddcr4);
 506}
 507
 508static void rcar_du_plane_setup_format_gen3(struct rcar_du_group *rgrp,
 509                                            unsigned int index,
 510                                            const struct rcar_du_plane_state *state)
 511{
 512        rcar_du_plane_write(rgrp, index, PnMR,
 513                            PnMR_SPIM_TP_OFF | state->format->pnmr);
 514
 515        rcar_du_plane_write(rgrp, index, PnDDCR4,
 516                            state->format->edf | PnDDCR4_CODE);
 517}
 518
 519static void rcar_du_plane_setup_format(struct rcar_du_group *rgrp,
 520                                       unsigned int index,
 521                                       const struct rcar_du_plane_state *state)
 522{
 523        struct rcar_du_device *rcdu = rgrp->dev;
 524
 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
 545void __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
 568static 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
 596static 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
 624static 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
 629static struct drm_plane_state *
 630rcar_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
 648static 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
 655static 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
 678static 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
 696static 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
 714static 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
 725static 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
 738int 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}
 784