drivers/gpu/drm/vmwgfx/vmwgfx_kms.c

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