drivers/gpu/drm/vmwgfx/vmwgfx_kms.c

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