drivers/gpu/drm/vmwgfx/vmwgfx_kms.c

   1 // SPDX-License-Identifier: GPL-2.0 OR MIT
   2 /**************************************************************************
   3  *
   4  * Copyright 2009-2023 VMware, Inc., Palo Alto, CA., USA
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  21  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
  22  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  23  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  24  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27 #include "vmwgfx_kms.h"
  28
  29 #include "vmwgfx_bo.h"
  30 #include "vmw_surface_cache.h"
  31
  32 #include <drm/drm_atomic.h>
  33 #include <drm/drm_atomic_helper.h>
  34 #include <drm/drm_damage_helper.h>
  35 #include <drm/drm_fourcc.h>
  36 #include <drm/drm_rect.h>
  37 #include <drm/drm_sysfs.h>
  38 #include <drm/drm_edid.h>
  39
  40 void vmw_du_cleanup(struct vmw_display_unit *du)
  41 {
  42         struct vmw_private *dev_priv = vmw_priv(du->primary.dev);
  43         drm_plane_cleanup(&du->primary);
  44         if (vmw_cmd_supported(dev_priv))
  45                 drm_plane_cleanup(&du->cursor.base);
  46
  47         drm_connector_unregister(&du->connector);
  48         drm_crtc_cleanup(&du->crtc);
  49         drm_encoder_cleanup(&du->encoder);
  50         drm_connector_cleanup(&du->connector);
  51 }
  52
  53 /*
  54  * Display Unit Cursor functions
  55  */
  56
  57 static int vmw_du_cursor_plane_unmap_cm(struct vmw_plane_state *vps);
  58 static void vmw_cursor_update_mob(struct vmw_private *dev_priv,
  59                                   struct vmw_plane_state *vps,
  60                                   u32 *image, u32 width, u32 height,
  61                                   u32 hotspotX, u32 hotspotY);
  62
  63 struct vmw_svga_fifo_cmd_define_cursor {
  64         u32 cmd;
  65         SVGAFifoCmdDefineAlphaCursor cursor;
  66 };
  67
  68 /**
  69  * vmw_send_define_cursor_cmd - queue a define cursor command
  70  * @dev_priv: the private driver struct
  71  * @image: buffer which holds the cursor image
  72  * @width: width of the mouse cursor image
  73  * @height: height of the mouse cursor image
  74  * @hotspotX: the horizontal position of mouse hotspot
  75  * @hotspotY: the vertical position of mouse hotspot
  76  */
  77 static void vmw_send_define_cursor_cmd(struct vmw_private *dev_priv,
  78                                        u32 *image, u32 width, u32 height,
  79                                        u32 hotspotX, u32 hotspotY)
  80 {
  81         struct vmw_svga_fifo_cmd_define_cursor *cmd;
  82         const u32 image_size = width * height * sizeof(*image);
  83         const u32 cmd_size = sizeof(*cmd) + image_size;
  84
  85         /* Try to reserve fifocmd space and swallow any failures;
  86            such reservations cannot be left unconsumed for long
  87            under the risk of clogging other fifocmd users, so
  88            we treat reservations separtely from the way we treat
  89            other fallible KMS-atomic resources at prepare_fb */
  90         cmd = VMW_CMD_RESERVE(dev_priv, cmd_size);
  91
  92         if (unlikely(!cmd))
  93                 return;
  94
  95         memset(cmd, 0, sizeof(*cmd));
  96
  97         memcpy(&cmd[1], image, image_size);
  98
  99         cmd->cmd = SVGA_CMD_DEFINE_ALPHA_CURSOR;
 100         cmd->cursor.id = 0;
 101         cmd->cursor.width = width;
 102         cmd->cursor.height = height;
 103         cmd->cursor.hotspotX = hotspotX;
 104         cmd->cursor.hotspotY = hotspotY;
 105
 106         vmw_cmd_commit_flush(dev_priv, cmd_size);
 107 }
 108
 109 /**
 110  * vmw_cursor_update_image - update the cursor image on the provided plane
 111  * @dev_priv: the private driver struct
 112  * @vps: the plane state of the cursor plane
 113  * @image: buffer which holds the cursor image
 114  * @width: width of the mouse cursor image
 115  * @height: height of the mouse cursor image
 116  * @hotspotX: the horizontal position of mouse hotspot
 117  * @hotspotY: the vertical position of mouse hotspot
 118  */
 119 static void vmw_cursor_update_image(struct vmw_private *dev_priv,
 120                                     struct vmw_plane_state *vps,
 121                                     u32 *image, u32 width, u32 height,
 122                                     u32 hotspotX, u32 hotspotY)
 123 {
 124         if (vps->cursor.bo)
 125                 vmw_cursor_update_mob(dev_priv, vps, image,
 126                                       vps->base.crtc_w, vps->base.crtc_h,
 127                                       hotspotX, hotspotY);
 128
 129         else
 130                 vmw_send_define_cursor_cmd(dev_priv, image, width, height,
 131                                            hotspotX, hotspotY);
 132 }
 133
 134
 135 /**
 136  * vmw_cursor_update_mob - Update cursor vis CursorMob mechanism
 137  *
 138  * Called from inside vmw_du_cursor_plane_atomic_update to actually
 139  * make the cursor-image live.
 140  *
 141  * @dev_priv: device to work with
 142  * @vps: the plane state of the cursor plane
 143  * @image: cursor source data to fill the MOB with
 144  * @width: source data width
 145  * @height: source data height
 146  * @hotspotX: cursor hotspot x
 147  * @hotspotY: cursor hotspot Y
 148  */
 149 static void vmw_cursor_update_mob(struct vmw_private *dev_priv,
 150                                   struct vmw_plane_state *vps,
 151                                   u32 *image, u32 width, u32 height,
 152                                   u32 hotspotX, u32 hotspotY)
 153 {
 154         SVGAGBCursorHeader *header;
 155         SVGAGBAlphaCursorHeader *alpha_header;
 156         const u32 image_size = width * height * sizeof(*image);
 157
 158         header = vmw_bo_map_and_cache(vps->cursor.bo);
 159         alpha_header = &header->header.alphaHeader;
 160
 161         memset(header, 0, sizeof(*header));
 162
 163         header->type = SVGA_ALPHA_CURSOR;
 164         header->sizeInBytes = image_size;
 165
 166         alpha_header->hotspotX = hotspotX;
 167         alpha_header->hotspotY = hotspotY;
 168         alpha_header->width = width;
 169         alpha_header->height = height;
 170
 171         memcpy(header + 1, image, image_size);
 172         vmw_write(dev_priv, SVGA_REG_CURSOR_MOBID,
 173                   vps->cursor.bo->tbo.resource->start);
 174 }
 175
 176
 177 static u32 vmw_du_cursor_mob_size(u32 w, u32 h)
 178 {
 179         return w * h * sizeof(u32) + sizeof(SVGAGBCursorHeader);
 180 }
 181
 182 /**
 183  * vmw_du_cursor_plane_acquire_image -- Acquire the image data
 184  * @vps: cursor plane state
 185  */
 186 static u32 *vmw_du_cursor_plane_acquire_image(struct vmw_plane_state *vps)
 187 {
 188         if (vps->surf) {
 189                 if (vps->surf_mapped)
 190                         return vmw_bo_map_and_cache(vps->surf->res.guest_memory_bo);
 191                 return vps->surf->snooper.image;
 192         } else if (vps->bo)
 193                 return vmw_bo_map_and_cache(vps->bo);
 194         return NULL;
 195 }
 196
 197 static bool vmw_du_cursor_plane_has_changed(struct vmw_plane_state *old_vps,
 198                                             struct vmw_plane_state *new_vps)
 199 {
 200         void *old_image;
 201         void *new_image;
 202         u32 size;
 203         bool changed;
 204
 205         if (old_vps->base.crtc_w != new_vps->base.crtc_w ||
 206             old_vps->base.crtc_h != new_vps->base.crtc_h)
 207             return true;
 208
 209         if (old_vps->cursor.hotspot_x != new_vps->cursor.hotspot_x ||
 210             old_vps->cursor.hotspot_y != new_vps->cursor.hotspot_y)
 211             return true;
 212
 213         size = new_vps->base.crtc_w * new_vps->base.crtc_h * sizeof(u32);
 214
 215         old_image = vmw_du_cursor_plane_acquire_image(old_vps);
 216         new_image = vmw_du_cursor_plane_acquire_image(new_vps);
 217
 218         changed = false;
 219         if (old_image && new_image)
 220                 changed = memcmp(old_image, new_image, size) != 0;
 221
 222         return changed;
 223 }
 224
 225 static void vmw_du_destroy_cursor_mob(struct vmw_bo **vbo)
 226 {
 227         if (!(*vbo))
 228                 return;
 229
 230         ttm_bo_unpin(&(*vbo)->tbo);
 231         vmw_bo_unreference(vbo);
 232 }
 233
 234 static void vmw_du_put_cursor_mob(struct vmw_cursor_plane *vcp,
 235                                   struct vmw_plane_state *vps)
 236 {
 237         u32 i;
 238
 239         if (!vps->cursor.bo)
 240                 return;
 241
 242         vmw_du_cursor_plane_unmap_cm(vps);
 243
 244         /* Look for a free slot to return this mob to the cache. */
 245         for (i = 0; i < ARRAY_SIZE(vcp->cursor_mobs); i++) {
 246                 if (!vcp->cursor_mobs[i]) {
 247                         vcp->cursor_mobs[i] = vps->cursor.bo;
 248                         vps->cursor.bo = NULL;
 249                         return;
 250                 }
 251         }
 252
 253         /* Cache is full: See if this mob is bigger than an existing mob. */
 254         for (i = 0; i < ARRAY_SIZE(vcp->cursor_mobs); i++) {
 255                 if (vcp->cursor_mobs[i]->tbo.base.size <
 256                     vps->cursor.bo->tbo.base.size) {
 257                         vmw_du_destroy_cursor_mob(&vcp->cursor_mobs[i]);
 258                         vcp->cursor_mobs[i] = vps->cursor.bo;
 259                         vps->cursor.bo = NULL;
 260                         return;
 261                 }
 262         }
 263
 264         /* Destroy it if it's not worth caching. */
 265         vmw_du_destroy_cursor_mob(&vps->cursor.bo);
 266 }
 267
 268 static int vmw_du_get_cursor_mob(struct vmw_cursor_plane *vcp,
 269                                  struct vmw_plane_state *vps)
 270 {
 271         struct vmw_private *dev_priv = vcp->base.dev->dev_private;
 272         u32 size = vmw_du_cursor_mob_size(vps->base.crtc_w, vps->base.crtc_h);
 273         u32 i;
 274         u32 cursor_max_dim, mob_max_size;
 275         struct vmw_fence_obj *fence = NULL;
 276         int ret;
 277
 278         if (!dev_priv->has_mob ||
 279             (dev_priv->capabilities2 & SVGA_CAP2_CURSOR_MOB) == 0)
 280                 return -EINVAL;
 281
 282         mob_max_size = vmw_read(dev_priv, SVGA_REG_MOB_MAX_SIZE);
 283         cursor_max_dim = vmw_read(dev_priv, SVGA_REG_CURSOR_MAX_DIMENSION);
 284
 285         if (size > mob_max_size || vps->base.crtc_w > cursor_max_dim ||
 286             vps->base.crtc_h > cursor_max_dim)
 287                 return -EINVAL;
 288
 289         if (vps->cursor.bo) {
 290                 if (vps->cursor.bo->tbo.base.size >= size)
 291                         return 0;
 292                 vmw_du_put_cursor_mob(vcp, vps);
 293         }
 294
 295         /* Look for an unused mob in the cache. */
 296         for (i = 0; i < ARRAY_SIZE(vcp->cursor_mobs); i++) {
 297                 if (vcp->cursor_mobs[i] &&
 298                     vcp->cursor_mobs[i]->tbo.base.size >= size) {
 299                         vps->cursor.bo = vcp->cursor_mobs[i];
 300                         vcp->cursor_mobs[i] = NULL;
 301                         return 0;
 302                 }
 303         }
 304         /* Create a new mob if we can't find an existing one. */
 305         ret = vmw_bo_create_and_populate(dev_priv, size,
 306                                          VMW_BO_DOMAIN_MOB,
 307                                          &vps->cursor.bo);
 308
 309         if (ret != 0)
 310                 return ret;
 311
 312         /* Fence the mob creation so we are guarateed to have the mob */
 313         ret = ttm_bo_reserve(&vps->cursor.bo->tbo, false, false, NULL);
 314         if (ret != 0)
 315                 goto teardown;
 316
 317         ret = vmw_execbuf_fence_commands(NULL, dev_priv, &fence, NULL);
 318         if (ret != 0) {
 319                 ttm_bo_unreserve(&vps->cursor.bo->tbo);
 320                 goto teardown;
 321         }
 322
 323         dma_fence_wait(&fence->base, false);
 324         dma_fence_put(&fence->base);
 325
 326         ttm_bo_unreserve(&vps->cursor.bo->tbo);
 327         return 0;
 328
 329 teardown:
 330         vmw_du_destroy_cursor_mob(&vps->cursor.bo);
 331         return ret;
 332 }
 333
 334
 335 static void vmw_cursor_update_position(struct vmw_private *dev_priv,
 336                                        bool show, int x, int y)
 337 {
 338         const uint32_t svga_cursor_on = show ? SVGA_CURSOR_ON_SHOW
 339                                              : SVGA_CURSOR_ON_HIDE;
 340         uint32_t count;
 341
 342         spin_lock(&dev_priv->cursor_lock);
 343         if (dev_priv->capabilities2 & SVGA_CAP2_EXTRA_REGS) {
 344                 vmw_write(dev_priv, SVGA_REG_CURSOR4_X, x);
 345                 vmw_write(dev_priv, SVGA_REG_CURSOR4_Y, y);
 346                 vmw_write(dev_priv, SVGA_REG_CURSOR4_SCREEN_ID, SVGA3D_INVALID_ID);
 347                 vmw_write(dev_priv, SVGA_REG_CURSOR4_ON, svga_cursor_on);
 348                 vmw_write(dev_priv, SVGA_REG_CURSOR4_SUBMIT, 1);
 349         } else if (vmw_is_cursor_bypass3_enabled(dev_priv)) {
 350                 vmw_fifo_mem_write(dev_priv, SVGA_FIFO_CURSOR_ON, svga_cursor_on);
 351                 vmw_fifo_mem_write(dev_priv, SVGA_FIFO_CURSOR_X, x);
 352                 vmw_fifo_mem_write(dev_priv, SVGA_FIFO_CURSOR_Y, y);
 353                 count = vmw_fifo_mem_read(dev_priv, SVGA_FIFO_CURSOR_COUNT);
 354                 vmw_fifo_mem_write(dev_priv, SVGA_FIFO_CURSOR_COUNT, ++count);
 355         } else {
 356                 vmw_write(dev_priv, SVGA_REG_CURSOR_X, x);
 357                 vmw_write(dev_priv, SVGA_REG_CURSOR_Y, y);
 358                 vmw_write(dev_priv, SVGA_REG_CURSOR_ON, svga_cursor_on);
 359         }
 360         spin_unlock(&dev_priv->cursor_lock);
 361 }
 362
 363 void vmw_kms_cursor_snoop(struct vmw_surface *srf,
 364                           struct ttm_object_file *tfile,
 365                           struct ttm_buffer_object *bo,
 366                           SVGA3dCmdHeader *header)
 367 {
 368         struct ttm_bo_kmap_obj map;
 369         unsigned long kmap_offset;
 370         unsigned long kmap_num;
 371         SVGA3dCopyBox *box;
 372         unsigned box_count;
 373         void *virtual;
 374         bool is_iomem;
 375         struct vmw_dma_cmd {
 376                 SVGA3dCmdHeader header;
 377                 SVGA3dCmdSurfaceDMA dma;
 378         } *cmd;
 379         int i, ret;
 380         const struct SVGA3dSurfaceDesc *desc =
 381                 vmw_surface_get_desc(VMW_CURSOR_SNOOP_FORMAT);
 382         const u32 image_pitch = VMW_CURSOR_SNOOP_WIDTH * desc->pitchBytesPerBlock;
 383
 384         cmd = container_of(header, struct vmw_dma_cmd, header);
 385
 386         /* No snooper installed, nothing to copy */
 387         if (!srf->snooper.image)
 388                 return;
 389
 390         if (cmd->dma.host.face != 0 || cmd->dma.host.mipmap != 0) {
 391                 DRM_ERROR("face and mipmap for cursors should never != 0\n");
 392                 return;
 393         }
 394
 395         if (cmd->header.size < 64) {
 396                 DRM_ERROR("at least one full copy box must be given\n");
 397                 return;
 398         }
 399
 400         box = (SVGA3dCopyBox *)&cmd[1];
 401         box_count = (cmd->header.size - sizeof(SVGA3dCmdSurfaceDMA)) /
 402                         sizeof(SVGA3dCopyBox);
 403
 404         if (cmd->dma.guest.ptr.offset % PAGE_SIZE ||
 405             box->x != 0    || box->y != 0    || box->z != 0    ||
 406             box->srcx != 0 || box->srcy != 0 || box->srcz != 0 ||
 407             box->d != 1    || box_count != 1 ||
 408             box->w > VMW_CURSOR_SNOOP_WIDTH || box->h > VMW_CURSOR_SNOOP_HEIGHT) {
 409                 /* TODO handle none page aligned offsets */
 410                 /* TODO handle more dst & src != 0 */
 411                 /* TODO handle more then one copy */
 412                 DRM_ERROR("Can't snoop dma request for cursor!\n");
 413                 DRM_ERROR("(%u, %u, %u) (%u, %u, %u) (%ux%ux%u) %u %u\n",
 414                           box->srcx, box->srcy, box->srcz,
 415                           box->x, box->y, box->z,
 416                           box->w, box->h, box->d, box_count,
 417                           cmd->dma.guest.ptr.offset);
 418                 return;
 419         }
 420
 421         kmap_offset = cmd->dma.guest.ptr.offset >> PAGE_SHIFT;
 422         kmap_num = (VMW_CURSOR_SNOOP_HEIGHT*image_pitch) >> PAGE_SHIFT;
 423
 424         ret = ttm_bo_reserve(bo, true, false, NULL);
 425         if (unlikely(ret != 0)) {
 426                 DRM_ERROR("reserve failed\n");
 427                 return;
 428         }
 429
 430         ret = ttm_bo_kmap(bo, kmap_offset, kmap_num, &map);
 431         if (unlikely(ret != 0))
 432                 goto err_unreserve;
 433
 434         virtual = ttm_kmap_obj_virtual(&map, &is_iomem);
 435
 436         if (box->w == VMW_CURSOR_SNOOP_WIDTH && cmd->dma.guest.pitch == image_pitch) {
 437                 memcpy(srf->snooper.image, virtual,
 438                        VMW_CURSOR_SNOOP_HEIGHT*image_pitch);
 439         } else {
 440                 /* Image is unsigned pointer. */
 441                 for (i = 0; i < box->h; i++)
 442                         memcpy(srf->snooper.image + i * image_pitch,
 443                                virtual + i * cmd->dma.guest.pitch,
 444                                box->w * desc->pitchBytesPerBlock);
 445         }
 446
 447         srf->snooper.age++;
 448
 449         ttm_bo_kunmap(&map);
 450 err_unreserve:
 451         ttm_bo_unreserve(bo);
 452 }
 453
 454 /**
 455  * vmw_kms_legacy_hotspot_clear - Clear legacy hotspots
 456  *
 457  * @dev_priv: Pointer to the device private struct.
 458  *
 459  * Clears all legacy hotspots.
 460  */
 461 void vmw_kms_legacy_hotspot_clear(struct vmw_private *dev_priv)
 462 {
 463         struct drm_device *dev = &dev_priv->drm;
 464         struct vmw_display_unit *du;
 465         struct drm_crtc *crtc;
 466
 467         drm_modeset_lock_all(dev);
 468         drm_for_each_crtc(crtc, dev) {
 469                 du = vmw_crtc_to_du(crtc);
 470
 471                 du->hotspot_x = 0;
 472                 du->hotspot_y = 0;
 473         }
 474         drm_modeset_unlock_all(dev);
 475 }
 476
 477 void vmw_kms_cursor_post_execbuf(struct vmw_private *dev_priv)
 478 {
 479         struct drm_device *dev = &dev_priv->drm;
 480         struct vmw_display_unit *du;
 481         struct drm_crtc *crtc;
 482
 483         mutex_lock(&dev->mode_config.mutex);
 484
 485         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
 486                 du = vmw_crtc_to_du(crtc);
 487                 if (!du->cursor_surface ||
 488                     du->cursor_age == du->cursor_surface->snooper.age ||
 489                     !du->cursor_surface->snooper.image)
 490                         continue;
 491
 492                 du->cursor_age = du->cursor_surface->snooper.age;
 493                 vmw_send_define_cursor_cmd(dev_priv,
 494                                            du->cursor_surface->snooper.image,
 495                                            VMW_CURSOR_SNOOP_WIDTH,
 496                                            VMW_CURSOR_SNOOP_HEIGHT,
 497                                            du->hotspot_x + du->core_hotspot_x,
 498                                            du->hotspot_y + du->core_hotspot_y);
 499         }
 500
 501         mutex_unlock(&dev->mode_config.mutex);
 502 }
 503
 504
 505 void vmw_du_cursor_plane_destroy(struct drm_plane *plane)
 506 {
 507         struct vmw_cursor_plane *vcp = vmw_plane_to_vcp(plane);
 508         u32 i;
 509
 510         vmw_cursor_update_position(plane->dev->dev_private, false, 0, 0);
 511
 512         for (i = 0; i < ARRAY_SIZE(vcp->cursor_mobs); i++)
 513                 vmw_du_destroy_cursor_mob(&vcp->cursor_mobs[i]);
 514
 515         drm_plane_cleanup(plane);
 516 }
 517
 518
 519 void vmw_du_primary_plane_destroy(struct drm_plane *plane)
 520 {
 521         drm_plane_cleanup(plane);
 522
 523         /* Planes are static in our case so we don't free it */
 524 }
 525
 526
 527 /**
 528  * vmw_du_plane_unpin_surf - unpins resource associated with a framebuffer surface
 529  *
 530  * @vps: plane state associated with the display surface
 531  * @unreference: true if we also want to unreference the display.
 532  */
 533 void vmw_du_plane_unpin_surf(struct vmw_plane_state *vps,
 534                              bool unreference)
 535 {
 536         if (vps->surf) {
 537                 if (vps->pinned) {
 538                         vmw_resource_unpin(&vps->surf->res);
 539                         vps->pinned--;
 540                 }
 541
 542                 if (unreference) {
 543                         if (vps->pinned)
 544                                 DRM_ERROR("Surface still pinned\n");
 545                         vmw_surface_unreference(&vps->surf);
 546                 }
 547         }
 548 }
 549
 550
 551 /**
 552  * vmw_du_plane_cleanup_fb - Unpins the plane surface
 553  *
 554  * @plane:  display plane
 555  * @old_state: Contains the FB to clean up
 556  *
 557  * Unpins the framebuffer surface
 558  *
 559  * Returns 0 on success
 560  */
 561 void
 562 vmw_du_plane_cleanup_fb(struct drm_plane *plane,
 563                         struct drm_plane_state *old_state)
 564 {
 565         struct vmw_plane_state *vps = vmw_plane_state_to_vps(old_state);
 566
 567         vmw_du_plane_unpin_surf(vps, false);
 568 }
 569
 570
 571 /**
 572  * vmw_du_cursor_plane_map_cm - Maps the cursor mobs.
 573  *
 574  * @vps: plane_state
 575  *
 576  * Returns 0 on success
 577  */
 578
 579 static int
 580 vmw_du_cursor_plane_map_cm(struct vmw_plane_state *vps)
 581 {
 582         int ret;
 583         u32 size = vmw_du_cursor_mob_size(vps->base.crtc_w, vps->base.crtc_h);
 584         struct ttm_buffer_object *bo;
 585
 586         if (!vps->cursor.bo)
 587                 return -EINVAL;
 588
 589         bo = &vps->cursor.bo->tbo;
 590
 591         if (bo->base.size < size)
 592                 return -EINVAL;
 593
 594         if (vps->cursor.bo->map.virtual)
 595                 return 0;
 596
 597         ret = ttm_bo_reserve(bo, false, false, NULL);
 598         if (unlikely(ret != 0))
 599                 return -ENOMEM;
 600
 601         vmw_bo_map_and_cache(vps->cursor.bo);
 602
 603         ttm_bo_unreserve(bo);
 604
 605         if (unlikely(ret != 0))
 606                 return -ENOMEM;
 607
 608         return 0;
 609 }
 610
 611
 612 /**
 613  * vmw_du_cursor_plane_unmap_cm - Unmaps the cursor mobs.
 614  *
 615  * @vps: state of the cursor plane
 616  *
 617  * Returns 0 on success
 618  */
 619
 620 static int
 621 vmw_du_cursor_plane_unmap_cm(struct vmw_plane_state *vps)
 622 {
 623         int ret = 0;
 624         struct vmw_bo *vbo = vps->cursor.bo;
 625
 626         if (!vbo || !vbo->map.virtual)
 627                 return 0;
 628
 629         ret = ttm_bo_reserve(&vbo->tbo, true, false, NULL);
 630         if (likely(ret == 0)) {
 631                 vmw_bo_unmap(vbo);
 632                 ttm_bo_unreserve(&vbo->tbo);
 633         }
 634
 635         return ret;
 636 }
 637
 638
 639 /**
 640  * vmw_du_cursor_plane_cleanup_fb - Unpins the plane surface
 641  *
 642  * @plane: cursor plane
 643  * @old_state: contains the state to clean up
 644  *
 645  * Unmaps all cursor bo mappings and unpins the cursor surface
 646  *
 647  * Returns 0 on success
 648  */
 649 void
 650 vmw_du_cursor_plane_cleanup_fb(struct drm_plane *plane,
 651                                struct drm_plane_state *old_state)
 652 {
 653         struct vmw_cursor_plane *vcp = vmw_plane_to_vcp(plane);
 654         struct vmw_plane_state *vps = vmw_plane_state_to_vps(old_state);
 655
 656         if (vps->surf_mapped) {
 657                 vmw_bo_unmap(vps->surf->res.guest_memory_bo);
 658                 vps->surf_mapped = false;
 659         }
 660
 661         vmw_du_cursor_plane_unmap_cm(vps);
 662         vmw_du_put_cursor_mob(vcp, vps);
 663
 664         vmw_du_plane_unpin_surf(vps, false);
 665
 666         if (vps->surf) {
 667                 vmw_surface_unreference(&vps->surf);
 668                 vps->surf = NULL;
 669         }
 670
 671         if (vps->bo) {
 672                 vmw_bo_unreference(&vps->bo);
 673                 vps->bo = NULL;
 674         }
 675 }
 676
 677
 678 /**
 679  * vmw_du_cursor_plane_prepare_fb - Readies the cursor by referencing it
 680  *
 681  * @plane:  display plane
 682  * @new_state: info on the new plane state, including the FB
 683  *
 684  * Returns 0 on success
 685  */
 686 int
 687 vmw_du_cursor_plane_prepare_fb(struct drm_plane *plane,
 688                                struct drm_plane_state *new_state)
 689 {
 690         struct drm_framebuffer *fb = new_state->fb;
 691         struct vmw_cursor_plane *vcp = vmw_plane_to_vcp(plane);
 692         struct vmw_plane_state *vps = vmw_plane_state_to_vps(new_state);
 693         int ret = 0;
 694
 695         if (vps->surf) {
 696                 if (vps->surf_mapped) {
 697                         vmw_bo_unmap(vps->surf->res.guest_memory_bo);
 698                         vps->surf_mapped = false;
 699                 }
 700                 vmw_surface_unreference(&vps->surf);
 701                 vps->surf = NULL;
 702         }
 703
 704         if (vps->bo) {
 705                 vmw_bo_unreference(&vps->bo);
 706                 vps->bo = NULL;
 707         }
 708
 709         if (fb) {
 710                 if (vmw_framebuffer_to_vfb(fb)->bo) {
 711                         vps->bo = vmw_framebuffer_to_vfbd(fb)->buffer;
 712                         vmw_bo_reference(vps->bo);
 713                 } else {
 714                         vps->surf = vmw_framebuffer_to_vfbs(fb)->surface;
 715                         vmw_surface_reference(vps->surf);
 716                 }
 717         }
 718
 719         if (!vps->surf && vps->bo) {
 720                 const u32 size = new_state->crtc_w * new_state->crtc_h * sizeof(u32);
 721
 722                 /*
 723                  * Not using vmw_bo_map_and_cache() helper here as we need to
 724                  * reserve the ttm_buffer_object first which
 725                  * vmw_bo_map_and_cache() omits.
 726                  */
 727                 ret = ttm_bo_reserve(&vps->bo->tbo, true, false, NULL);
 728
 729                 if (unlikely(ret != 0))
 730                         return -ENOMEM;
 731
 732                 ret = ttm_bo_kmap(&vps->bo->tbo, 0, PFN_UP(size), &vps->bo->map);
 733
 734                 ttm_bo_unreserve(&vps->bo->tbo);
 735
 736                 if (unlikely(ret != 0))
 737                         return -ENOMEM;
 738         } else if (vps->surf && !vps->bo && vps->surf->res.guest_memory_bo) {
 739
 740                 WARN_ON(vps->surf->snooper.image);
 741                 ret = ttm_bo_reserve(&vps->surf->res.guest_memory_bo->tbo, true, false,
 742                                      NULL);
 743                 if (unlikely(ret != 0))
 744                         return -ENOMEM;
 745                 vmw_bo_map_and_cache(vps->surf->res.guest_memory_bo);
 746                 ttm_bo_unreserve(&vps->surf->res.guest_memory_bo->tbo);
 747                 vps->surf_mapped = true;
 748         }
 749
 750         if (vps->surf || vps->bo) {
 751                 vmw_du_get_cursor_mob(vcp, vps);
 752                 vmw_du_cursor_plane_map_cm(vps);
 753         }
 754
 755         return 0;
 756 }
 757
 758
 759 void
 760 vmw_du_cursor_plane_atomic_update(struct drm_plane *plane,
 761                                   struct drm_atomic_state *state)
 762 {
 763         struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
 764                                                                            plane);
 765         struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
 766                                                                            plane);
 767         struct drm_crtc *crtc = new_state->crtc ?: old_state->crtc;
 768         struct vmw_private *dev_priv = vmw_priv(crtc->dev);
 769         struct vmw_display_unit *du = vmw_crtc_to_du(crtc);
 770         struct vmw_plane_state *vps = vmw_plane_state_to_vps(new_state);
 771         struct vmw_plane_state *old_vps = vmw_plane_state_to_vps(old_state);
 772         s32 hotspot_x, hotspot_y;
 773
 774         hotspot_x = du->hotspot_x + new_state->hotspot_x;
 775         hotspot_y = du->hotspot_y + new_state->hotspot_y;
 776
 777         du->cursor_surface = vps->surf;
 778         du->cursor_bo = vps->bo;
 779
 780         if (!vps->surf && !vps->bo) {
 781                 vmw_cursor_update_position(dev_priv, false, 0, 0);
 782                 return;
 783         }
 784
 785         vps->cursor.hotspot_x = hotspot_x;
 786         vps->cursor.hotspot_y = hotspot_y;
 787
 788         if (vps->surf) {
 789                 du->cursor_age = du->cursor_surface->snooper.age;
 790         }
 791
 792         if (!vmw_du_cursor_plane_has_changed(old_vps, vps)) {
 793                 /*
 794                  * If it hasn't changed, avoid making the device do extra
 795                  * work by keeping the old cursor active.
 796                  */
 797                 struct vmw_cursor_plane_state tmp = old_vps->cursor;
 798                 old_vps->cursor = vps->cursor;
 799                 vps->cursor = tmp;
 800         } else {
 801                 void *image = vmw_du_cursor_plane_acquire_image(vps);
 802                 if (image)
 803                         vmw_cursor_update_image(dev_priv, vps, image,
 804                                                 new_state->crtc_w,
 805                                                 new_state->crtc_h,
 806                                                 hotspot_x, hotspot_y);
 807         }
 808
 809         du->cursor_x = new_state->crtc_x + du->set_gui_x;
 810         du->cursor_y = new_state->crtc_y + du->set_gui_y;
 811
 812         vmw_cursor_update_position(dev_priv, true,
 813                                    du->cursor_x + hotspot_x,
 814                                    du->cursor_y + hotspot_y);
 815
 816         du->core_hotspot_x = hotspot_x - du->hotspot_x;
 817         du->core_hotspot_y = hotspot_y - du->hotspot_y;
 818 }
 819
 820
 821 /**
 822  * vmw_du_primary_plane_atomic_check - check if the new state is okay
 823  *
 824  * @plane: display plane
 825  * @state: info on the new plane state, including the FB
 826  *
 827  * Check if the new state is settable given the current state.  Other
 828  * than what the atomic helper checks, we care about crtc fitting
 829  * the FB and maintaining one active framebuffer.
 830  *
 831  * Returns 0 on success
 832  */
 833 int vmw_du_primary_plane_atomic_check(struct drm_plane *plane,
 834                                       struct drm_atomic_state *state)
 835 {
 836         struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
 837                                                                            plane);
 838         struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
 839                                                                            plane);
 840         struct drm_crtc_state *crtc_state = NULL;
 841         struct drm_framebuffer *new_fb = new_state->fb;
 842         struct drm_framebuffer *old_fb = old_state->fb;
 843         int ret;
 844
 845         /*
 846          * Ignore damage clips if the framebuffer attached to the plane's state
 847          * has changed since the last plane update (page-flip). In this case, a
 848          * full plane update should happen because uploads are done per-buffer.
 849          */
 850         if (old_fb != new_fb)
 851                 new_state->ignore_damage_clips = true;
 852
 853         if (new_state->crtc)
 854                 crtc_state = drm_atomic_get_new_crtc_state(state,
 855                                                            new_state->crtc);
 856
 857         ret = drm_atomic_helper_check_plane_state(new_state, crtc_state,
 858                                                   DRM_PLANE_NO_SCALING,
 859                                                   DRM_PLANE_NO_SCALING,
 860                                                   false, true);
 861
 862         if (!ret && new_fb) {
 863                 struct drm_crtc *crtc = new_state->crtc;
 864                 struct vmw_display_unit *du = vmw_crtc_to_du(crtc);
 865
 866                 vmw_connector_state_to_vcs(du->connector.state);
 867         }
 868
 869
 870         return ret;
 871 }
 872
 873
 874 /**
 875  * vmw_du_cursor_plane_atomic_check - check if the new state is okay
 876  *
 877  * @plane: cursor plane
 878  * @state: info on the new plane state
 879  *
 880  * This is a chance to fail if the new cursor state does not fit
 881  * our requirements.
 882  *
 883  * Returns 0 on success
 884  */
 885 int vmw_du_cursor_plane_atomic_check(struct drm_plane *plane,
 886                                      struct drm_atomic_state *state)
 887 {
 888         struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
 889                                                                            plane);
 890         int ret = 0;
 891         struct drm_crtc_state *crtc_state = NULL;
 892         struct vmw_surface *surface = NULL;
 893         struct drm_framebuffer *fb = new_state->fb;
 894
 895         if (new_state->crtc)
 896                 crtc_state = drm_atomic_get_new_crtc_state(new_state->state,
 897                                                            new_state->crtc);
 898
 899         ret = drm_atomic_helper_check_plane_state(new_state, crtc_state,
 900                                                   DRM_PLANE_NO_SCALING,
 901                                                   DRM_PLANE_NO_SCALING,
 902                                                   true, true);
 903         if (ret)
 904                 return ret;
 905
 906         /* Turning off */
 907         if (!fb)
 908                 return 0;
 909
 910         /* A lot of the code assumes this */
 911         if (new_state->crtc_w != 64 || new_state->crtc_h != 64) {
 912                 DRM_ERROR("Invalid cursor dimensions (%d, %d)\n",
 913                           new_state->crtc_w, new_state->crtc_h);
 914                 return -EINVAL;
 915         }
 916
 917         if (!vmw_framebuffer_to_vfb(fb)->bo) {
 918                 surface = vmw_framebuffer_to_vfbs(fb)->surface;
 919
 920                 WARN_ON(!surface);
 921
 922                 if (!surface ||
 923                     (!surface->snooper.image && !surface->res.guest_memory_bo)) {
 924                         DRM_ERROR("surface not suitable for cursor\n");
 925                         return -EINVAL;
 926                 }
 927         }
 928
 929         return 0;
 930 }
 931
 932
 933 int vmw_du_crtc_atomic_check(struct drm_crtc *crtc,
 934                              struct drm_atomic_state *state)
 935 {
 936         struct vmw_private *vmw = vmw_priv(crtc->dev);
 937         struct drm_crtc_state *new_state = drm_atomic_get_new_crtc_state(state,
 938                                                                          crtc);
 939         struct vmw_display_unit *du = vmw_crtc_to_du(new_state->crtc);
 940         int connector_mask = drm_connector_mask(&du->connector);
 941         bool has_primary = new_state->plane_mask &
 942                            drm_plane_mask(crtc->primary);
 943
 944         /*
 945          * This is fine in general, but broken userspace might expect
 946          * some actual rendering so give a clue as why it's blank.
 947          */
 948         if (new_state->enable && !has_primary)
 949                 drm_dbg_driver(&vmw->drm,
 950                                "CRTC without a primary plane will be blank.\n");
 951
 952
 953         if (new_state->connector_mask != connector_mask &&
 954             new_state->connector_mask != 0) {
 955                 DRM_ERROR("Invalid connectors configuration\n");
 956                 return -EINVAL;
 957         }
 958
 959         /*
 960          * Our virtual device does not have a dot clock, so use the logical
 961          * clock value as the dot clock.
 962          */
 963         if (new_state->mode.crtc_clock == 0)
 964                 new_state->adjusted_mode.crtc_clock = new_state->mode.clock;
 965
 966         return 0;
 967 }
 968
 969
 970 void vmw_du_crtc_atomic_begin(struct drm_crtc *crtc,
 971                               struct drm_atomic_state *state)
 972 {
 973 }
 974
 975
 976 void vmw_du_crtc_atomic_flush(struct drm_crtc *crtc,
 977                               struct drm_atomic_state *state)
 978 {
 979 }
 980
 981
 982 /**
 983  * vmw_du_crtc_duplicate_state - duplicate crtc state
 984  * @crtc: DRM crtc
 985  *
 986  * Allocates and returns a copy of the crtc state (both common and
 987  * vmw-specific) for the specified crtc.
 988  *
 989  * Returns: The newly allocated crtc state, or NULL on failure.
 990  */
 991 struct drm_crtc_state *
 992 vmw_du_crtc_duplicate_state(struct drm_crtc *crtc)
 993 {
 994         struct drm_crtc_state *state;
 995         struct vmw_crtc_state *vcs;
 996
 997         if (WARN_ON(!crtc->state))
 998                 return NULL;
 999
1000         vcs = kmemdup(crtc->state, sizeof(*vcs), GFP_KERNEL);
1001
1002         if (!vcs)
1003                 return NULL;
1004
1005         state = &vcs->base;
1006
1007         __drm_atomic_helper_crtc_duplicate_state(crtc, state);
1008
1009         return state;
1010 }
1011
1012
1013 /**
1014  * vmw_du_crtc_reset - creates a blank vmw crtc state
1015  * @crtc: DRM crtc
1016  *
1017  * Resets the atomic state for @crtc by freeing the state pointer (which
1018  * might be NULL, e.g. at driver load time) and allocating a new empty state
1019  * object.
1020  */
1021 void vmw_du_crtc_reset(struct drm_crtc *crtc)
1022 {
1023         struct vmw_crtc_state *vcs;
1024
1025
1026         if (crtc->state) {
1027                 __drm_atomic_helper_crtc_destroy_state(crtc->state);
1028
1029                 kfree(vmw_crtc_state_to_vcs(crtc->state));
1030         }
1031
1032         vcs = kzalloc(sizeof(*vcs), GFP_KERNEL);
1033
1034         if (!vcs) {
1035                 DRM_ERROR("Cannot allocate vmw_crtc_state\n");
1036                 return;
1037         }
1038
1039         __drm_atomic_helper_crtc_reset(crtc, &vcs->base);
1040 }
1041
1042
1043 /**
1044  * vmw_du_crtc_destroy_state - destroy crtc state
1045  * @crtc: DRM crtc
1046  * @state: state object to destroy
1047  *
1048  * Destroys the crtc state (both common and vmw-specific) for the
1049  * specified plane.
1050  */
1051 void
1052 vmw_du_crtc_destroy_state(struct drm_crtc *crtc,
1053                           struct drm_crtc_state *state)
1054 {
1055         drm_atomic_helper_crtc_destroy_state(crtc, state);
1056 }
1057
1058
1059 /**
1060  * vmw_du_plane_duplicate_state - duplicate plane state
1061  * @plane: drm plane
1062  *
1063  * Allocates and returns a copy of the plane state (both common and
1064  * vmw-specific) for the specified plane.
1065  *
1066  * Returns: The newly allocated plane state, or NULL on failure.
1067  */
1068 struct drm_plane_state *
1069 vmw_du_plane_duplicate_state(struct drm_plane *plane)
1070 {
1071         struct drm_plane_state *state;
1072         struct vmw_plane_state *vps;
1073
1074         vps = kmemdup(plane->state, sizeof(*vps), GFP_KERNEL);
1075
1076         if (!vps)
1077                 return NULL;
1078
1079         vps->pinned = 0;
1080         vps->cpp = 0;
1081
1082         memset(&vps->cursor, 0, sizeof(vps->cursor));
1083
1084         /* Each ref counted resource needs to be acquired again */
1085         if (vps->surf)
1086                 (void) vmw_surface_reference(vps->surf);
1087
1088         if (vps->bo)
1089                 (void) vmw_bo_reference(vps->bo);
1090
1091         state = &vps->base;
1092
1093         __drm_atomic_helper_plane_duplicate_state(plane, state);
1094
1095         return state;
1096 }
1097
1098
1099 /**
1100  * vmw_du_plane_reset - creates a blank vmw plane state
1101  * @plane: drm plane
1102  *
1103  * Resets the atomic state for @plane by freeing the state pointer (which might
1104  * be NULL, e.g. at driver load time) and allocating a new empty state object.
1105  */
1106 void vmw_du_plane_reset(struct drm_plane *plane)
1107 {
1108         struct vmw_plane_state *vps;
1109
1110         if (plane->state)
1111                 vmw_du_plane_destroy_state(plane, plane->state);
1112
1113         vps = kzalloc(sizeof(*vps), GFP_KERNEL);
1114
1115         if (!vps) {
1116                 DRM_ERROR("Cannot allocate vmw_plane_state\n");
1117                 return;
1118         }
1119
1120         __drm_atomic_helper_plane_reset(plane, &vps->base);
1121 }
1122
1123
1124 /**
1125  * vmw_du_plane_destroy_state - destroy plane state
1126  * @plane: DRM plane
1127  * @state: state object to destroy
1128  *
1129  * Destroys the plane state (both common and vmw-specific) for the
1130  * specified plane.
1131  */
1132 void
1133 vmw_du_plane_destroy_state(struct drm_plane *plane,
1134                            struct drm_plane_state *state)
1135 {
1136         struct vmw_plane_state *vps = vmw_plane_state_to_vps(state);
1137
1138         /* Should have been freed by cleanup_fb */
1139         if (vps->surf)
1140                 vmw_surface_unreference(&vps->surf);
1141
1142         if (vps->bo)
1143                 vmw_bo_unreference(&vps->bo);
1144
1145         drm_atomic_helper_plane_destroy_state(plane, state);
1146 }
1147
1148
1149 /**
1150  * vmw_du_connector_duplicate_state - duplicate connector state
1151  * @connector: DRM connector
1152  *
1153  * Allocates and returns a copy of the connector state (both common and
1154  * vmw-specific) for the specified connector.
1155  *
1156  * Returns: The newly allocated connector state, or NULL on failure.
1157  */
1158 struct drm_connector_state *
1159 vmw_du_connector_duplicate_state(struct drm_connector *connector)
1160 {
1161         struct drm_connector_state *state;
1162         struct vmw_connector_state *vcs;
1163
1164         if (WARN_ON(!connector->state))
1165                 return NULL;
1166
1167         vcs = kmemdup(connector->state, sizeof(*vcs), GFP_KERNEL);
1168
1169         if (!vcs)
1170                 return NULL;
1171
1172         state = &vcs->base;
1173
1174         __drm_atomic_helper_connector_duplicate_state(connector, state);
1175
1176         return state;
1177 }
1178
1179
1180 /**
1181  * vmw_du_connector_reset - creates a blank vmw connector state
1182  * @connector: DRM connector
1183  *
1184  * Resets the atomic state for @connector by freeing the state pointer (which
1185  * might be NULL, e.g. at driver load time) and allocating a new empty state
1186  * object.
1187  */
1188 void vmw_du_connector_reset(struct drm_connector *connector)
1189 {
1190         struct vmw_connector_state *vcs;
1191
1192
1193         if (connector->state) {
1194                 __drm_atomic_helper_connector_destroy_state(connector->state);
1195
1196                 kfree(vmw_connector_state_to_vcs(connector->state));
1197         }
1198
1199         vcs = kzalloc(sizeof(*vcs), GFP_KERNEL);
1200
1201         if (!vcs) {
1202                 DRM_ERROR("Cannot allocate vmw_connector_state\n");
1203                 return;
1204         }
1205
1206         __drm_atomic_helper_connector_reset(connector, &vcs->base);
1207 }
1208
1209
1210 /**
1211  * vmw_du_connector_destroy_state - destroy connector state
1212  * @connector: DRM connector
1213  * @state: state object to destroy
1214  *
1215  * Destroys the connector state (both common and vmw-specific) for the
1216  * specified plane.
1217  */
1218 void
1219 vmw_du_connector_destroy_state(struct drm_connector *connector,
1220                           struct drm_connector_state *state)
1221 {
1222         drm_atomic_helper_connector_destroy_state(connector, state);
1223 }
1224 /*
1225  * Generic framebuffer code
1226  */
1227
1228 /*
1229  * Surface framebuffer code
1230  */
1231
1232 static void vmw_framebuffer_surface_destroy(struct drm_framebuffer *framebuffer)
1233 {
1234         struct vmw_framebuffer_surface *vfbs =
1235                 vmw_framebuffer_to_vfbs(framebuffer);
1236
1237         drm_framebuffer_cleanup(framebuffer);
1238         vmw_surface_unreference(&vfbs->surface);
1239
1240         kfree(vfbs);
1241 }
1242
1243 /**
1244  * vmw_kms_readback - Perform a readback from the screen system to
1245  * a buffer-object backed framebuffer.
1246  *
1247  * @dev_priv: Pointer to the device private structure.
1248  * @file_priv: Pointer to a struct drm_file identifying the caller.
1249  * Must be set to NULL if @user_fence_rep is NULL.
1250  * @vfb: Pointer to the buffer-object backed framebuffer.
1251  * @user_fence_rep: User-space provided structure for fence information.
1252  * Must be set to non-NULL if @file_priv is non-NULL.
1253  * @vclips: Array of clip rects.
1254  * @num_clips: Number of clip rects in @vclips.
1255  *
1256  * Returns 0 on success, negative error code on failure. -ERESTARTSYS if
1257  * interrupted.
1258  */
1259 int vmw_kms_readback(struct vmw_private *dev_priv,
1260                      struct drm_file *file_priv,
1261                      struct vmw_framebuffer *vfb,
1262                      struct drm_vmw_fence_rep __user *user_fence_rep,
1263                      struct drm_vmw_rect *vclips,
1264                      uint32_t num_clips)
1265 {
1266         switch (dev_priv->active_display_unit) {
1267         case vmw_du_screen_object:
1268                 return vmw_kms_sou_readback(dev_priv, file_priv, vfb,
1269                                             user_fence_rep, vclips, num_clips,
1270                                             NULL);
1271         case vmw_du_screen_target:
1272                 return vmw_kms_stdu_readback(dev_priv, file_priv, vfb,
1273                                              user_fence_rep, NULL, vclips, num_clips,
1274                                              1, NULL);
1275         default:
1276                 WARN_ONCE(true,
1277                           "Readback called with invalid display system.\n");
1278 }
1279
1280         return -ENOSYS;
1281 }
1282
1283
1284 static const struct drm_framebuffer_funcs vmw_framebuffer_surface_funcs = {
1285         .destroy = vmw_framebuffer_surface_destroy,
1286         .dirty = drm_atomic_helper_dirtyfb,
1287 };
1288
1289 static int vmw_kms_new_framebuffer_surface(struct vmw_private *dev_priv,
1290                                            struct vmw_surface *surface,
1291                                            struct vmw_framebuffer **out,
1292                                            const struct drm_mode_fb_cmd2
1293                                            *mode_cmd,
1294                                            bool is_bo_proxy)
1295
1296 {
1297         struct drm_device *dev = &dev_priv->drm;
1298         struct vmw_framebuffer_surface *vfbs;
1299         enum SVGA3dSurfaceFormat format;
1300         int ret;
1301
1302         /* 3D is only supported on HWv8 and newer hosts */
1303         if (dev_priv->active_display_unit == vmw_du_legacy)
1304                 return -ENOSYS;
1305
1306         /*
1307          * Sanity checks.
1308          */
1309
1310         if (!drm_any_plane_has_format(&dev_priv->drm,
1311                                       mode_cmd->pixel_format,
1312                                       mode_cmd->modifier[0])) {
1313                 drm_dbg(&dev_priv->drm,
1314                         "unsupported pixel format %p4cc / modifier 0x%llx\n",
1315                         &mode_cmd->pixel_format, mode_cmd->modifier[0]);
1316                 return -EINVAL;
1317         }
1318
1319         /* Surface must be marked as a scanout. */
1320         if (unlikely(!surface->metadata.scanout))
1321                 return -EINVAL;
1322
1323         if (unlikely(surface->metadata.mip_levels[0] != 1 ||
1324                      surface->metadata.num_sizes != 1 ||
1325                      surface->metadata.base_size.width < mode_cmd->width ||
1326                      surface->metadata.base_size.height < mode_cmd->height ||
1327                      surface->metadata.base_size.depth != 1)) {
1328                 DRM_ERROR("Incompatible surface dimensions "
1329                           "for requested mode.\n");
1330                 return -EINVAL;
1331         }
1332
1333         switch (mode_cmd->pixel_format) {
1334         case DRM_FORMAT_ARGB8888:
1335                 format = SVGA3D_A8R8G8B8;
1336                 break;
1337         case DRM_FORMAT_XRGB8888:
1338                 format = SVGA3D_X8R8G8B8;
1339                 break;
1340         case DRM_FORMAT_RGB565:
1341                 format = SVGA3D_R5G6B5;
1342                 break;
1343         case DRM_FORMAT_XRGB1555:
1344                 format = SVGA3D_A1R5G5B5;
1345                 break;
1346         default:
1347                 DRM_ERROR("Invalid pixel format: %p4cc\n",
1348                           &mode_cmd->pixel_format);
1349                 return -EINVAL;
1350         }
1351
1352         /*
1353          * For DX, surface format validation is done when surface->scanout
1354          * is set.
1355          */
1356         if (!has_sm4_context(dev_priv) && format != surface->metadata.format) {
1357                 DRM_ERROR("Invalid surface format for requested mode.\n");
1358                 return -EINVAL;
1359         }
1360
1361         vfbs = kzalloc(sizeof(*vfbs), GFP_KERNEL);
1362         if (!vfbs) {
1363                 ret = -ENOMEM;
1364                 goto out_err1;
1365         }
1366
1367         drm_helper_mode_fill_fb_struct(dev, &vfbs->base.base, mode_cmd);
1368         vfbs->surface = vmw_surface_reference(surface);
1369         vfbs->base.user_handle = mode_cmd->handles[0];
1370         vfbs->is_bo_proxy = is_bo_proxy;
1371
1372         *out = &vfbs->base;
1373
1374         ret = drm_framebuffer_init(dev, &vfbs->base.base,
1375                                    &vmw_framebuffer_surface_funcs);
1376         if (ret)
1377                 goto out_err2;
1378
1379         return 0;
1380
1381 out_err2:
1382         vmw_surface_unreference(&surface);
1383         kfree(vfbs);
1384 out_err1:
1385         return ret;
1386 }
1387
1388 /*
1389  * Buffer-object framebuffer code
1390  */
1391
1392 static int vmw_framebuffer_bo_create_handle(struct drm_framebuffer *fb,
1393                                             struct drm_file *file_priv,
1394                                             unsigned int *handle)
1395 {
1396         struct vmw_framebuffer_bo *vfbd =
1397                         vmw_framebuffer_to_vfbd(fb);
1398
1399         return drm_gem_handle_create(file_priv, &vfbd->buffer->tbo.base, handle);
1400 }
1401
1402 static void vmw_framebuffer_bo_destroy(struct drm_framebuffer *framebuffer)
1403 {
1404         struct vmw_framebuffer_bo *vfbd =
1405                 vmw_framebuffer_to_vfbd(framebuffer);
1406
1407         drm_framebuffer_cleanup(framebuffer);
1408         vmw_bo_unreference(&vfbd->buffer);
1409
1410         kfree(vfbd);
1411 }
1412
1413 static const struct drm_framebuffer_funcs vmw_framebuffer_bo_funcs = {
1414         .create_handle = vmw_framebuffer_bo_create_handle,
1415         .destroy = vmw_framebuffer_bo_destroy,
1416         .dirty = drm_atomic_helper_dirtyfb,
1417 };
1418
1419 /**
1420  * vmw_create_bo_proxy - create a proxy surface for the buffer object
1421  *
1422  * @dev: DRM device
1423  * @mode_cmd: parameters for the new surface
1424  * @bo_mob: MOB backing the buffer object
1425  * @srf_out: newly created surface
1426  *
1427  * When the content FB is a buffer object, we create a surface as a proxy to the
1428  * same buffer.  This way we can do a surface copy rather than a surface DMA.
1429  * This is a more efficient approach
1430  *
1431  * RETURNS:
1432  * 0 on success, error code otherwise
1433  */
1434 static int vmw_create_bo_proxy(struct drm_device *dev,
1435                                const struct drm_mode_fb_cmd2 *mode_cmd,
1436                                struct vmw_bo *bo_mob,
1437                                struct vmw_surface **srf_out)
1438 {
1439         struct vmw_surface_metadata metadata = {0};
1440         uint32_t format;
1441         struct vmw_resource *res;
1442         unsigned int bytes_pp;
1443         int ret;
1444
1445         switch (mode_cmd->pixel_format) {
1446         case DRM_FORMAT_ARGB8888:
1447         case DRM_FORMAT_XRGB8888:
1448                 format = SVGA3D_X8R8G8B8;
1449                 bytes_pp = 4;
1450                 break;
1451
1452         case DRM_FORMAT_RGB565:
1453         case DRM_FORMAT_XRGB1555:
1454                 format = SVGA3D_R5G6B5;
1455                 bytes_pp = 2;
1456                 break;
1457
1458         case 8:
1459                 format = SVGA3D_P8;
1460                 bytes_pp = 1;
1461                 break;
1462
1463         default:
1464                 DRM_ERROR("Invalid framebuffer format %p4cc\n",
1465                           &mode_cmd->pixel_format);
1466                 return -EINVAL;
1467         }
1468
1469         metadata.format = format;
1470         metadata.mip_levels[0] = 1;
1471         metadata.num_sizes = 1;
1472         metadata.base_size.width = mode_cmd->pitches[0] / bytes_pp;
1473         metadata.base_size.height =  mode_cmd->height;
1474         metadata.base_size.depth = 1;
1475         metadata.scanout = true;
1476
1477         ret = vmw_gb_surface_define(vmw_priv(dev), &metadata, srf_out);
1478         if (ret) {
1479                 DRM_ERROR("Failed to allocate proxy content buffer\n");
1480                 return ret;
1481         }
1482
1483         res = &(*srf_out)->res;
1484
1485         /* Reserve and switch the backing mob. */
1486         mutex_lock(&res->dev_priv->cmdbuf_mutex);
1487         (void) vmw_resource_reserve(res, false, true);
1488         vmw_user_bo_unref(&res->guest_memory_bo);
1489         res->guest_memory_bo = vmw_user_bo_ref(bo_mob);
1490         res->guest_memory_offset = 0;
1491         vmw_resource_unreserve(res, false, false, false, NULL, 0);
1492         mutex_unlock(&res->dev_priv->cmdbuf_mutex);
1493
1494         return 0;
1495 }
1496
1497
1498
1499 static int vmw_kms_new_framebuffer_bo(struct vmw_private *dev_priv,
1500                                       struct vmw_bo *bo,
1501                                       struct vmw_framebuffer **out,
1502                                       const struct drm_mode_fb_cmd2
1503                                       *mode_cmd)
1504
1505 {
1506         struct drm_device *dev = &dev_priv->drm;
1507         struct vmw_framebuffer_bo *vfbd;
1508         unsigned int requested_size;
1509         int ret;
1510
1511         requested_size = mode_cmd->height * mode_cmd->pitches[0];
1512         if (unlikely(requested_size > bo->tbo.base.size)) {
1513                 DRM_ERROR("Screen buffer object size is too small "
1514                           "for requested mode.\n");
1515                 return -EINVAL;
1516         }
1517
1518         if (!drm_any_plane_has_format(&dev_priv->drm,
1519                                       mode_cmd->pixel_format,
1520                                       mode_cmd->modifier[0])) {
1521                 drm_dbg(&dev_priv->drm,
1522                         "unsupported pixel format %p4cc / modifier 0x%llx\n",
1523                         &mode_cmd->pixel_format, mode_cmd->modifier[0]);
1524                 return -EINVAL;
1525         }
1526
1527         vfbd = kzalloc(sizeof(*vfbd), GFP_KERNEL);
1528         if (!vfbd) {
1529                 ret = -ENOMEM;
1530                 goto out_err1;
1531         }
1532
1533         vfbd->base.base.obj[0] = &bo->tbo.base;
1534         drm_helper_mode_fill_fb_struct(dev, &vfbd->base.base, mode_cmd);
1535         vfbd->base.bo = true;
1536         vfbd->buffer = vmw_bo_reference(bo);
1537         vfbd->base.user_handle = mode_cmd->handles[0];
1538         *out = &vfbd->base;
1539
1540         ret = drm_framebuffer_init(dev, &vfbd->base.base,
1541                                    &vmw_framebuffer_bo_funcs);
1542         if (ret)
1543                 goto out_err2;
1544
1545         return 0;
1546
1547 out_err2:
1548         vmw_bo_unreference(&bo);
1549         kfree(vfbd);
1550 out_err1:
1551         return ret;
1552 }
1553
1554
1555 /**
1556  * vmw_kms_srf_ok - check if a surface can be created
1557  *
1558  * @dev_priv: Pointer to device private struct.
1559  * @width: requested width
1560  * @height: requested height
1561  *
1562  * Surfaces need to be less than texture size
1563  */
1564 static bool
1565 vmw_kms_srf_ok(struct vmw_private *dev_priv, uint32_t width, uint32_t height)
1566 {
1567         if (width  > dev_priv->texture_max_width ||
1568             height > dev_priv->texture_max_height)
1569                 return false;
1570
1571         return true;
1572 }
1573
1574 /**
1575  * vmw_kms_new_framebuffer - Create a new framebuffer.
1576  *
1577  * @dev_priv: Pointer to device private struct.
1578  * @bo: Pointer to buffer object to wrap the kms framebuffer around.
1579  * Either @bo or @surface must be NULL.
1580  * @surface: Pointer to a surface to wrap the kms framebuffer around.
1581  * Either @bo or @surface must be NULL.
1582  * @only_2d: No presents will occur to this buffer object based framebuffer.
1583  * This helps the code to do some important optimizations.
1584  * @mode_cmd: Frame-buffer metadata.
1585  */
1586 struct vmw_framebuffer *
1587 vmw_kms_new_framebuffer(struct vmw_private *dev_priv,
1588                         struct vmw_bo *bo,
1589                         struct vmw_surface *surface,
1590                         bool only_2d,
1591                         const struct drm_mode_fb_cmd2 *mode_cmd)
1592 {
1593         struct vmw_framebuffer *vfb = NULL;
1594         bool is_bo_proxy = false;
1595         int ret;
1596
1597         /*
1598          * We cannot use the SurfaceDMA command in an non-accelerated VM,
1599          * therefore, wrap the buffer object in a surface so we can use the
1600          * SurfaceCopy command.
1601          */
1602         if (vmw_kms_srf_ok(dev_priv, mode_cmd->width, mode_cmd->height)  &&
1603             bo && only_2d &&
1604             mode_cmd->width > 64 &&  /* Don't create a proxy for cursor */
1605             dev_priv->active_display_unit == vmw_du_screen_target) {
1606                 ret = vmw_create_bo_proxy(&dev_priv->drm, mode_cmd,
1607                                           bo, &surface);
1608                 if (ret)
1609                         return ERR_PTR(ret);
1610
1611                 is_bo_proxy = true;
1612         }
1613
1614         /* Create the new framebuffer depending one what we have */
1615         if (surface) {
1616                 ret = vmw_kms_new_framebuffer_surface(dev_priv, surface, &vfb,
1617                                                       mode_cmd,
1618                                                       is_bo_proxy);
1619                 /*
1620                  * vmw_create_bo_proxy() adds a reference that is no longer
1621                  * needed
1622                  */
1623                 if (is_bo_proxy)
1624                         vmw_surface_unreference(&surface);
1625         } else if (bo) {
1626                 ret = vmw_kms_new_framebuffer_bo(dev_priv, bo, &vfb,
1627                                                  mode_cmd);
1628         } else {
1629                 BUG();
1630         }
1631
1632         if (ret)
1633                 return ERR_PTR(ret);
1634
1635         return vfb;
1636 }
1637
1638 /*
1639  * Generic Kernel modesetting functions
1640  */
1641
1642 static struct drm_framebuffer *vmw_kms_fb_create(struct drm_device *dev,
1643                                                  struct drm_file *file_priv,
1644                                                  const struct drm_mode_fb_cmd2 *mode_cmd)
1645 {
1646         struct vmw_private *dev_priv = vmw_priv(dev);
1647         struct vmw_framebuffer *vfb = NULL;
1648         struct vmw_surface *surface = NULL;
1649         struct vmw_bo *bo = NULL;
1650         int ret;
1651
1652         /* returns either a bo or surface */
1653         ret = vmw_user_lookup_handle(dev_priv, file_priv,
1654                                      mode_cmd->handles[0],
1655                                      &surface, &bo);
1656         if (ret) {
1657                 DRM_ERROR("Invalid buffer object handle %u (0x%x).\n",
1658                           mode_cmd->handles[0], mode_cmd->handles[0]);
1659                 goto err_out;
1660         }
1661
1662
1663         if (!bo &&
1664             !vmw_kms_srf_ok(dev_priv, mode_cmd->width, mode_cmd->height)) {
1665                 DRM_ERROR("Surface size cannot exceed %dx%d\n",
1666                         dev_priv->texture_max_width,
1667                         dev_priv->texture_max_height);
1668                 goto err_out;
1669         }
1670
1671
1672         vfb = vmw_kms_new_framebuffer(dev_priv, bo, surface,
1673                                       !(dev_priv->capabilities & SVGA_CAP_3D),
1674                                       mode_cmd);
1675         if (IS_ERR(vfb)) {
1676                 ret = PTR_ERR(vfb);
1677                 goto err_out;
1678         }
1679
1680 err_out:
1681         /* vmw_user_lookup_handle takes one ref so does new_fb */
1682         if (bo)
1683                 vmw_user_bo_unref(&bo);
1684         if (surface)
1685                 vmw_surface_unreference(&surface);
1686
1687         if (ret) {
1688                 DRM_ERROR("failed to create vmw_framebuffer: %i\n", ret);
1689                 return ERR_PTR(ret);
1690         }
1691
1692         return &vfb->base;
1693 }
1694
1695 /**
1696  * vmw_kms_check_display_memory - Validates display memory required for a
1697  * topology
1698  * @dev: DRM device
1699  * @num_rects: number of drm_rect in rects
1700  * @rects: array of drm_rect representing the topology to validate indexed by
1701  * crtc index.
1702  *
1703  * Returns:
1704  * 0 on success otherwise negative error code
1705  */
1706 static int vmw_kms_check_display_memory(struct drm_device *dev,
1707                                         uint32_t num_rects,
1708                                         struct drm_rect *rects)
1709 {
1710         struct vmw_private *dev_priv = vmw_priv(dev);
1711         struct drm_rect bounding_box = {0};
1712         u64 total_pixels = 0, pixel_mem, bb_mem;
1713         int i;
1714
1715         for (i = 0; i < num_rects; i++) {
1716                 /*
1717                  * For STDU only individual screen (screen target) is limited by
1718                  * SCREENTARGET_MAX_WIDTH/HEIGHT registers.
1719                  */
1720                 if (dev_priv->active_display_unit == vmw_du_screen_target &&
1721                     (drm_rect_width(&rects[i]) > dev_priv->stdu_max_width ||
1722                      drm_rect_height(&rects[i]) > dev_priv->stdu_max_height)) {
1723                         VMW_DEBUG_KMS("Screen size not supported.\n");
1724                         return -EINVAL;
1725                 }
1726
1727                 /* Bounding box upper left is at (0,0). */
1728                 if (rects[i].x2 > bounding_box.x2)
1729                         bounding_box.x2 = rects[i].x2;
1730
1731                 if (rects[i].y2 > bounding_box.y2)
1732                         bounding_box.y2 = rects[i].y2;
1733
1734                 total_pixels += (u64) drm_rect_width(&rects[i]) *
1735                         (u64) drm_rect_height(&rects[i]);
1736         }
1737
1738         /* Virtual svga device primary limits are always in 32-bpp. */
1739         pixel_mem = total_pixels * 4;
1740
1741         /*
1742          * For HV10 and below prim_bb_mem is vram size. When
1743          * SVGA_REG_MAX_PRIMARY_BOUNDING_BOX_MEM is not present vram size is
1744          * limit on primary bounding box
1745          */
1746         if (pixel_mem > dev_priv->max_primary_mem) {
1747                 VMW_DEBUG_KMS("Combined output size too large.\n");
1748                 return -EINVAL;
1749         }
1750
1751         /* SVGA_CAP_NO_BB_RESTRICTION is available for STDU only. */
1752         if (dev_priv->active_display_unit != vmw_du_screen_target ||
1753             !(dev_priv->capabilities & SVGA_CAP_NO_BB_RESTRICTION)) {
1754                 bb_mem = (u64) bounding_box.x2 * bounding_box.y2 * 4;
1755
1756                 if (bb_mem > dev_priv->max_primary_mem) {
1757                         VMW_DEBUG_KMS("Topology is beyond supported limits.\n");
1758                         return -EINVAL;
1759                 }
1760         }
1761
1762         return 0;
1763 }
1764
1765 /**
1766  * vmw_crtc_state_and_lock - Return new or current crtc state with locked
1767  * crtc mutex
1768  * @state: The atomic state pointer containing the new atomic state
1769  * @crtc: The crtc
1770  *
1771  * This function returns the new crtc state if it's part of the state update.
1772  * Otherwise returns the current crtc state. It also makes sure that the
1773  * crtc mutex is locked.
1774  *
1775  * Returns: A valid crtc state pointer or NULL. It may also return a
1776  * pointer error, in particular -EDEADLK if locking needs to be rerun.
1777  */
1778 static struct drm_crtc_state *
1779 vmw_crtc_state_and_lock(struct drm_atomic_state *state, struct drm_crtc *crtc)
1780 {
1781         struct drm_crtc_state *crtc_state;
1782
1783         crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
1784         if (crtc_state) {
1785                 lockdep_assert_held(&crtc->mutex.mutex.base);
1786         } else {
1787                 int ret = drm_modeset_lock(&crtc->mutex, state->acquire_ctx);
1788
1789                 if (ret != 0 && ret != -EALREADY)
1790                         return ERR_PTR(ret);
1791
1792                 crtc_state = crtc->state;
1793         }
1794
1795         return crtc_state;
1796 }
1797
1798 /**
1799  * vmw_kms_check_implicit - Verify that all implicit display units scan out
1800  * from the same fb after the new state is committed.
1801  * @dev: The drm_device.
1802  * @state: The new state to be checked.
1803  *
1804  * Returns:
1805  *   Zero on success,
1806  *   -EINVAL on invalid state,
1807  *   -EDEADLK if modeset locking needs to be rerun.
1808  */
1809 static int vmw_kms_check_implicit(struct drm_device *dev,
1810                                   struct drm_atomic_state *state)
1811 {
1812         struct drm_framebuffer *implicit_fb = NULL;
1813         struct drm_crtc *crtc;
1814         struct drm_crtc_state *crtc_state;
1815         struct drm_plane_state *plane_state;
1816
1817         drm_for_each_crtc(crtc, dev) {
1818                 struct vmw_display_unit *du = vmw_crtc_to_du(crtc);
1819
1820                 if (!du->is_implicit)
1821                         continue;
1822
1823                 crtc_state = vmw_crtc_state_and_lock(state, crtc);
1824                 if (IS_ERR(crtc_state))
1825                         return PTR_ERR(crtc_state);
1826
1827                 if (!crtc_state || !crtc_state->enable)
1828                         continue;
1829
1830                 /*
1831                  * Can't move primary planes across crtcs, so this is OK.
1832                  * It also means we don't need to take the plane mutex.
1833                  */
1834                 plane_state = du->primary.state;
1835                 if (plane_state->crtc != crtc)
1836                         continue;
1837
1838                 if (!implicit_fb)
1839                         implicit_fb = plane_state->fb;
1840                 else if (implicit_fb != plane_state->fb)
1841                         return -EINVAL;
1842         }
1843
1844         return 0;
1845 }
1846
1847 /**
1848  * vmw_kms_check_topology - Validates topology in drm_atomic_state
1849  * @dev: DRM device
1850  * @state: the driver state object
1851  *
1852  * Returns:
1853  * 0 on success otherwise negative error code
1854  */
1855 static int vmw_kms_check_topology(struct drm_device *dev,
1856                                   struct drm_atomic_state *state)
1857 {
1858         struct drm_crtc_state *old_crtc_state, *new_crtc_state;
1859         struct drm_rect *rects;
1860         struct drm_crtc *crtc;
1861         uint32_t i;
1862         int ret = 0;
1863
1864         rects = kcalloc(dev->mode_config.num_crtc, sizeof(struct drm_rect),
1865                         GFP_KERNEL);
1866         if (!rects)
1867                 return -ENOMEM;
1868
1869         drm_for_each_crtc(crtc, dev) {
1870                 struct vmw_display_unit *du = vmw_crtc_to_du(crtc);
1871                 struct drm_crtc_state *crtc_state;
1872
1873                 i = drm_crtc_index(crtc);
1874
1875                 crtc_state = vmw_crtc_state_and_lock(state, crtc);
1876                 if (IS_ERR(crtc_state)) {
1877                         ret = PTR_ERR(crtc_state);
1878                         goto clean;
1879                 }
1880
1881                 if (!crtc_state)
1882                         continue;
1883
1884                 if (crtc_state->enable) {
1885                         rects[i].x1 = du->gui_x;
1886                         rects[i].y1 = du->gui_y;
1887                         rects[i].x2 = du->gui_x + crtc_state->mode.hdisplay;
1888                         rects[i].y2 = du->gui_y + crtc_state->mode.vdisplay;
1889                 } else {
1890                         rects[i].x1 = 0;
1891                         rects[i].y1 = 0;
1892                         rects[i].x2 = 0;
1893                         rects[i].y2 = 0;
1894                 }
1895         }
1896
1897         /* Determine change to topology due to new atomic state */
1898         for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state,
1899                                       new_crtc_state, i) {
1900                 struct vmw_display_unit *du = vmw_crtc_to_du(crtc);
1901                 struct drm_connector *connector;
1902                 struct drm_connector_state *conn_state;
1903                 struct vmw_connector_state *vmw_conn_state;
1904
1905                 if (!du->pref_active && new_crtc_state->enable) {
1906                         VMW_DEBUG_KMS("Enabling a disabled display unit\n");
1907                         ret = -EINVAL;
1908                         goto clean;
1909                 }
1910
1911                 /*
1912                  * For vmwgfx each crtc has only one connector attached and it
1913                  * is not changed so don't really need to check the
1914                  * crtc->connector_mask and iterate over it.
1915                  */
1916                 connector = &du->connector;
1917                 conn_state = drm_atomic_get_connector_state(state, connector);
1918                 if (IS_ERR(conn_state)) {
1919                         ret = PTR_ERR(conn_state);
1920                         goto clean;
1921                 }
1922
1923                 vmw_conn_state = vmw_connector_state_to_vcs(conn_state);
1924                 vmw_conn_state->gui_x = du->gui_x;
1925                 vmw_conn_state->gui_y = du->gui_y;
1926         }
1927
1928         ret = vmw_kms_check_display_memory(dev, dev->mode_config.num_crtc,
1929                                            rects);
1930
1931 clean:
1932         kfree(rects);
1933         return ret;
1934 }
1935
1936 /**
1937  * vmw_kms_atomic_check_modeset- validate state object for modeset changes
1938  *
1939  * @dev: DRM device
1940  * @state: the driver state object
1941  *
1942  * This is a simple wrapper around drm_atomic_helper_check_modeset() for
1943  * us to assign a value to mode->crtc_clock so that
1944  * drm_calc_timestamping_constants() won't throw an error message
1945  *
1946  * Returns:
1947  * Zero for success or -errno
1948  */
1949 static int
1950 vmw_kms_atomic_check_modeset(struct drm_device *dev,
1951                              struct drm_atomic_state *state)
1952 {
1953         struct drm_crtc *crtc;
1954         struct drm_crtc_state *crtc_state;
1955         bool need_modeset = false;
1956         int i, ret;
1957
1958         ret = drm_atomic_helper_check(dev, state);
1959         if (ret)
1960                 return ret;
1961
1962         ret = vmw_kms_check_implicit(dev, state);
1963         if (ret) {
1964                 VMW_DEBUG_KMS("Invalid implicit state\n");
1965                 return ret;
1966         }
1967
1968         for_each_new_crtc_in_state(state, crtc, crtc_state, i) {
1969                 if (drm_atomic_crtc_needs_modeset(crtc_state))
1970                         need_modeset = true;
1971         }
1972
1973         if (need_modeset)
1974                 return vmw_kms_check_topology(dev, state);
1975
1976         return ret;
1977 }
1978
1979 static const struct drm_mode_config_funcs vmw_kms_funcs = {
1980         .fb_create = vmw_kms_fb_create,
1981         .atomic_check = vmw_kms_atomic_check_modeset,
1982         .atomic_commit = drm_atomic_helper_commit,
1983 };
1984
1985 static int vmw_kms_generic_present(struct vmw_private *dev_priv,
1986                                    struct drm_file *file_priv,
1987                                    struct vmw_framebuffer *vfb,
1988                                    struct vmw_surface *surface,
1989                                    uint32_t sid,
1990                                    int32_t destX, int32_t destY,
1991                                    struct drm_vmw_rect *clips,
1992                                    uint32_t num_clips)
1993 {
1994         return vmw_kms_sou_do_surface_dirty(dev_priv, vfb, NULL, clips,
1995                                             &surface->res, destX, destY,
1996                                             num_clips, 1, NULL, NULL);
1997 }
1998
1999
2000 int vmw_kms_present(struct vmw_private *dev_priv,
2001                     struct drm_file *file_priv,
2002                     struct vmw_framebuffer *vfb,
2003                     struct vmw_surface *surface,
2004                     uint32_t sid,
2005                     int32_t destX, int32_t destY,
2006                     struct drm_vmw_rect *clips,
2007                     uint32_t num_clips)
2008 {
2009         int ret;
2010
2011         switch (dev_priv->active_display_unit) {
2012         case vmw_du_screen_target:
2013                 ret = vmw_kms_stdu_surface_dirty(dev_priv, vfb, NULL, clips,
2014                                                  &surface->res, destX, destY,
2015                                                  num_clips, 1, NULL, NULL);
2016                 break;
2017         case vmw_du_screen_object:
2018                 ret = vmw_kms_generic_present(dev_priv, file_priv, vfb, surface,
2019                                               sid, destX, destY, clips,
2020                                               num_clips);
2021                 break;
2022         default:
2023                 WARN_ONCE(true,
2024                           "Present called with invalid display system.\n");
2025                 ret = -ENOSYS;
2026                 break;
2027         }
2028         if (ret)
2029                 return ret;
2030
2031         vmw_cmd_flush(dev_priv, false);
2032
2033         return 0;
2034 }
2035
2036 static void
2037 vmw_kms_create_hotplug_mode_update_property(struct vmw_private *dev_priv)
2038 {
2039         if (dev_priv->hotplug_mode_update_property)
2040                 return;
2041
2042         dev_priv->hotplug_mode_update_property =
2043                 drm_property_create_range(&dev_priv->drm,
2044                                           DRM_MODE_PROP_IMMUTABLE,
2045                                           "hotplug_mode_update", 0, 1);
2046 }
2047
2048 int vmw_kms_init(struct vmw_private *dev_priv)
2049 {
2050         struct drm_device *dev = &dev_priv->drm;
2051         int ret;
2052         static const char *display_unit_names[] = {
2053                 "Invalid",
2054                 "Legacy",
2055                 "Screen Object",
2056                 "Screen Target",
2057                 "Invalid (max)"
2058         };
2059
2060         drm_mode_config_init(dev);
2061         dev->mode_config.funcs = &vmw_kms_funcs;
2062         dev->mode_config.min_width = 1;
2063         dev->mode_config.min_height = 1;
2064         dev->mode_config.max_width = dev_priv->texture_max_width;
2065         dev->mode_config.max_height = dev_priv->texture_max_height;
2066         dev->mode_config.preferred_depth = dev_priv->assume_16bpp ? 16 : 32;
2067
2068         drm_mode_create_suggested_offset_properties(dev);
2069         vmw_kms_create_hotplug_mode_update_property(dev_priv);
2070
2071         ret = vmw_kms_stdu_init_display(dev_priv);
2072         if (ret) {
2073                 ret = vmw_kms_sou_init_display(dev_priv);
2074                 if (ret) /* Fallback */
2075                         ret = vmw_kms_ldu_init_display(dev_priv);
2076         }
2077         BUILD_BUG_ON(ARRAY_SIZE(display_unit_names) != (vmw_du_max + 1));
2078         drm_info(&dev_priv->drm, "%s display unit initialized\n",
2079                  display_unit_names[dev_priv->active_display_unit]);
2080
2081         return ret;
2082 }
2083
2084 int vmw_kms_close(struct vmw_private *dev_priv)
2085 {
2086         int ret = 0;
2087
2088         /*
2089          * Docs says we should take the lock before calling this function
2090          * but since it destroys encoders and our destructor calls
2091          * drm_encoder_cleanup which takes the lock we deadlock.
2092          */
2093         drm_mode_config_cleanup(&dev_priv->drm);
2094         if (dev_priv->active_display_unit == vmw_du_legacy)
2095                 ret = vmw_kms_ldu_close_display(dev_priv);
2096
2097         return ret;
2098 }
2099
2100 int vmw_kms_cursor_bypass_ioctl(struct drm_device *dev, void *data,
2101                                 struct drm_file *file_priv)
2102 {
2103         struct drm_vmw_cursor_bypass_arg *arg = data;
2104         struct vmw_display_unit *du;
2105         struct drm_crtc *crtc;
2106         int ret = 0;
2107
2108         mutex_lock(&dev->mode_config.mutex);
2109         if (arg->flags & DRM_VMW_CURSOR_BYPASS_ALL) {
2110
2111                 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
2112                         du = vmw_crtc_to_du(crtc);
2113                         du->hotspot_x = arg->xhot;
2114                         du->hotspot_y = arg->yhot;
2115                 }
2116
2117                 mutex_unlock(&dev->mode_config.mutex);
2118                 return 0;
2119         }
2120
2121         crtc = drm_crtc_find(dev, file_priv, arg->crtc_id);
2122         if (!crtc) {
2123                 ret = -ENOENT;
2124                 goto out;
2125         }
2126
2127         du = vmw_crtc_to_du(crtc);
2128
2129         du->hotspot_x = arg->xhot;
2130         du->hotspot_y = arg->yhot;
2131
2132 out:
2133         mutex_unlock(&dev->mode_config.mutex);
2134
2135         return ret;
2136 }
2137
2138 int vmw_kms_write_svga(struct vmw_private *vmw_priv,
2139                         unsigned width, unsigned height, unsigned pitch,
2140                         unsigned bpp, unsigned depth)
2141 {
2142         if (vmw_priv->capabilities & SVGA_CAP_PITCHLOCK)
2143                 vmw_write(vmw_priv, SVGA_REG_PITCHLOCK, pitch);
2144         else if (vmw_fifo_have_pitchlock(vmw_priv))
2145                 vmw_fifo_mem_write(vmw_priv, SVGA_FIFO_PITCHLOCK, pitch);
2146         vmw_write(vmw_priv, SVGA_REG_WIDTH, width);
2147         vmw_write(vmw_priv, SVGA_REG_HEIGHT, height);
2148         if ((vmw_priv->capabilities & SVGA_CAP_8BIT_EMULATION) != 0)
2149                 vmw_write(vmw_priv, SVGA_REG_BITS_PER_PIXEL, bpp);
2150
2151         if (vmw_read(vmw_priv, SVGA_REG_DEPTH) != depth) {
2152                 DRM_ERROR("Invalid depth %u for %u bpp, host expects %u\n",
2153                           depth, bpp, vmw_read(vmw_priv, SVGA_REG_DEPTH));
2154                 return -EINVAL;
2155         }
2156
2157         return 0;
2158 }
2159
2160 bool vmw_kms_validate_mode_vram(struct vmw_private *dev_priv,
2161                                 uint32_t pitch,
2162                                 uint32_t height)
2163 {
2164         return ((u64) pitch * (u64) height) < (u64)
2165                 ((dev_priv->active_display_unit == vmw_du_screen_target) ?
2166                  dev_priv->max_primary_mem : dev_priv->vram_size);
2167 }
2168
2169 /**
2170  * vmw_du_update_layout - Update the display unit with topology from resolution
2171  * plugin and generate DRM uevent
2172  * @dev_priv: device private
2173  * @num_rects: number of drm_rect in rects
2174  * @rects: toplogy to update
2175  */
2176 static int vmw_du_update_layout(struct vmw_private *dev_priv,
2177                                 unsigned int num_rects, struct drm_rect *rects)
2178 {
2179         struct drm_device *dev = &dev_priv->drm;
2180         struct vmw_display_unit *du;
2181         struct drm_connector *con;
2182         struct drm_connector_list_iter conn_iter;
2183         struct drm_modeset_acquire_ctx ctx;
2184         struct drm_crtc *crtc;
2185         int ret;
2186
2187         /* Currently gui_x/y is protected with the crtc mutex */
2188         mutex_lock(&dev->mode_config.mutex);
2189         drm_modeset_acquire_init(&ctx, 0);
2190 retry:
2191         drm_for_each_crtc(crtc, dev) {
2192                 ret = drm_modeset_lock(&crtc->mutex, &ctx);
2193                 if (ret < 0) {
2194                         if (ret == -EDEADLK) {
2195                                 drm_modeset_backoff(&ctx);
2196                                 goto retry;
2197                 }
2198                         goto out_fini;
2199                 }
2200         }
2201
2202         drm_connector_list_iter_begin(dev, &conn_iter);
2203         drm_for_each_connector_iter(con, &conn_iter) {
2204                 du = vmw_connector_to_du(con);
2205                 if (num_rects > du->unit) {
2206                         du->pref_width = drm_rect_width(&rects[du->unit]);
2207                         du->pref_height = drm_rect_height(&rects[du->unit]);
2208                         du->pref_active = true;
2209                         du->gui_x = rects[du->unit].x1;
2210                         du->gui_y = rects[du->unit].y1;
2211                 } else {
2212                         du->pref_width  = VMWGFX_MIN_INITIAL_WIDTH;
2213                         du->pref_height = VMWGFX_MIN_INITIAL_HEIGHT;
2214                         du->pref_active = false;
2215                         du->gui_x = 0;
2216                         du->gui_y = 0;
2217                 }
2218         }
2219         drm_connector_list_iter_end(&conn_iter);
2220
2221         list_for_each_entry(con, &dev->mode_config.connector_list, head) {
2222                 du = vmw_connector_to_du(con);
2223                 if (num_rects > du->unit) {
2224                         drm_object_property_set_value
2225                           (&con->base, dev->mode_config.suggested_x_property,
2226                            du->gui_x);
2227                         drm_object_property_set_value
2228                           (&con->base, dev->mode_config.suggested_y_property,
2229                            du->gui_y);
2230                 } else {
2231                         drm_object_property_set_value
2232                           (&con->base, dev->mode_config.suggested_x_property,
2233                            0);
2234                         drm_object_property_set_value
2235                           (&con->base, dev->mode_config.suggested_y_property,
2236                            0);
2237                 }
2238                 con->status = vmw_du_connector_detect(con, true);
2239         }
2240 out_fini:
2241         drm_modeset_drop_locks(&ctx);
2242         drm_modeset_acquire_fini(&ctx);
2243         mutex_unlock(&dev->mode_config.mutex);
2244
2245         drm_sysfs_hotplug_event(dev);
2246
2247         return 0;
2248 }
2249
2250 int vmw_du_crtc_gamma_set(struct drm_crtc *crtc,
2251                           u16 *r, u16 *g, u16 *b,
2252                           uint32_t size,
2253                           struct drm_modeset_acquire_ctx *ctx)
2254 {
2255         struct vmw_private *dev_priv = vmw_priv(crtc->dev);
2256         int i;
2257
2258         for (i = 0; i < size; i++) {
2259                 DRM_DEBUG("%d r/g/b = 0x%04x / 0x%04x / 0x%04x\n", i,
2260                           r[i], g[i], b[i]);
2261                 vmw_write(dev_priv, SVGA_PALETTE_BASE + i * 3 + 0, r[i] >> 8);
2262                 vmw_write(dev_priv, SVGA_PALETTE_BASE + i * 3 + 1, g[i] >> 8);
2263                 vmw_write(dev_priv, SVGA_PALETTE_BASE + i * 3 + 2, b[i] >> 8);
2264         }
2265
2266         return 0;
2267 }
2268
2269 int vmw_du_connector_dpms(struct drm_connector *connector, int mode)
2270 {
2271         return 0;
2272 }
2273
2274 enum drm_connector_status
2275 vmw_du_connector_detect(struct drm_connector *connector, bool force)
2276 {
2277         uint32_t num_displays;
2278         struct drm_device *dev = connector->dev;
2279         struct vmw_private *dev_priv = vmw_priv(dev);
2280         struct vmw_display_unit *du = vmw_connector_to_du(connector);
2281
2282         num_displays = vmw_read(dev_priv, SVGA_REG_NUM_DISPLAYS);
2283
2284         return ((vmw_connector_to_du(connector)->unit < num_displays &&
2285                  du->pref_active) ?
2286                 connector_status_connected : connector_status_disconnected);
2287 }
2288
2289 /**
2290  * vmw_guess_mode_timing - Provide fake timings for a
2291  * 60Hz vrefresh mode.
2292  *
2293  * @mode: Pointer to a struct drm_display_mode with hdisplay and vdisplay
2294  * members filled in.
2295  */
2296 void vmw_guess_mode_timing(struct drm_display_mode *mode)
2297 {
2298         mode->hsync_start = mode->hdisplay + 50;
2299         mode->hsync_end = mode->hsync_start + 50;
2300         mode->htotal = mode->hsync_end + 50;
2301
2302         mode->vsync_start = mode->vdisplay + 50;
2303         mode->vsync_end = mode->vsync_start + 50;
2304         mode->vtotal = mode->vsync_end + 50;
2305
2306         mode->clock = (u32)mode->htotal * (u32)mode->vtotal / 100 * 6;
2307 }
2308
2309
2310 /**
2311  * vmw_kms_update_layout_ioctl - Handler for DRM_VMW_UPDATE_LAYOUT ioctl
2312  * @dev: drm device for the ioctl
2313  * @data: data pointer for the ioctl
2314  * @file_priv: drm file for the ioctl call
2315  *
2316  * Update preferred topology of display unit as per ioctl request. The topology
2317  * is expressed as array of drm_vmw_rect.
2318  * e.g.
2319  * [0 0 640 480] [640 0 800 600] [0 480 640 480]
2320  *
2321  * NOTE:
2322  * The x and y offset (upper left) in drm_vmw_rect cannot be less than 0. Beside
2323  * device limit on topology, x + w and y + h (lower right) cannot be greater
2324  * than INT_MAX. So topology beyond these limits will return with error.
2325  *
2326  * Returns:
2327  * Zero on success, negative errno on failure.
2328  */
2329 int vmw_kms_update_layout_ioctl(struct drm_device *dev, void *data,
2330                                 struct drm_file *file_priv)
2331 {
2332         struct vmw_private *dev_priv = vmw_priv(dev);
2333         struct drm_mode_config *mode_config = &dev->mode_config;
2334         struct drm_vmw_update_layout_arg *arg =
2335                 (struct drm_vmw_update_layout_arg *)data;
2336         void __user *user_rects;
2337         struct drm_vmw_rect *rects;
2338         struct drm_rect *drm_rects;
2339         unsigned rects_size;
2340         int ret, i;
2341
2342         if (!arg->num_outputs) {
2343                 struct drm_rect def_rect = {0, 0,
2344                                             VMWGFX_MIN_INITIAL_WIDTH,
2345                                             VMWGFX_MIN_INITIAL_HEIGHT};
2346                 vmw_du_update_layout(dev_priv, 1, &def_rect);
2347                 return 0;
2348         }
2349
2350         rects_size = arg->num_outputs * sizeof(struct drm_vmw_rect);
2351         rects = kcalloc(arg->num_outputs, sizeof(struct drm_vmw_rect),
2352                         GFP_KERNEL);
2353         if (unlikely(!rects))
2354                 return -ENOMEM;
2355
2356         user_rects = (void __user *)(unsigned long)arg->rects;
2357         ret = copy_from_user(rects, user_rects, rects_size);
2358         if (unlikely(ret != 0)) {
2359                 DRM_ERROR("Failed to get rects.\n");
2360                 ret = -EFAULT;
2361                 goto out_free;
2362         }
2363
2364         drm_rects = (struct drm_rect *)rects;
2365
2366         VMW_DEBUG_KMS("Layout count = %u\n", arg->num_outputs);
2367         for (i = 0; i < arg->num_outputs; i++) {
2368                 struct drm_vmw_rect curr_rect;
2369
2370                 /* Verify user-space for overflow as kernel use drm_rect */
2371                 if ((rects[i].x + rects[i].w > INT_MAX) ||
2372                     (rects[i].y + rects[i].h > INT_MAX)) {
2373                         ret = -ERANGE;
2374                         goto out_free;
2375                 }
2376
2377                 curr_rect = rects[i];
2378                 drm_rects[i].x1 = curr_rect.x;
2379                 drm_rects[i].y1 = curr_rect.y;
2380                 drm_rects[i].x2 = curr_rect.x + curr_rect.w;
2381                 drm_rects[i].y2 = curr_rect.y + curr_rect.h;
2382
2383                 VMW_DEBUG_KMS("  x1 = %d y1 = %d x2 = %d y2 = %d\n",
2384                               drm_rects[i].x1, drm_rects[i].y1,
2385                               drm_rects[i].x2, drm_rects[i].y2);
2386
2387                 /*
2388                  * Currently this check is limiting the topology within
2389                  * mode_config->max (which actually is max texture size
2390                  * supported by virtual device). This limit is here to address
2391                  * window managers that create a big framebuffer for whole
2392                  * topology.
2393                  */
2394                 if (drm_rects[i].x1 < 0 ||  drm_rects[i].y1 < 0 ||
2395                     drm_rects[i].x2 > mode_config->max_width ||
2396                     drm_rects[i].y2 > mode_config->max_height) {
2397                         VMW_DEBUG_KMS("Invalid layout %d %d %d %d\n",
2398                                       drm_rects[i].x1, drm_rects[i].y1,
2399                                       drm_rects[i].x2, drm_rects[i].y2);
2400                         ret = -EINVAL;
2401                         goto out_free;
2402                 }
2403         }
2404
2405         ret = vmw_kms_check_display_memory(dev, arg->num_outputs, drm_rects);
2406
2407         if (ret == 0)
2408                 vmw_du_update_layout(dev_priv, arg->num_outputs, drm_rects);
2409
2410 out_free:
2411         kfree(rects);
2412         return ret;
2413 }
2414
2415 /**
2416  * vmw_kms_helper_dirty - Helper to build commands and perform actions based
2417  * on a set of cliprects and a set of display units.
2418  *
2419  * @dev_priv: Pointer to a device private structure.
2420  * @framebuffer: Pointer to the framebuffer on which to perform the actions.
2421  * @clips: A set of struct drm_clip_rect. Either this os @vclips must be NULL.
2422  * Cliprects are given in framebuffer coordinates.
2423  * @vclips: A set of struct drm_vmw_rect cliprects. Either this or @clips must
2424  * be NULL. Cliprects are given in source coordinates.
2425  * @dest_x: X coordinate offset for the crtc / destination clip rects.
2426  * @dest_y: Y coordinate offset for the crtc / destination clip rects.
2427  * @num_clips: Number of cliprects in the @clips or @vclips array.
2428  * @increment: Integer with which to increment the clip counter when looping.
2429  * Used to skip a predetermined number of clip rects.
2430  * @dirty: Closure structure. See the description of struct vmw_kms_dirty.
2431  */
2432 int vmw_kms_helper_dirty(struct vmw_private *dev_priv,
2433                          struct vmw_framebuffer *framebuffer,
2434                          const struct drm_clip_rect *clips,
2435                          const struct drm_vmw_rect *vclips,
2436                          s32 dest_x, s32 dest_y,
2437                          int num_clips,
2438                          int increment,
2439                          struct vmw_kms_dirty *dirty)
2440 {
2441         struct vmw_display_unit *units[VMWGFX_NUM_DISPLAY_UNITS];
2442         struct drm_crtc *crtc;
2443         u32 num_units = 0;
2444         u32 i, k;
2445
2446         dirty->dev_priv = dev_priv;
2447
2448         /* If crtc is passed, no need to iterate over other display units */
2449         if (dirty->crtc) {
2450                 units[num_units++] = vmw_crtc_to_du(dirty->crtc);
2451         } else {
2452                 list_for_each_entry(crtc, &dev_priv->drm.mode_config.crtc_list,
2453                                     head) {
2454                         struct drm_plane *plane = crtc->primary;
2455
2456                         if (plane->state->fb == &framebuffer->base)
2457                                 units[num_units++] = vmw_crtc_to_du(crtc);
2458                 }
2459         }
2460
2461         for (k = 0; k < num_units; k++) {
2462                 struct vmw_display_unit *unit = units[k];
2463                 s32 crtc_x = unit->crtc.x;
2464                 s32 crtc_y = unit->crtc.y;
2465                 s32 crtc_width = unit->crtc.mode.hdisplay;
2466                 s32 crtc_height = unit->crtc.mode.vdisplay;
2467                 const struct drm_clip_rect *clips_ptr = clips;
2468                 const struct drm_vmw_rect *vclips_ptr = vclips;
2469
2470                 dirty->unit = unit;
2471                 if (dirty->fifo_reserve_size > 0) {
2472                         dirty->cmd = VMW_CMD_RESERVE(dev_priv,
2473                                                       dirty->fifo_reserve_size);
2474                         if (!dirty->cmd)
2475                                 return -ENOMEM;
2476
2477                         memset(dirty->cmd, 0, dirty->fifo_reserve_size);
2478                 }
2479                 dirty->num_hits = 0;
2480                 for (i = 0; i < num_clips; i++, clips_ptr += increment,
2481                        vclips_ptr += increment) {
2482                         s32 clip_left;
2483                         s32 clip_top;
2484
2485                         /*
2486                          * Select clip array type. Note that integer type
2487                          * in @clips is unsigned short, whereas in @vclips
2488                          * it's 32-bit.
2489                          */
2490                         if (clips) {
2491                                 dirty->fb_x = (s32) clips_ptr->x1;
2492                                 dirty->fb_y = (s32) clips_ptr->y1;
2493                                 dirty->unit_x2 = (s32) clips_ptr->x2 + dest_x -
2494                                         crtc_x;
2495                                 dirty->unit_y2 = (s32) clips_ptr->y2 + dest_y -
2496                                         crtc_y;
2497                         } else {
2498                                 dirty->fb_x = vclips_ptr->x;
2499                                 dirty->fb_y = vclips_ptr->y;
2500                                 dirty->unit_x2 = dirty->fb_x + vclips_ptr->w +
2501                                         dest_x - crtc_x;
2502                                 dirty->unit_y2 = dirty->fb_y + vclips_ptr->h +
2503                                         dest_y - crtc_y;
2504                         }
2505
2506                         dirty->unit_x1 = dirty->fb_x + dest_x - crtc_x;
2507                         dirty->unit_y1 = dirty->fb_y + dest_y - crtc_y;
2508
2509                         /* Skip this clip if it's outside the crtc region */
2510                         if (dirty->unit_x1 >= crtc_width ||
2511                             dirty->unit_y1 >= crtc_height ||
2512                             dirty->unit_x2 <= 0 || dirty->unit_y2 <= 0)
2513                                 continue;
2514
2515                         /* Clip right and bottom to crtc limits */
2516                         dirty->unit_x2 = min_t(s32, dirty->unit_x2,
2517                                                crtc_width);
2518                         dirty->unit_y2 = min_t(s32, dirty->unit_y2,
2519                                                crtc_height);
2520
2521                         /* Clip left and top to crtc limits */
2522                         clip_left = min_t(s32, dirty->unit_x1, 0);
2523                         clip_top = min_t(s32, dirty->unit_y1, 0);
2524                         dirty->unit_x1 -= clip_left;
2525                         dirty->unit_y1 -= clip_top;
2526                         dirty->fb_x -= clip_left;
2527                         dirty->fb_y -= clip_top;
2528
2529                         dirty->clip(dirty);
2530                 }
2531
2532                 dirty->fifo_commit(dirty);
2533         }
2534
2535         return 0;
2536 }
2537
2538 /**
2539  * vmw_kms_helper_validation_finish - Helper for post KMS command submission
2540  * cleanup and fencing
2541  * @dev_priv: Pointer to the device-private struct
2542  * @file_priv: Pointer identifying the client when user-space fencing is used
2543  * @ctx: Pointer to the validation context
2544  * @out_fence: If non-NULL, returned refcounted fence-pointer
2545  * @user_fence_rep: If non-NULL, pointer to user-space address area
2546  * in which to copy user-space fence info
2547  */
2548 void vmw_kms_helper_validation_finish(struct vmw_private *dev_priv,
2549                                       struct drm_file *file_priv,
2550                                       struct vmw_validation_context *ctx,
2551                                       struct vmw_fence_obj **out_fence,
2552                                       struct drm_vmw_fence_rep __user *
2553                                       user_fence_rep)
2554 {
2555         struct vmw_fence_obj *fence = NULL;
2556         uint32_t handle = 0;
2557         int ret = 0;
2558
2559         if (file_priv || user_fence_rep || vmw_validation_has_bos(ctx) ||
2560             out_fence)
2561                 ret = vmw_execbuf_fence_commands(file_priv, dev_priv, &fence,
2562                                                  file_priv ? &handle : NULL);
2563         vmw_validation_done(ctx, fence);
2564         if (file_priv)
2565                 vmw_execbuf_copy_fence_user(dev_priv, vmw_fpriv(file_priv),
2566                                             ret, user_fence_rep, fence,
2567                                             handle, -1);
2568         if (out_fence)
2569                 *out_fence = fence;
2570         else
2571                 vmw_fence_obj_unreference(&fence);
2572 }
2573
2574 /**
2575  * vmw_kms_update_proxy - Helper function to update a proxy surface from
2576  * its backing MOB.
2577  *
2578  * @res: Pointer to the surface resource
2579  * @clips: Clip rects in framebuffer (surface) space.
2580  * @num_clips: Number of clips in @clips.
2581  * @increment: Integer with which to increment the clip counter when looping.
2582  * Used to skip a predetermined number of clip rects.
2583  *
2584  * This function makes sure the proxy surface is updated from its backing MOB
2585  * using the region given by @clips. The surface resource @res and its backing
2586  * MOB needs to be reserved and validated on call.
2587  */
2588 int vmw_kms_update_proxy(struct vmw_resource *res,
2589                          const struct drm_clip_rect *clips,
2590                          unsigned num_clips,
2591                          int increment)
2592 {
2593         struct vmw_private *dev_priv = res->dev_priv;
2594         struct drm_vmw_size *size = &vmw_res_to_srf(res)->metadata.base_size;
2595         struct {
2596                 SVGA3dCmdHeader header;
2597                 SVGA3dCmdUpdateGBImage body;
2598         } *cmd;
2599         SVGA3dBox *box;
2600         size_t copy_size = 0;
2601         int i;
2602
2603         if (!clips)
2604                 return 0;
2605
2606         cmd = VMW_CMD_RESERVE(dev_priv, sizeof(*cmd) * num_clips);
2607         if (!cmd)
2608                 return -ENOMEM;
2609
2610         for (i = 0; i < num_clips; ++i, clips += increment, ++cmd) {
2611                 box = &cmd->body.box;
2612
2613                 cmd->header.id = SVGA_3D_CMD_UPDATE_GB_IMAGE;
2614                 cmd->header.size = sizeof(cmd->body);
2615                 cmd->body.image.sid = res->id;
2616                 cmd->body.image.face = 0;
2617                 cmd->body.image.mipmap = 0;
2618
2619                 if (clips->x1 > size->width || clips->x2 > size->width ||
2620                     clips->y1 > size->height || clips->y2 > size->height) {
2621                         DRM_ERROR("Invalid clips outsize of framebuffer.\n");
2622                         return -EINVAL;
2623                 }
2624
2625                 box->x = clips->x1;
2626                 box->y = clips->y1;
2627                 box->z = 0;
2628                 box->w = clips->x2 - clips->x1;
2629                 box->h = clips->y2 - clips->y1;
2630                 box->d = 1;
2631
2632                 copy_size += sizeof(*cmd);
2633         }
2634
2635         vmw_cmd_commit(dev_priv, copy_size);
2636
2637         return 0;
2638 }
2639
2640 /**
2641  * vmw_kms_create_implicit_placement_property - Set up the implicit placement
2642  * property.
2643  *
2644  * @dev_priv: Pointer to a device private struct.
2645  *
2646  * Sets up the implicit placement property unless it's already set up.
2647  */
2648 void
2649 vmw_kms_create_implicit_placement_property(struct vmw_private *dev_priv)
2650 {
2651         if (dev_priv->implicit_placement_property)
2652                 return;
2653
2654         dev_priv->implicit_placement_property =
2655                 drm_property_create_range(&dev_priv->drm,
2656                                           DRM_MODE_PROP_IMMUTABLE,
2657                                           "implicit_placement", 0, 1);
2658 }
2659
2660 /**
2661  * vmw_kms_suspend - Save modesetting state and turn modesetting off.
2662  *
2663  * @dev: Pointer to the drm device
2664  * Return: 0 on success. Negative error code on failure.
2665  */
2666 int vmw_kms_suspend(struct drm_device *dev)
2667 {
2668         struct vmw_private *dev_priv = vmw_priv(dev);
2669
2670         dev_priv->suspend_state = drm_atomic_helper_suspend(dev);
2671         if (IS_ERR(dev_priv->suspend_state)) {
2672                 int ret = PTR_ERR(dev_priv->suspend_state);
2673
2674                 DRM_ERROR("Failed kms suspend: %d\n", ret);
2675                 dev_priv->suspend_state = NULL;
2676
2677                 return ret;
2678         }
2679
2680         return 0;
2681 }
2682
2683
2684 /**
2685  * vmw_kms_resume - Re-enable modesetting and restore state
2686  *
2687  * @dev: Pointer to the drm device
2688  * Return: 0 on success. Negative error code on failure.
2689  *
2690  * State is resumed from a previous vmw_kms_suspend(). It's illegal
2691  * to call this function without a previous vmw_kms_suspend().
2692  */
2693 int vmw_kms_resume(struct drm_device *dev)
2694 {
2695         struct vmw_private *dev_priv = vmw_priv(dev);
2696         int ret;
2697
2698         if (WARN_ON(!dev_priv->suspend_state))
2699                 return 0;
2700
2701         ret = drm_atomic_helper_resume(dev, dev_priv->suspend_state);
2702         dev_priv->suspend_state = NULL;
2703
2704         return ret;
2705 }
2706
2707 /**
2708  * vmw_kms_lost_device - Notify kms that modesetting capabilities will be lost
2709  *
2710  * @dev: Pointer to the drm device
2711  */
2712 void vmw_kms_lost_device(struct drm_device *dev)
2713 {
2714         drm_atomic_helper_shutdown(dev);
2715 }
2716
2717 /**
2718  * vmw_du_helper_plane_update - Helper to do plane update on a display unit.
2719  * @update: The closure structure.
2720  *
2721  * Call this helper after setting callbacks in &vmw_du_update_plane to do plane
2722  * update on display unit.
2723  *
2724  * Return: 0 on success or a negative error code on failure.
2725  */
2726 int vmw_du_helper_plane_update(struct vmw_du_update_plane *update)
2727 {
2728         struct drm_plane_state *state = update->plane->state;
2729         struct drm_plane_state *old_state = update->old_state;
2730         struct drm_atomic_helper_damage_iter iter;
2731         struct drm_rect clip;
2732         struct drm_rect bb;
2733         DECLARE_VAL_CONTEXT(val_ctx, NULL, 0);
2734         uint32_t reserved_size = 0;
2735         uint32_t submit_size = 0;
2736         uint32_t curr_size = 0;
2737         uint32_t num_hits = 0;
2738         void *cmd_start;
2739         char *cmd_next;
2740         int ret;
2741
2742         /*
2743          * Iterate in advance to check if really need plane update and find the
2744          * number of clips that actually are in plane src for fifo allocation.
2745          */
2746         drm_atomic_helper_damage_iter_init(&iter, old_state, state);
2747         drm_atomic_for_each_plane_damage(&iter, &clip)
2748                 num_hits++;
2749
2750         if (num_hits == 0)
2751                 return 0;
2752
2753         if (update->vfb->bo) {
2754                 struct vmw_framebuffer_bo *vfbbo =
2755                         container_of(update->vfb, typeof(*vfbbo), base);
2756
2757                 /*
2758                  * For screen targets we want a mappable bo, for everything else we want
2759                  * accelerated i.e. host backed (vram or gmr) bo. If the display unit
2760                  * is not screen target then mob's shouldn't be available.
2761                  */
2762                 if (update->dev_priv->active_display_unit == vmw_du_screen_target) {
2763                         vmw_bo_placement_set(vfbbo->buffer,
2764                                              VMW_BO_DOMAIN_SYS | VMW_BO_DOMAIN_MOB | VMW_BO_DOMAIN_GMR,
2765                                              VMW_BO_DOMAIN_SYS | VMW_BO_DOMAIN_MOB | VMW_BO_DOMAIN_GMR);
2766                 } else {
2767                         WARN_ON(update->dev_priv->has_mob);
2768                         vmw_bo_placement_set_default_accelerated(vfbbo->buffer);
2769                 }
2770                 ret = vmw_validation_add_bo(&val_ctx, vfbbo->buffer);
2771         } else {
2772                 struct vmw_framebuffer_surface *vfbs =
2773                         container_of(update->vfb, typeof(*vfbs), base);
2774
2775                 ret = vmw_validation_add_resource(&val_ctx, &vfbs->surface->res,
2776                                                   0, VMW_RES_DIRTY_NONE, NULL,
2777                                                   NULL);
2778         }
2779
2780         if (ret)
2781                 return ret;
2782
2783         ret = vmw_validation_prepare(&val_ctx, update->mutex, update->intr);
2784         if (ret)
2785                 goto out_unref;
2786
2787         reserved_size = update->calc_fifo_size(update, num_hits);
2788         cmd_start = VMW_CMD_RESERVE(update->dev_priv, reserved_size);
2789         if (!cmd_start) {
2790                 ret = -ENOMEM;
2791                 goto out_revert;
2792         }
2793
2794         cmd_next = cmd_start;
2795
2796         if (update->post_prepare) {
2797                 curr_size = update->post_prepare(update, cmd_next);
2798                 cmd_next += curr_size;
2799                 submit_size += curr_size;
2800         }
2801
2802         if (update->pre_clip) {
2803                 curr_size = update->pre_clip(update, cmd_next, num_hits);
2804                 cmd_next += curr_size;
2805                 submit_size += curr_size;
2806         }
2807
2808         bb.x1 = INT_MAX;
2809         bb.y1 = INT_MAX;
2810         bb.x2 = INT_MIN;
2811         bb.y2 = INT_MIN;
2812
2813         drm_atomic_helper_damage_iter_init(&iter, old_state, state);
2814         drm_atomic_for_each_plane_damage(&iter, &clip) {
2815                 uint32_t fb_x = clip.x1;
2816                 uint32_t fb_y = clip.y1;
2817
2818                 vmw_du_translate_to_crtc(state, &clip);
2819                 if (update->clip) {
2820                         curr_size = update->clip(update, cmd_next, &clip, fb_x,
2821                                                  fb_y);
2822                         cmd_next += curr_size;
2823                         submit_size += curr_size;
2824                 }
2825                 bb.x1 = min_t(int, bb.x1, clip.x1);
2826                 bb.y1 = min_t(int, bb.y1, clip.y1);
2827                 bb.x2 = max_t(int, bb.x2, clip.x2);
2828                 bb.y2 = max_t(int, bb.y2, clip.y2);
2829         }
2830
2831         curr_size = update->post_clip(update, cmd_next, &bb);
2832         submit_size += curr_size;
2833
2834         if (reserved_size < submit_size)
2835                 submit_size = 0;
2836
2837         vmw_cmd_commit(update->dev_priv, submit_size);
2838
2839         vmw_kms_helper_validation_finish(update->dev_priv, NULL, &val_ctx,
2840                                          update->out_fence, NULL);
2841         return ret;
2842
2843 out_revert:
2844         vmw_validation_revert(&val_ctx);
2845
2846 out_unref:
2847         vmw_validation_unref_lists(&val_ctx);
2848         return ret;
2849 }
2850
2851 /**
2852  * vmw_connector_mode_valid - implements drm_connector_helper_funcs.mode_valid callback
2853  *
2854  * @connector: the drm connector, part of a DU container
2855  * @mode: drm mode to check
2856  *
2857  * Returns MODE_OK on success, or a drm_mode_status error code.
2858  */
2859 enum drm_mode_status vmw_connector_mode_valid(struct drm_connector *connector,
2860                                               struct drm_display_mode *mode)
2861 {
2862         struct drm_device *dev = connector->dev;
2863         struct vmw_private *dev_priv = vmw_priv(dev);
2864         u32 max_width = dev_priv->texture_max_width;
2865         u32 max_height = dev_priv->texture_max_height;
2866         u32 assumed_cpp = 4;
2867
2868         if (dev_priv->assume_16bpp)
2869                 assumed_cpp = 2;
2870
2871         if (dev_priv->active_display_unit == vmw_du_screen_target) {
2872                 max_width  = min(dev_priv->stdu_max_width,  max_width);
2873                 max_height = min(dev_priv->stdu_max_height, max_height);
2874         }
2875
2876         if (max_width < mode->hdisplay)
2877                 return MODE_BAD_HVALUE;
2878
2879         if (max_height < mode->vdisplay)
2880                 return MODE_BAD_VVALUE;
2881
2882         if (!vmw_kms_validate_mode_vram(dev_priv,
2883                                         mode->hdisplay * assumed_cpp,
2884                                         mode->vdisplay))
2885                 return MODE_MEM;
2886
2887         return MODE_OK;
2888 }
2889
2890 /**
2891  * vmw_connector_get_modes - implements drm_connector_helper_funcs.get_modes callback
2892  *
2893  * @connector: the drm connector, part of a DU container
2894  *
2895  * Returns the number of added modes.
2896  */
2897 int vmw_connector_get_modes(struct drm_connector *connector)
2898 {
2899         struct vmw_display_unit *du = vmw_connector_to_du(connector);
2900         struct drm_device *dev = connector->dev;
2901         struct vmw_private *dev_priv = vmw_priv(dev);
2902         struct drm_display_mode *mode = NULL;
2903         struct drm_display_mode prefmode = { DRM_MODE("preferred",
2904                 DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED,
2905                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2906                 DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC)
2907         };
2908         u32 max_width;
2909         u32 max_height;
2910         u32 num_modes;
2911
2912         /* Add preferred mode */
2913         mode = drm_mode_duplicate(dev, &prefmode);
2914         if (!mode)
2915                 return 0;
2916
2917         mode->hdisplay = du->pref_width;
2918         mode->vdisplay = du->pref_height;
2919         vmw_guess_mode_timing(mode);
2920         drm_mode_set_name(mode);
2921
2922         drm_mode_probed_add(connector, mode);
2923         drm_dbg_kms(dev, "preferred mode " DRM_MODE_FMT "\n", DRM_MODE_ARG(mode));
2924
2925         /* Probe connector for all modes not exceeding our geom limits */
2926         max_width  = dev_priv->texture_max_width;
2927         max_height = dev_priv->texture_max_height;
2928
2929         if (dev_priv->active_display_unit == vmw_du_screen_target) {
2930                 max_width  = min(dev_priv->stdu_max_width,  max_width);
2931                 max_height = min(dev_priv->stdu_max_height, max_height);
2932         }
2933
2934         num_modes = 1 + drm_add_modes_noedid(connector, max_width, max_height);
2935
2936         return num_modes;
2937 }