drivers/gpu/drm/i915/display/intel_cursor.c

   1 // SPDX-License-Identifier: MIT
   2 /*
   3  * Copyright © 2020 Intel Corporation
   4  */
   5 #include <linux/kernel.h>
   6
   7 #include <drm/drm_atomic_helper.h>
   8 #include <drm/drm_atomic_uapi.h>
   9 #include <drm/drm_blend.h>
  10 #include <drm/drm_damage_helper.h>
  11 #include <drm/drm_fourcc.h>
  12
  13 #include "i915_reg.h"
  14 #include "intel_atomic.h"
  15 #include "intel_atomic_plane.h"
  16 #include "intel_cursor.h"
  17 #include "intel_de.h"
  18 #include "intel_display.h"
  19 #include "intel_display_types.h"
  20 #include "intel_fb.h"
  21 #include "intel_fb_pin.h"
  22 #include "intel_frontbuffer.h"
  23 #include "intel_psr.h"
  24 #include "skl_watermark.h"
  25
  26 /* Cursor formats */
  27 static const u32 intel_cursor_formats[] = {
  28         DRM_FORMAT_ARGB8888,
  29 };
  30
  31 static u32 intel_cursor_base(const struct intel_plane_state *plane_state)
  32 {
  33         struct drm_i915_private *dev_priv =
  34                 to_i915(plane_state->uapi.plane->dev);
  35         const struct drm_framebuffer *fb = plane_state->hw.fb;
  36         const struct drm_i915_gem_object *obj = intel_fb_obj(fb);
  37         u32 base;
  38
  39         if (DISPLAY_INFO(dev_priv)->cursor_needs_physical)
  40                 base = sg_dma_address(obj->mm.pages->sgl);
  41         else
  42                 base = intel_plane_ggtt_offset(plane_state);
  43
  44         return base + plane_state->view.color_plane[0].offset;
  45 }
  46
  47 static u32 intel_cursor_position(const struct intel_plane_state *plane_state)
  48 {
  49         int x = plane_state->uapi.dst.x1;
  50         int y = plane_state->uapi.dst.y1;
  51         u32 pos = 0;
  52
  53         if (x < 0) {
  54                 pos |= CURSOR_POS_X_SIGN;
  55                 x = -x;
  56         }
  57         pos |= CURSOR_POS_X(x);
  58
  59         if (y < 0) {
  60                 pos |= CURSOR_POS_Y_SIGN;
  61                 y = -y;
  62         }
  63         pos |= CURSOR_POS_Y(y);
  64
  65         return pos;
  66 }
  67
  68 static bool intel_cursor_size_ok(const struct intel_plane_state *plane_state)
  69 {
  70         const struct drm_mode_config *config =
  71                 &plane_state->uapi.plane->dev->mode_config;
  72         int width = drm_rect_width(&plane_state->uapi.dst);
  73         int height = drm_rect_height(&plane_state->uapi.dst);
  74
  75         return width > 0 && width <= config->cursor_width &&
  76                 height > 0 && height <= config->cursor_height;
  77 }
  78
  79 static int intel_cursor_check_surface(struct intel_plane_state *plane_state)
  80 {
  81         struct drm_i915_private *dev_priv =
  82                 to_i915(plane_state->uapi.plane->dev);
  83         unsigned int rotation = plane_state->hw.rotation;
  84         int src_x, src_y;
  85         u32 offset;
  86         int ret;
  87
  88         ret = intel_plane_compute_gtt(plane_state);
  89         if (ret)
  90                 return ret;
  91
  92         if (!plane_state->uapi.visible)
  93                 return 0;
  94
  95         src_x = plane_state->uapi.src.x1 >> 16;
  96         src_y = plane_state->uapi.src.y1 >> 16;
  97
  98         intel_add_fb_offsets(&src_x, &src_y, plane_state, 0);
  99         offset = intel_plane_compute_aligned_offset(&src_x, &src_y,
 100                                                     plane_state, 0);
 101
 102         if (src_x != 0 || src_y != 0) {
 103                 drm_dbg_kms(&dev_priv->drm,
 104                             "Arbitrary cursor panning not supported\n");
 105                 return -EINVAL;
 106         }
 107
 108         /*
 109          * Put the final coordinates back so that the src
 110          * coordinate checks will see the right values.
 111          */
 112         drm_rect_translate_to(&plane_state->uapi.src,
 113                               src_x << 16, src_y << 16);
 114
 115         /* ILK+ do this automagically in hardware */
 116         if (HAS_GMCH(dev_priv) && rotation & DRM_MODE_ROTATE_180) {
 117                 const struct drm_framebuffer *fb = plane_state->hw.fb;
 118                 int src_w = drm_rect_width(&plane_state->uapi.src) >> 16;
 119                 int src_h = drm_rect_height(&plane_state->uapi.src) >> 16;
 120
 121                 offset += (src_h * src_w - 1) * fb->format->cpp[0];
 122         }
 123
 124         plane_state->view.color_plane[0].offset = offset;
 125         plane_state->view.color_plane[0].x = src_x;
 126         plane_state->view.color_plane[0].y = src_y;
 127
 128         return 0;
 129 }
 130
 131 static int intel_check_cursor(struct intel_crtc_state *crtc_state,
 132                               struct intel_plane_state *plane_state)
 133 {
 134         const struct drm_framebuffer *fb = plane_state->hw.fb;
 135         struct drm_i915_private *i915 = to_i915(plane_state->uapi.plane->dev);
 136         const struct drm_rect src = plane_state->uapi.src;
 137         const struct drm_rect dst = plane_state->uapi.dst;
 138         int ret;
 139
 140         if (fb && fb->modifier != DRM_FORMAT_MOD_LINEAR) {
 141                 drm_dbg_kms(&i915->drm, "cursor cannot be tiled\n");
 142                 return -EINVAL;
 143         }
 144
 145         ret = intel_atomic_plane_check_clipping(plane_state, crtc_state,
 146                                                 DRM_PLANE_NO_SCALING,
 147                                                 DRM_PLANE_NO_SCALING,
 148                                                 true);
 149         if (ret)
 150                 return ret;
 151
 152         /* Use the unclipped src/dst rectangles, which we program to hw */
 153         plane_state->uapi.src = src;
 154         plane_state->uapi.dst = dst;
 155
 156         /* final plane coordinates will be relative to the plane's pipe */
 157         drm_rect_translate(&plane_state->uapi.dst,
 158                            -crtc_state->pipe_src.x1,
 159                            -crtc_state->pipe_src.y1);
 160
 161         ret = intel_cursor_check_surface(plane_state);
 162         if (ret)
 163                 return ret;
 164
 165         if (!plane_state->uapi.visible)
 166                 return 0;
 167
 168         ret = intel_plane_check_src_coordinates(plane_state);
 169         if (ret)
 170                 return ret;
 171
 172         return 0;
 173 }
 174
 175 static unsigned int
 176 i845_cursor_max_stride(struct intel_plane *plane,
 177                        u32 pixel_format, u64 modifier,
 178                        unsigned int rotation)
 179 {
 180         return 2048;
 181 }
 182
 183 static u32 i845_cursor_ctl_crtc(const struct intel_crtc_state *crtc_state)
 184 {
 185         u32 cntl = 0;
 186
 187         if (crtc_state->gamma_enable)
 188                 cntl |= CURSOR_PIPE_GAMMA_ENABLE;
 189
 190         return cntl;
 191 }
 192
 193 static u32 i845_cursor_ctl(const struct intel_crtc_state *crtc_state,
 194                            const struct intel_plane_state *plane_state)
 195 {
 196         return CURSOR_ENABLE |
 197                 CURSOR_FORMAT_ARGB |
 198                 CURSOR_STRIDE(plane_state->view.color_plane[0].mapping_stride);
 199 }
 200
 201 static bool i845_cursor_size_ok(const struct intel_plane_state *plane_state)
 202 {
 203         int width = drm_rect_width(&plane_state->uapi.dst);
 204
 205         /*
 206          * 845g/865g are only limited by the width of their cursors,
 207          * the height is arbitrary up to the precision of the register.
 208          */
 209         return intel_cursor_size_ok(plane_state) && IS_ALIGNED(width, 64);
 210 }
 211
 212 static int i845_check_cursor(struct intel_crtc_state *crtc_state,
 213                              struct intel_plane_state *plane_state)
 214 {
 215         const struct drm_framebuffer *fb = plane_state->hw.fb;
 216         struct drm_i915_private *i915 = to_i915(plane_state->uapi.plane->dev);
 217         int ret;
 218
 219         ret = intel_check_cursor(crtc_state, plane_state);
 220         if (ret)
 221                 return ret;
 222
 223         /* if we want to turn off the cursor ignore width and height */
 224         if (!fb)
 225                 return 0;
 226
 227         /* Check for which cursor types we support */
 228         if (!i845_cursor_size_ok(plane_state)) {
 229                 drm_dbg_kms(&i915->drm,
 230                             "Cursor dimension %dx%d not supported\n",
 231                             drm_rect_width(&plane_state->uapi.dst),
 232                             drm_rect_height(&plane_state->uapi.dst));
 233                 return -EINVAL;
 234         }
 235
 236         drm_WARN_ON(&i915->drm, plane_state->uapi.visible &&
 237                     plane_state->view.color_plane[0].mapping_stride != fb->pitches[0]);
 238
 239         switch (fb->pitches[0]) {
 240         case 256:
 241         case 512:
 242         case 1024:
 243         case 2048:
 244                 break;
 245         default:
 246                  drm_dbg_kms(&i915->drm, "Invalid cursor stride (%u)\n",
 247                              fb->pitches[0]);
 248                 return -EINVAL;
 249         }
 250
 251         plane_state->ctl = i845_cursor_ctl(crtc_state, plane_state);
 252
 253         return 0;
 254 }
 255
 256 /* TODO: split into noarm+arm pair */
 257 static void i845_cursor_update_arm(struct intel_plane *plane,
 258                                    const struct intel_crtc_state *crtc_state,
 259                                    const struct intel_plane_state *plane_state)
 260 {
 261         struct drm_i915_private *dev_priv = to_i915(plane->base.dev);
 262         u32 cntl = 0, base = 0, pos = 0, size = 0;
 263
 264         if (plane_state && plane_state->uapi.visible) {
 265                 unsigned int width = drm_rect_width(&plane_state->uapi.dst);
 266                 unsigned int height = drm_rect_height(&plane_state->uapi.dst);
 267
 268                 cntl = plane_state->ctl |
 269                         i845_cursor_ctl_crtc(crtc_state);
 270
 271                 size = CURSOR_HEIGHT(height) | CURSOR_WIDTH(width);
 272
 273                 base = intel_cursor_base(plane_state);
 274                 pos = intel_cursor_position(plane_state);
 275         }
 276
 277         /* On these chipsets we can only modify the base/size/stride
 278          * whilst the cursor is disabled.
 279          */
 280         if (plane->cursor.base != base ||
 281             plane->cursor.size != size ||
 282             plane->cursor.cntl != cntl) {
 283                 intel_de_write_fw(dev_priv, CURCNTR(PIPE_A), 0);
 284                 intel_de_write_fw(dev_priv, CURBASE(PIPE_A), base);
 285                 intel_de_write_fw(dev_priv, CURSIZE(PIPE_A), size);
 286                 intel_de_write_fw(dev_priv, CURPOS(PIPE_A), pos);
 287                 intel_de_write_fw(dev_priv, CURCNTR(PIPE_A), cntl);
 288
 289                 plane->cursor.base = base;
 290                 plane->cursor.size = size;
 291                 plane->cursor.cntl = cntl;
 292         } else {
 293                 intel_de_write_fw(dev_priv, CURPOS(PIPE_A), pos);
 294         }
 295 }
 296
 297 static void i845_cursor_disable_arm(struct intel_plane *plane,
 298                                     const struct intel_crtc_state *crtc_state)
 299 {
 300         i845_cursor_update_arm(plane, crtc_state, NULL);
 301 }
 302
 303 static bool i845_cursor_get_hw_state(struct intel_plane *plane,
 304                                      enum pipe *pipe)
 305 {
 306         struct drm_i915_private *dev_priv = to_i915(plane->base.dev);
 307         enum intel_display_power_domain power_domain;
 308         intel_wakeref_t wakeref;
 309         bool ret;
 310
 311         power_domain = POWER_DOMAIN_PIPE(PIPE_A);
 312         wakeref = intel_display_power_get_if_enabled(dev_priv, power_domain);
 313         if (!wakeref)
 314                 return false;
 315
 316         ret = intel_de_read(dev_priv, CURCNTR(PIPE_A)) & CURSOR_ENABLE;
 317
 318         *pipe = PIPE_A;
 319
 320         intel_display_power_put(dev_priv, power_domain, wakeref);
 321
 322         return ret;
 323 }
 324
 325 static unsigned int
 326 i9xx_cursor_max_stride(struct intel_plane *plane,
 327                        u32 pixel_format, u64 modifier,
 328                        unsigned int rotation)
 329 {
 330         return plane->base.dev->mode_config.cursor_width * 4;
 331 }
 332
 333 static u32 i9xx_cursor_ctl_crtc(const struct intel_crtc_state *crtc_state)
 334 {
 335         struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc);
 336         struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
 337         u32 cntl = 0;
 338
 339         if (DISPLAY_VER(dev_priv) >= 11)
 340                 return cntl;
 341
 342         if (crtc_state->gamma_enable)
 343                 cntl = MCURSOR_PIPE_GAMMA_ENABLE;
 344
 345         if (crtc_state->csc_enable)
 346                 cntl |= MCURSOR_PIPE_CSC_ENABLE;
 347
 348         if (DISPLAY_VER(dev_priv) < 5 && !IS_G4X(dev_priv))
 349                 cntl |= MCURSOR_PIPE_SEL(crtc->pipe);
 350
 351         return cntl;
 352 }
 353
 354 static u32 i9xx_cursor_ctl(const struct intel_crtc_state *crtc_state,
 355                            const struct intel_plane_state *plane_state)
 356 {
 357         struct drm_i915_private *dev_priv =
 358                 to_i915(plane_state->uapi.plane->dev);
 359         u32 cntl = 0;
 360
 361         if (IS_SANDYBRIDGE(dev_priv) || IS_IVYBRIDGE(dev_priv))
 362                 cntl |= MCURSOR_TRICKLE_FEED_DISABLE;
 363
 364         switch (drm_rect_width(&plane_state->uapi.dst)) {
 365         case 64:
 366                 cntl |= MCURSOR_MODE_64_ARGB_AX;
 367                 break;
 368         case 128:
 369                 cntl |= MCURSOR_MODE_128_ARGB_AX;
 370                 break;
 371         case 256:
 372                 cntl |= MCURSOR_MODE_256_ARGB_AX;
 373                 break;
 374         default:
 375                 MISSING_CASE(drm_rect_width(&plane_state->uapi.dst));
 376                 return 0;
 377         }
 378
 379         if (plane_state->hw.rotation & DRM_MODE_ROTATE_180)
 380                 cntl |= MCURSOR_ROTATE_180;
 381
 382         /* Wa_22012358565:adl-p */
 383         if (DISPLAY_VER(dev_priv) == 13)
 384                 cntl |= MCURSOR_ARB_SLOTS(1);
 385
 386         return cntl;
 387 }
 388
 389 static bool i9xx_cursor_size_ok(const struct intel_plane_state *plane_state)
 390 {
 391         struct drm_i915_private *dev_priv =
 392                 to_i915(plane_state->uapi.plane->dev);
 393         int width = drm_rect_width(&plane_state->uapi.dst);
 394         int height = drm_rect_height(&plane_state->uapi.dst);
 395
 396         if (!intel_cursor_size_ok(plane_state))
 397                 return false;
 398
 399         /* Cursor width is limited to a few power-of-two sizes */
 400         switch (width) {
 401         case 256:
 402         case 128:
 403         case 64:
 404                 break;
 405         default:
 406                 return false;
 407         }
 408
 409         /*
 410          * IVB+ have CUR_FBC_CTL which allows an arbitrary cursor
 411          * height from 8 lines up to the cursor width, when the
 412          * cursor is not rotated. Everything else requires square
 413          * cursors.
 414          */
 415         if (HAS_CUR_FBC(dev_priv) &&
 416             plane_state->hw.rotation & DRM_MODE_ROTATE_0) {
 417                 if (height < 8 || height > width)
 418                         return false;
 419         } else {
 420                 if (height != width)
 421                         return false;
 422         }
 423
 424         return true;
 425 }
 426
 427 static int i9xx_check_cursor(struct intel_crtc_state *crtc_state,
 428                              struct intel_plane_state *plane_state)
 429 {
 430         struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
 431         struct drm_i915_private *dev_priv = to_i915(plane->base.dev);
 432         const struct drm_framebuffer *fb = plane_state->hw.fb;
 433         enum pipe pipe = plane->pipe;
 434         int ret;
 435
 436         ret = intel_check_cursor(crtc_state, plane_state);
 437         if (ret)
 438                 return ret;
 439
 440         /* if we want to turn off the cursor ignore width and height */
 441         if (!fb)
 442                 return 0;
 443
 444         /* Check for which cursor types we support */
 445         if (!i9xx_cursor_size_ok(plane_state)) {
 446                 drm_dbg(&dev_priv->drm,
 447                         "Cursor dimension %dx%d not supported\n",
 448                         drm_rect_width(&plane_state->uapi.dst),
 449                         drm_rect_height(&plane_state->uapi.dst));
 450                 return -EINVAL;
 451         }
 452
 453         drm_WARN_ON(&dev_priv->drm, plane_state->uapi.visible &&
 454                     plane_state->view.color_plane[0].mapping_stride != fb->pitches[0]);
 455
 456         if (fb->pitches[0] !=
 457             drm_rect_width(&plane_state->uapi.dst) * fb->format->cpp[0]) {
 458                 drm_dbg_kms(&dev_priv->drm,
 459                             "Invalid cursor stride (%u) (cursor width %d)\n",
 460                             fb->pitches[0],
 461                             drm_rect_width(&plane_state->uapi.dst));
 462                 return -EINVAL;
 463         }
 464
 465         /*
 466          * There's something wrong with the cursor on CHV pipe C.
 467          * If it straddles the left edge of the screen then
 468          * moving it away from the edge or disabling it often
 469          * results in a pipe underrun, and often that can lead to
 470          * dead pipe (constant underrun reported, and it scans
 471          * out just a solid color). To recover from that, the
 472          * display power well must be turned off and on again.
 473          * Refuse the put the cursor into that compromised position.
 474          */
 475         if (IS_CHERRYVIEW(dev_priv) && pipe == PIPE_C &&
 476             plane_state->uapi.visible && plane_state->uapi.dst.x1 < 0) {
 477                 drm_dbg_kms(&dev_priv->drm,
 478                             "CHV cursor C not allowed to straddle the left screen edge\n");
 479                 return -EINVAL;
 480         }
 481
 482         plane_state->ctl = i9xx_cursor_ctl(crtc_state, plane_state);
 483
 484         return 0;
 485 }
 486
 487 /* TODO: split into noarm+arm pair */
 488 static void i9xx_cursor_update_arm(struct intel_plane *plane,
 489                                    const struct intel_crtc_state *crtc_state,
 490                                    const struct intel_plane_state *plane_state)
 491 {
 492         struct drm_i915_private *dev_priv = to_i915(plane->base.dev);
 493         enum pipe pipe = plane->pipe;
 494         u32 cntl = 0, base = 0, pos = 0, fbc_ctl = 0;
 495
 496         if (plane_state && plane_state->uapi.visible) {
 497                 int width = drm_rect_width(&plane_state->uapi.dst);
 498                 int height = drm_rect_height(&plane_state->uapi.dst);
 499
 500                 cntl = plane_state->ctl |
 501                         i9xx_cursor_ctl_crtc(crtc_state);
 502
 503                 if (width != height)
 504                         fbc_ctl = CUR_FBC_EN | CUR_FBC_HEIGHT(height - 1);
 505
 506                 base = intel_cursor_base(plane_state);
 507                 pos = intel_cursor_position(plane_state);
 508         }
 509
 510         /*
 511          * On some platforms writing CURCNTR first will also
 512          * cause CURPOS to be armed by the CURBASE write.
 513          * Without the CURCNTR write the CURPOS write would
 514          * arm itself. Thus we always update CURCNTR before
 515          * CURPOS.
 516          *
 517          * On other platforms CURPOS always requires the
 518          * CURBASE write to arm the update. Additonally
 519          * a write to any of the cursor register will cancel
 520          * an already armed cursor update. Thus leaving out
 521          * the CURBASE write after CURPOS could lead to a
 522          * cursor that doesn't appear to move, or even change
 523          * shape. Thus we always write CURBASE.
 524          *
 525          * The other registers are armed by the CURBASE write
 526          * except when the plane is getting enabled at which time
 527          * the CURCNTR write arms the update.
 528          */
 529
 530         if (DISPLAY_VER(dev_priv) >= 9)
 531                 skl_write_cursor_wm(plane, crtc_state);
 532
 533         if (plane_state)
 534                 intel_psr2_program_plane_sel_fetch_arm(plane, crtc_state,
 535                                                        plane_state);
 536         else
 537                 intel_psr2_disable_plane_sel_fetch_arm(plane, crtc_state);
 538
 539         if (plane->cursor.base != base ||
 540             plane->cursor.size != fbc_ctl ||
 541             plane->cursor.cntl != cntl) {
 542                 if (HAS_CUR_FBC(dev_priv))
 543                         intel_de_write_fw(dev_priv, CUR_FBC_CTL(pipe),
 544                                           fbc_ctl);
 545                 intel_de_write_fw(dev_priv, CURCNTR(pipe), cntl);
 546                 intel_de_write_fw(dev_priv, CURPOS(pipe), pos);
 547                 intel_de_write_fw(dev_priv, CURBASE(pipe), base);
 548
 549                 plane->cursor.base = base;
 550                 plane->cursor.size = fbc_ctl;
 551                 plane->cursor.cntl = cntl;
 552         } else {
 553                 intel_de_write_fw(dev_priv, CURPOS(pipe), pos);
 554                 intel_de_write_fw(dev_priv, CURBASE(pipe), base);
 555         }
 556 }
 557
 558 static void i9xx_cursor_disable_arm(struct intel_plane *plane,
 559                                     const struct intel_crtc_state *crtc_state)
 560 {
 561         i9xx_cursor_update_arm(plane, crtc_state, NULL);
 562 }
 563
 564 static bool i9xx_cursor_get_hw_state(struct intel_plane *plane,
 565                                      enum pipe *pipe)
 566 {
 567         struct drm_i915_private *dev_priv = to_i915(plane->base.dev);
 568         enum intel_display_power_domain power_domain;
 569         intel_wakeref_t wakeref;
 570         bool ret;
 571         u32 val;
 572
 573         /*
 574          * Not 100% correct for planes that can move between pipes,
 575          * but that's only the case for gen2-3 which don't have any
 576          * display power wells.
 577          */
 578         power_domain = POWER_DOMAIN_PIPE(plane->pipe);
 579         wakeref = intel_display_power_get_if_enabled(dev_priv, power_domain);
 580         if (!wakeref)
 581                 return false;
 582
 583         val = intel_de_read(dev_priv, CURCNTR(plane->pipe));
 584
 585         ret = val & MCURSOR_MODE_MASK;
 586
 587         if (DISPLAY_VER(dev_priv) >= 5 || IS_G4X(dev_priv))
 588                 *pipe = plane->pipe;
 589         else
 590                 *pipe = REG_FIELD_GET(MCURSOR_PIPE_SEL_MASK, val);
 591
 592         intel_display_power_put(dev_priv, power_domain, wakeref);
 593
 594         return ret;
 595 }
 596
 597 static bool intel_cursor_format_mod_supported(struct drm_plane *_plane,
 598                                               u32 format, u64 modifier)
 599 {
 600         if (!intel_fb_plane_supports_modifier(to_intel_plane(_plane), modifier))
 601                 return false;
 602
 603         return format == DRM_FORMAT_ARGB8888;
 604 }
 605
 606 static int
 607 intel_legacy_cursor_update(struct drm_plane *_plane,
 608                            struct drm_crtc *_crtc,
 609                            struct drm_framebuffer *fb,
 610                            int crtc_x, int crtc_y,
 611                            unsigned int crtc_w, unsigned int crtc_h,
 612                            u32 src_x, u32 src_y,
 613                            u32 src_w, u32 src_h,
 614                            struct drm_modeset_acquire_ctx *ctx)
 615 {
 616         struct intel_plane *plane = to_intel_plane(_plane);
 617         struct intel_crtc *crtc = to_intel_crtc(_crtc);
 618         struct intel_plane_state *old_plane_state =
 619                 to_intel_plane_state(plane->base.state);
 620         struct intel_plane_state *new_plane_state;
 621         struct intel_crtc_state *crtc_state =
 622                 to_intel_crtc_state(crtc->base.state);
 623         struct intel_crtc_state *new_crtc_state;
 624         int ret;
 625
 626         /*
 627          * When crtc is inactive or there is a modeset pending,
 628          * wait for it to complete in the slowpath.
 629          * PSR2 selective fetch also requires the slow path as
 630          * PSR2 plane and transcoder registers can only be updated during
 631          * vblank.
 632          *
 633          * FIXME bigjoiner fastpath would be good
 634          */
 635         if (!crtc_state->hw.active ||
 636             intel_crtc_needs_modeset(crtc_state) ||
 637             intel_crtc_needs_fastset(crtc_state) ||
 638             crtc_state->bigjoiner_pipes)
 639                 goto slow;
 640
 641         /*
 642          * Don't do an async update if there is an outstanding commit modifying
 643          * the plane.  This prevents our async update's changes from getting
 644          * overridden by a previous synchronous update's state.
 645          */
 646         if (old_plane_state->uapi.commit &&
 647             !try_wait_for_completion(&old_plane_state->uapi.commit->hw_done))
 648                 goto slow;
 649
 650         /*
 651          * If any parameters change that may affect watermarks,
 652          * take the slowpath. Only changing fb or position should be
 653          * in the fastpath.
 654          */
 655         if (old_plane_state->uapi.crtc != &crtc->base ||
 656             old_plane_state->uapi.src_w != src_w ||
 657             old_plane_state->uapi.src_h != src_h ||
 658             old_plane_state->uapi.crtc_w != crtc_w ||
 659             old_plane_state->uapi.crtc_h != crtc_h ||
 660             !old_plane_state->uapi.fb != !fb)
 661                 goto slow;
 662
 663         new_plane_state = to_intel_plane_state(intel_plane_duplicate_state(&plane->base));
 664         if (!new_plane_state)
 665                 return -ENOMEM;
 666
 667         new_crtc_state = to_intel_crtc_state(intel_crtc_duplicate_state(&crtc->base));
 668         if (!new_crtc_state) {
 669                 ret = -ENOMEM;
 670                 goto out_free;
 671         }
 672
 673         drm_atomic_set_fb_for_plane(&new_plane_state->uapi, fb);
 674
 675         new_plane_state->uapi.src_x = src_x;
 676         new_plane_state->uapi.src_y = src_y;
 677         new_plane_state->uapi.src_w = src_w;
 678         new_plane_state->uapi.src_h = src_h;
 679         new_plane_state->uapi.crtc_x = crtc_x;
 680         new_plane_state->uapi.crtc_y = crtc_y;
 681         new_plane_state->uapi.crtc_w = crtc_w;
 682         new_plane_state->uapi.crtc_h = crtc_h;
 683
 684         intel_plane_copy_uapi_to_hw_state(new_plane_state, new_plane_state, crtc);
 685
 686         ret = intel_plane_atomic_check_with_state(crtc_state, new_crtc_state,
 687                                                   old_plane_state, new_plane_state);
 688         if (ret)
 689                 goto out_free;
 690
 691         ret = intel_plane_pin_fb(new_plane_state);
 692         if (ret)
 693                 goto out_free;
 694
 695         intel_frontbuffer_flush(to_intel_frontbuffer(new_plane_state->hw.fb),
 696                                 ORIGIN_CURSOR_UPDATE);
 697         intel_frontbuffer_track(to_intel_frontbuffer(old_plane_state->hw.fb),
 698                                 to_intel_frontbuffer(new_plane_state->hw.fb),
 699                                 plane->frontbuffer_bit);
 700
 701         /* Swap plane state */
 702         plane->base.state = &new_plane_state->uapi;
 703
 704         /*
 705          * We cannot swap crtc_state as it may be in use by an atomic commit or
 706          * page flip that's running simultaneously. If we swap crtc_state and
 707          * destroy the old state, we will cause a use-after-free there.
 708          *
 709          * Only update active_planes, which is needed for our internal
 710          * bookkeeping. Either value will do the right thing when updating
 711          * planes atomically. If the cursor was part of the atomic update then
 712          * we would have taken the slowpath.
 713          */
 714         crtc_state->active_planes = new_crtc_state->active_planes;
 715
 716         /*
 717          * Technically we should do a vblank evasion here to make
 718          * sure all the cursor registers update on the same frame.
 719          * For now just make sure the register writes happen as
 720          * quickly as possible to minimize the race window.
 721          */
 722         local_irq_disable();
 723
 724         if (new_plane_state->uapi.visible) {
 725                 intel_plane_update_noarm(plane, crtc_state, new_plane_state);
 726                 intel_plane_update_arm(plane, crtc_state, new_plane_state);
 727         } else {
 728                 intel_plane_disable_arm(plane, crtc_state);
 729         }
 730
 731         local_irq_enable();
 732
 733         intel_plane_unpin_fb(old_plane_state);
 734
 735 out_free:
 736         if (new_crtc_state)
 737                 intel_crtc_destroy_state(&crtc->base, &new_crtc_state->uapi);
 738         if (ret)
 739                 intel_plane_destroy_state(&plane->base, &new_plane_state->uapi);
 740         else
 741                 intel_plane_destroy_state(&plane->base, &old_plane_state->uapi);
 742         return ret;
 743
 744 slow:
 745         return drm_atomic_helper_update_plane(&plane->base, &crtc->base, fb,
 746                                               crtc_x, crtc_y, crtc_w, crtc_h,
 747                                               src_x, src_y, src_w, src_h, ctx);
 748 }
 749
 750 static const struct drm_plane_funcs intel_cursor_plane_funcs = {
 751         .update_plane = intel_legacy_cursor_update,
 752         .disable_plane = drm_atomic_helper_disable_plane,
 753         .destroy = intel_plane_destroy,
 754         .atomic_duplicate_state = intel_plane_duplicate_state,
 755         .atomic_destroy_state = intel_plane_destroy_state,
 756         .format_mod_supported = intel_cursor_format_mod_supported,
 757 };
 758
 759 struct intel_plane *
 760 intel_cursor_plane_create(struct drm_i915_private *dev_priv,
 761                           enum pipe pipe)
 762 {
 763         struct intel_plane *cursor;
 764         int ret, zpos;
 765         u64 *modifiers;
 766
 767         cursor = intel_plane_alloc();
 768         if (IS_ERR(cursor))
 769                 return cursor;
 770
 771         cursor->pipe = pipe;
 772         cursor->i9xx_plane = (enum i9xx_plane_id) pipe;
 773         cursor->id = PLANE_CURSOR;
 774         cursor->frontbuffer_bit = INTEL_FRONTBUFFER(pipe, cursor->id);
 775
 776         if (IS_I845G(dev_priv) || IS_I865G(dev_priv)) {
 777                 cursor->max_stride = i845_cursor_max_stride;
 778                 cursor->update_arm = i845_cursor_update_arm;
 779                 cursor->disable_arm = i845_cursor_disable_arm;
 780                 cursor->get_hw_state = i845_cursor_get_hw_state;
 781                 cursor->check_plane = i845_check_cursor;
 782         } else {
 783                 cursor->max_stride = i9xx_cursor_max_stride;
 784                 cursor->update_arm = i9xx_cursor_update_arm;
 785                 cursor->disable_arm = i9xx_cursor_disable_arm;
 786                 cursor->get_hw_state = i9xx_cursor_get_hw_state;
 787                 cursor->check_plane = i9xx_check_cursor;
 788         }
 789
 790         cursor->cursor.base = ~0;
 791         cursor->cursor.cntl = ~0;
 792
 793         if (IS_I845G(dev_priv) || IS_I865G(dev_priv) || HAS_CUR_FBC(dev_priv))
 794                 cursor->cursor.size = ~0;
 795
 796         modifiers = intel_fb_plane_get_modifiers(dev_priv, INTEL_PLANE_CAP_NONE);
 797
 798         ret = drm_universal_plane_init(&dev_priv->drm, &cursor->base,
 799                                        0, &intel_cursor_plane_funcs,
 800                                        intel_cursor_formats,
 801                                        ARRAY_SIZE(intel_cursor_formats),
 802                                        modifiers,
 803                                        DRM_PLANE_TYPE_CURSOR,
 804                                        "cursor %c", pipe_name(pipe));
 805
 806         kfree(modifiers);
 807
 808         if (ret)
 809                 goto fail;
 810
 811         if (DISPLAY_VER(dev_priv) >= 4)
 812                 drm_plane_create_rotation_property(&cursor->base,
 813                                                    DRM_MODE_ROTATE_0,
 814                                                    DRM_MODE_ROTATE_0 |
 815                                                    DRM_MODE_ROTATE_180);
 816
 817         zpos = DISPLAY_RUNTIME_INFO(dev_priv)->num_sprites[pipe] + 1;
 818         drm_plane_create_zpos_immutable_property(&cursor->base, zpos);
 819
 820         if (DISPLAY_VER(dev_priv) >= 12)
 821                 drm_plane_enable_fb_damage_clips(&cursor->base);
 822
 823         intel_plane_helper_add(cursor);
 824
 825         return cursor;
 826
 827 fail:
 828         intel_plane_free(cursor);
 829
 830         return ERR_PTR(ret);
 831 }