drivers/gpu/drm/vmwgfx/vmwgfx_kms.c

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