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