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