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