drivers/gpu/drm/vmwgfx/vmwgfx

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
vmw_du_cleanup
vmw_cursor_update_image
vmw_cursor_update_bo
vmw_cursor_update_position
vmw_kms_cursor_snoop
vmw_kms_legacy_hotspot_clear
vmw_kms_cursor_post_execbuf
vmw_du_cursor_plane_destroy
vmw_du_primary_plane_destroy
vmw_du_plane_unpin_surf
vmw_du_plane_cleanup_fb
vmw_du_cursor_plane_prepare_fb
vmw_du_cursor_plane_atomic_update
vmw_du_primary_plane_atomic_check
vmw_du_cursor_plane_atomic_check
vmw_du_crtc_atomic_check
vmw_du_crtc_atomic_begin
vmw_du_crtc_atomic_flush
vmw_du_crtc_duplicate_state
vmw_du_crtc_reset
vmw_du_crtc_destroy_state
vmw_du_plane_duplicate_state
vmw_du_plane_reset
vmw_du_plane_destroy_state
vmw_du_connector_duplicate_state
vmw_du_connector_reset
vmw_du_connector_destroy_state
vmw_framebuffer_surface_destroy
vmw_kms_readback
vmw_kms_new_framebuffer_surface
vmw_framebuffer_bo_destroy
vmw_framebuffer_bo_dirty
vmw_framebuffer_bo_dirty_ext
vmw_framebuffer_pin
vmw_framebuffer_unpin
vmw_create_bo_proxy
vmw_kms_new_framebuffer_bo
vmw_kms_srf_ok
vmw_kms_new_framebuffer
vmw_kms_fb_create
vmw_kms_check_display_memory
vmw_crtc_state_and_lock
vmw_kms_check_implicit
vmw_kms_check_topology
vmw_kms_atomic_check_modeset
vmw_kms_generic_present
vmw_kms_present
vmw_kms_create_hotplug_mode_update_property
vmw_kms_init
vmw_kms_close
vmw_kms_cursor_bypass_ioctl
vmw_kms_write_svga
vmw_kms_save_vga
vmw_kms_restore_vga
vmw_kms_validate_mode_vram
vmw_get_vblank_counter
vmw_enable_vblank
vmw_disable_vblank
vmw_du_update_layout
vmw_du_crtc_gamma_set
vmw_du_connector_dpms
vmw_du_connector_detect
vmw_guess_mode_timing
vmw_du_connector_fill_modes
vmw_kms_update_layout_ioctl
vmw_kms_helper_dirty
vmw_kms_helper_validation_finish
vmw_kms_update_proxy
vmw_kms_fbdev_init_data
vmw_kms_create_implicit_placement_property
vmw_kms_suspend
vmw_kms_resume
vmw_kms_lost_device
vmw_du_helper_plane_update
   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->scanout))
 909                 return -EINVAL;
 910 
 911         if (unlikely(surface->mip_levels[0] != 1 ||
 912                      surface->num_sizes != 1 ||
 913                      surface->base_size.width < mode_cmd->width ||
 914                      surface->base_size.height < mode_cmd->height ||
 915                      surface->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 (!dev_priv->has_dx && format != surface->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         uint32_t format;
1148         struct drm_vmw_size content_base_size = {0};
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         content_base_size.width  = mode_cmd->pitches[0] / bytes_pp;
1179         content_base_size.height = mode_cmd->height;
1180         content_base_size.depth  = 1;
1181 
1182         ret = vmw_surface_gb_priv_define(dev,
1183                                          0, /* kernel visible only */
1184                                          0, /* flags */
1185                                          format,
1186                                          true, /* can be a scanout buffer */
1187                                          1, /* num of mip levels */
1188                                          0,
1189                                          0,
1190                                          content_base_size,
1191                                          SVGA3D_MS_PATTERN_NONE,
1192                                          SVGA3D_MS_QUALITY_NONE,
1193                                          srf_out);
1194         if (ret) {
1195                 DRM_ERROR("Failed to allocate proxy content buffer\n");
1196                 return ret;
1197         }
1198 
1199         res = &(*srf_out)->res;
1200 
1201         /* Reserve and switch the backing mob. */
1202         mutex_lock(&res->dev_priv->cmdbuf_mutex);
1203         (void) vmw_resource_reserve(res, false, true);
1204         vmw_bo_unreference(&res->backup);
1205         res->backup = vmw_bo_reference(bo_mob);
1206         res->backup_offset = 0;
1207         vmw_resource_unreserve(res, false, false, false, NULL, 0);
1208         mutex_unlock(&res->dev_priv->cmdbuf_mutex);
1209 
1210         return 0;
1211 }
1212 
1213 
1214 
1215 static int vmw_kms_new_framebuffer_bo(struct vmw_private *dev_priv,
1216                                       struct vmw_buffer_object *bo,
1217                                       struct vmw_framebuffer **out,
1218                                       const struct drm_mode_fb_cmd2
1219                                       *mode_cmd)
1220 
1221 {
1222         struct drm_device *dev = dev_priv->dev;
1223         struct vmw_framebuffer_bo *vfbd;
1224         unsigned int requested_size;
1225         struct drm_format_name_buf format_name;
1226         int ret;
1227 
1228         requested_size = mode_cmd->height * mode_cmd->pitches[0];
1229         if (unlikely(requested_size > bo->base.num_pages * PAGE_SIZE)) {
1230                 DRM_ERROR("Screen buffer object size is too small "
1231                           "for requested mode.\n");
1232                 return -EINVAL;
1233         }
1234 
1235         /* Limited framebuffer color depth support for screen objects */
1236         if (dev_priv->active_display_unit == vmw_du_screen_object) {
1237                 switch (mode_cmd->pixel_format) {
1238                 case DRM_FORMAT_XRGB8888:
1239                 case DRM_FORMAT_ARGB8888:
1240                         break;
1241                 case DRM_FORMAT_XRGB1555:
1242                 case DRM_FORMAT_RGB565:
1243                         break;
1244                 default:
1245                         DRM_ERROR("Invalid pixel format: %s\n",
1246                                   drm_get_format_name(mode_cmd->pixel_format, &format_name));
1247                         return -EINVAL;
1248                 }
1249         }
1250 
1251         vfbd = kzalloc(sizeof(*vfbd), GFP_KERNEL);
1252         if (!vfbd) {
1253                 ret = -ENOMEM;
1254                 goto out_err1;
1255         }
1256 
1257         drm_helper_mode_fill_fb_struct(dev, &vfbd->base.base, mode_cmd);
1258         vfbd->base.bo = true;
1259         vfbd->buffer = vmw_bo_reference(bo);
1260         vfbd->base.user_handle = mode_cmd->handles[0];
1261         *out = &vfbd->base;
1262 
1263         ret = drm_framebuffer_init(dev, &vfbd->base.base,
1264                                    &vmw_framebuffer_bo_funcs);
1265         if (ret)
1266                 goto out_err2;
1267 
1268         return 0;
1269 
1270 out_err2:
1271         vmw_bo_unreference(&bo);
1272         kfree(vfbd);
1273 out_err1:
1274         return ret;
1275 }
1276 
1277 
1278 /**
1279  * vmw_kms_srf_ok - check if a surface can be created
1280  *
1281  * @width: requested width
1282  * @height: requested height
1283  *
1284  * Surfaces need to be less than texture size
1285  */
1286 static bool
1287 vmw_kms_srf_ok(struct vmw_private *dev_priv, uint32_t width, uint32_t height)
1288 {
1289         if (width  > dev_priv->texture_max_width ||
1290             height > dev_priv->texture_max_height)
1291                 return false;
1292 
1293         return true;
1294 }
1295 
1296 /**
1297  * vmw_kms_new_framebuffer - Create a new framebuffer.
1298  *
1299  * @dev_priv: Pointer to device private struct.
1300  * @bo: Pointer to buffer object to wrap the kms framebuffer around.
1301  * Either @bo or @surface must be NULL.
1302  * @surface: Pointer to a surface to wrap the kms framebuffer around.
1303  * Either @bo or @surface must be NULL.
1304  * @only_2d: No presents will occur to this buffer object based framebuffer.
1305  * This helps the code to do some important optimizations.
1306  * @mode_cmd: Frame-buffer metadata.
1307  */
1308 struct vmw_framebuffer *
1309 vmw_kms_new_framebuffer(struct vmw_private *dev_priv,
1310                         struct vmw_buffer_object *bo,
1311                         struct vmw_surface *surface,
1312                         bool only_2d,
1313                         const struct drm_mode_fb_cmd2 *mode_cmd)
1314 {
1315         struct vmw_framebuffer *vfb = NULL;
1316         bool is_bo_proxy = false;
1317         int ret;
1318 
1319         /*
1320          * We cannot use the SurfaceDMA command in an non-accelerated VM,
1321          * therefore, wrap the buffer object in a surface so we can use the
1322          * SurfaceCopy command.
1323          */
1324         if (vmw_kms_srf_ok(dev_priv, mode_cmd->width, mode_cmd->height)  &&
1325             bo && only_2d &&
1326             mode_cmd->width > 64 &&  /* Don't create a proxy for cursor */
1327             dev_priv->active_display_unit == vmw_du_screen_target) {
1328                 ret = vmw_create_bo_proxy(dev_priv->dev, mode_cmd,
1329                                           bo, &surface);
1330                 if (ret)
1331                         return ERR_PTR(ret);
1332 
1333                 is_bo_proxy = true;
1334         }
1335 
1336         /* Create the new framebuffer depending one what we have */
1337         if (surface) {
1338                 ret = vmw_kms_new_framebuffer_surface(dev_priv, surface, &vfb,
1339                                                       mode_cmd,
1340                                                       is_bo_proxy);
1341 
1342                 /*
1343                  * vmw_create_bo_proxy() adds a reference that is no longer
1344                  * needed
1345                  */
1346                 if (is_bo_proxy)
1347                         vmw_surface_unreference(&surface);
1348         } else if (bo) {
1349                 ret = vmw_kms_new_framebuffer_bo(dev_priv, bo, &vfb,
1350                                                  mode_cmd);
1351         } else {
1352                 BUG();
1353         }
1354 
1355         if (ret)
1356                 return ERR_PTR(ret);
1357 
1358         vfb->pin = vmw_framebuffer_pin;
1359         vfb->unpin = vmw_framebuffer_unpin;
1360 
1361         return vfb;
1362 }
1363 
1364 /*
1365  * Generic Kernel modesetting functions
1366  */
1367 
1368 static struct drm_framebuffer *vmw_kms_fb_create(struct drm_device *dev,
1369                                                  struct drm_file *file_priv,
1370                                                  const struct drm_mode_fb_cmd2 *mode_cmd)
1371 {
1372         struct vmw_private *dev_priv = vmw_priv(dev);
1373         struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;
1374         struct vmw_framebuffer *vfb = NULL;
1375         struct vmw_surface *surface = NULL;
1376         struct vmw_buffer_object *bo = NULL;
1377         struct ttm_base_object *user_obj;
1378         int ret;
1379 
1380         /*
1381          * Take a reference on the user object of the resource
1382          * backing the kms fb. This ensures that user-space handle
1383          * lookups on that resource will always work as long as
1384          * it's registered with a kms framebuffer. This is important,
1385          * since vmw_execbuf_process identifies resources in the
1386          * command stream using user-space handles.
1387          */
1388 
1389         user_obj = ttm_base_object_lookup(tfile, mode_cmd->handles[0]);
1390         if (unlikely(user_obj == NULL)) {
1391                 DRM_ERROR("Could not locate requested kms frame buffer.\n");
1392                 return ERR_PTR(-ENOENT);
1393         }
1394 
1395         /**
1396          * End conditioned code.
1397          */
1398 
1399         /* returns either a bo or surface */
1400         ret = vmw_user_lookup_handle(dev_priv, tfile,
1401                                      mode_cmd->handles[0],
1402                                      &surface, &bo);
1403         if (ret)
1404                 goto err_out;
1405 
1406 
1407         if (!bo &&
1408             !vmw_kms_srf_ok(dev_priv, mode_cmd->width, mode_cmd->height)) {
1409                 DRM_ERROR("Surface size cannot exceed %dx%d",
1410                         dev_priv->texture_max_width,
1411                         dev_priv->texture_max_height);
1412                 goto err_out;
1413         }
1414 
1415 
1416         vfb = vmw_kms_new_framebuffer(dev_priv, bo, surface,
1417                                       !(dev_priv->capabilities & SVGA_CAP_3D),
1418                                       mode_cmd);
1419         if (IS_ERR(vfb)) {
1420                 ret = PTR_ERR(vfb);
1421                 goto err_out;
1422         }
1423 
1424 err_out:
1425         /* vmw_user_lookup_handle takes one ref so does new_fb */
1426         if (bo)
1427                 vmw_bo_unreference(&bo);
1428         if (surface)
1429                 vmw_surface_unreference(&surface);
1430 
1431         if (ret) {
1432                 DRM_ERROR("failed to create vmw_framebuffer: %i\n", ret);
1433                 ttm_base_object_unref(&user_obj);
1434                 return ERR_PTR(ret);
1435         } else
1436                 vfb->user_obj = user_obj;
1437 
1438         return &vfb->base;
1439 }
1440 
1441 /**
1442  * vmw_kms_check_display_memory - Validates display memory required for a
1443  * topology
1444  * @dev: DRM device
1445  * @num_rects: number of drm_rect in rects
1446  * @rects: array of drm_rect representing the topology to validate indexed by
1447  * crtc index.
1448  *
1449  * Returns:
1450  * 0 on success otherwise negative error code
1451  */
1452 static int vmw_kms_check_display_memory(struct drm_device *dev,
1453                                         uint32_t num_rects,
1454                                         struct drm_rect *rects)
1455 {
1456         struct vmw_private *dev_priv = vmw_priv(dev);
1457         struct drm_rect bounding_box = {0};
1458         u64 total_pixels = 0, pixel_mem, bb_mem;
1459         int i;
1460 
1461         for (i = 0; i < num_rects; i++) {
1462                 /*
1463                  * For STDU only individual screen (screen target) is limited by
1464                  * SCREENTARGET_MAX_WIDTH/HEIGHT registers.
1465                  */
1466                 if (dev_priv->active_display_unit == vmw_du_screen_target &&
1467                     (drm_rect_width(&rects[i]) > dev_priv->stdu_max_width ||
1468                      drm_rect_height(&rects[i]) > dev_priv->stdu_max_height)) {
1469                         VMW_DEBUG_KMS("Screen size not supported.\n");
1470                         return -EINVAL;
1471                 }
1472 
1473                 /* Bounding box upper left is at (0,0). */
1474                 if (rects[i].x2 > bounding_box.x2)
1475                         bounding_box.x2 = rects[i].x2;
1476 
1477                 if (rects[i].y2 > bounding_box.y2)
1478                         bounding_box.y2 = rects[i].y2;
1479 
1480                 total_pixels += (u64) drm_rect_width(&rects[i]) *
1481                         (u64) drm_rect_height(&rects[i]);
1482         }
1483 
1484         /* Virtual svga device primary limits are always in 32-bpp. */
1485         pixel_mem = total_pixels * 4;
1486 
1487         /*
1488          * For HV10 and below prim_bb_mem is vram size. When
1489          * SVGA_REG_MAX_PRIMARY_BOUNDING_BOX_MEM is not present vram size is
1490          * limit on primary bounding box
1491          */
1492         if (pixel_mem > dev_priv->prim_bb_mem) {
1493                 VMW_DEBUG_KMS("Combined output size too large.\n");
1494                 return -EINVAL;
1495         }
1496 
1497         /* SVGA_CAP_NO_BB_RESTRICTION is available for STDU only. */
1498         if (dev_priv->active_display_unit != vmw_du_screen_target ||
1499             !(dev_priv->capabilities & SVGA_CAP_NO_BB_RESTRICTION)) {
1500                 bb_mem = (u64) bounding_box.x2 * bounding_box.y2 * 4;
1501 
1502                 if (bb_mem > dev_priv->prim_bb_mem) {
1503                         VMW_DEBUG_KMS("Topology is beyond supported limits.\n");
1504                         return -EINVAL;
1505                 }
1506         }
1507 
1508         return 0;
1509 }
1510 
1511 /**
1512  * vmw_crtc_state_and_lock - Return new or current crtc state with locked
1513  * crtc mutex
1514  * @state: The atomic state pointer containing the new atomic state
1515  * @crtc: The crtc
1516  *
1517  * This function returns the new crtc state if it's part of the state update.
1518  * Otherwise returns the current crtc state. It also makes sure that the
1519  * crtc mutex is locked.
1520  *
1521  * Returns: A valid crtc state pointer or NULL. It may also return a
1522  * pointer error, in particular -EDEADLK if locking needs to be rerun.
1523  */
1524 static struct drm_crtc_state *
1525 vmw_crtc_state_and_lock(struct drm_atomic_state *state, struct drm_crtc *crtc)
1526 {
1527         struct drm_crtc_state *crtc_state;
1528 
1529         crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
1530         if (crtc_state) {
1531                 lockdep_assert_held(&crtc->mutex.mutex.base);
1532         } else {
1533                 int ret = drm_modeset_lock(&crtc->mutex, state->acquire_ctx);
1534 
1535                 if (ret != 0 && ret != -EALREADY)
1536                         return ERR_PTR(ret);
1537 
1538                 crtc_state = crtc->state;
1539         }
1540 
1541         return crtc_state;
1542 }
1543 
1544 /**
1545  * vmw_kms_check_implicit - Verify that all implicit display units scan out
1546  * from the same fb after the new state is committed.
1547  * @dev: The drm_device.
1548  * @state: The new state to be checked.
1549  *
1550  * Returns:
1551  *   Zero on success,
1552  *   -EINVAL on invalid state,
1553  *   -EDEADLK if modeset locking needs to be rerun.
1554  */
1555 static int vmw_kms_check_implicit(struct drm_device *dev,
1556                                   struct drm_atomic_state *state)
1557 {
1558         struct drm_framebuffer *implicit_fb = NULL;
1559         struct drm_crtc *crtc;
1560         struct drm_crtc_state *crtc_state;
1561         struct drm_plane_state *plane_state;
1562 
1563         drm_for_each_crtc(crtc, dev) {
1564                 struct vmw_display_unit *du = vmw_crtc_to_du(crtc);
1565 
1566                 if (!du->is_implicit)
1567                         continue;
1568 
1569                 crtc_state = vmw_crtc_state_and_lock(state, crtc);
1570                 if (IS_ERR(crtc_state))
1571                         return PTR_ERR(crtc_state);
1572 
1573                 if (!crtc_state || !crtc_state->enable)
1574                         continue;
1575 
1576                 /*
1577                  * Can't move primary planes across crtcs, so this is OK.
1578                  * It also means we don't need to take the plane mutex.
1579                  */
1580                 plane_state = du->primary.state;
1581                 if (plane_state->crtc != crtc)
1582                         continue;
1583 
1584                 if (!implicit_fb)
1585                         implicit_fb = plane_state->fb;
1586                 else if (implicit_fb != plane_state->fb)
1587                         return -EINVAL;
1588         }
1589 
1590         return 0;
1591 }
1592 
1593 /**
1594  * vmw_kms_check_topology - Validates topology in drm_atomic_state
1595  * @dev: DRM device
1596  * @state: the driver state object
1597  *
1598  * Returns:
1599  * 0 on success otherwise negative error code
1600  */
1601 static int vmw_kms_check_topology(struct drm_device *dev,
1602                                   struct drm_atomic_state *state)
1603 {
1604         struct drm_crtc_state *old_crtc_state, *new_crtc_state;
1605         struct drm_rect *rects;
1606         struct drm_crtc *crtc;
1607         uint32_t i;
1608         int ret = 0;
1609 
1610         rects = kcalloc(dev->mode_config.num_crtc, sizeof(struct drm_rect),
1611                         GFP_KERNEL);
1612         if (!rects)
1613                 return -ENOMEM;
1614 
1615         drm_for_each_crtc(crtc, dev) {
1616                 struct vmw_display_unit *du = vmw_crtc_to_du(crtc);
1617                 struct drm_crtc_state *crtc_state;
1618 
1619                 i = drm_crtc_index(crtc);
1620 
1621                 crtc_state = vmw_crtc_state_and_lock(state, crtc);
1622                 if (IS_ERR(crtc_state)) {
1623                         ret = PTR_ERR(crtc_state);
1624                         goto clean;
1625                 }
1626 
1627                 if (!crtc_state)
1628                         continue;
1629 
1630                 if (crtc_state->enable) {
1631                         rects[i].x1 = du->gui_x;
1632                         rects[i].y1 = du->gui_y;
1633                         rects[i].x2 = du->gui_x + crtc_state->mode.hdisplay;
1634                         rects[i].y2 = du->gui_y + crtc_state->mode.vdisplay;
1635                 } else {
1636                         rects[i].x1 = 0;
1637                         rects[i].y1 = 0;
1638                         rects[i].x2 = 0;
1639                         rects[i].y2 = 0;
1640                 }
1641         }
1642 
1643         /* Determine change to topology due to new atomic state */
1644         for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state,
1645                                       new_crtc_state, i) {
1646                 struct vmw_display_unit *du = vmw_crtc_to_du(crtc);
1647                 struct drm_connector *connector;
1648                 struct drm_connector_state *conn_state;
1649                 struct vmw_connector_state *vmw_conn_state;
1650 
1651                 if (!du->pref_active && new_crtc_state->enable) {
1652                         VMW_DEBUG_KMS("Enabling a disabled display unit\n");
1653                         ret = -EINVAL;
1654                         goto clean;
1655                 }
1656 
1657                 /*
1658                  * For vmwgfx each crtc has only one connector attached and it
1659                  * is not changed so don't really need to check the
1660                  * crtc->connector_mask and iterate over it.
1661                  */
1662                 connector = &du->connector;
1663                 conn_state = drm_atomic_get_connector_state(state, connector);
1664                 if (IS_ERR(conn_state)) {
1665                         ret = PTR_ERR(conn_state);
1666                         goto clean;
1667                 }
1668 
1669                 vmw_conn_state = vmw_connector_state_to_vcs(conn_state);
1670                 vmw_conn_state->gui_x = du->gui_x;
1671                 vmw_conn_state->gui_y = du->gui_y;
1672         }
1673 
1674         ret = vmw_kms_check_display_memory(dev, dev->mode_config.num_crtc,
1675                                            rects);
1676 
1677 clean:
1678         kfree(rects);
1679         return ret;
1680 }
1681 
1682 /**
1683  * vmw_kms_atomic_check_modeset- validate state object for modeset changes
1684  *
1685  * @dev: DRM device
1686  * @state: the driver state object
1687  *
1688  * This is a simple wrapper around drm_atomic_helper_check_modeset() for
1689  * us to assign a value to mode->crtc_clock so that
1690  * drm_calc_timestamping_constants() won't throw an error message
1691  *
1692  * Returns:
1693  * Zero for success or -errno
1694  */
1695 static int
1696 vmw_kms_atomic_check_modeset(struct drm_device *dev,
1697                              struct drm_atomic_state *state)
1698 {
1699         struct drm_crtc *crtc;
1700         struct drm_crtc_state *crtc_state;
1701         bool need_modeset = false;
1702         int i, ret;
1703 
1704         ret = drm_atomic_helper_check(dev, state);
1705         if (ret)
1706                 return ret;
1707 
1708         ret = vmw_kms_check_implicit(dev, state);
1709         if (ret) {
1710                 VMW_DEBUG_KMS("Invalid implicit state\n");
1711                 return ret;
1712         }
1713 
1714         for_each_new_crtc_in_state(state, crtc, crtc_state, i) {
1715                 if (drm_atomic_crtc_needs_modeset(crtc_state))
1716                         need_modeset = true;
1717         }
1718 
1719         if (need_modeset)
1720                 return vmw_kms_check_topology(dev, state);
1721 
1722         return ret;
1723 }
1724 
1725 static const struct drm_mode_config_funcs vmw_kms_funcs = {
1726         .fb_create = vmw_kms_fb_create,
1727         .atomic_check = vmw_kms_atomic_check_modeset,
1728         .atomic_commit = drm_atomic_helper_commit,
1729 };
1730 
1731 static int vmw_kms_generic_present(struct vmw_private *dev_priv,
1732                                    struct drm_file *file_priv,
1733                                    struct vmw_framebuffer *vfb,
1734                                    struct vmw_surface *surface,
1735                                    uint32_t sid,
1736                                    int32_t destX, int32_t destY,
1737                                    struct drm_vmw_rect *clips,
1738                                    uint32_t num_clips)
1739 {
1740         return vmw_kms_sou_do_surface_dirty(dev_priv, vfb, NULL, clips,
1741                                             &surface->res, destX, destY,
1742                                             num_clips, 1, NULL, NULL);
1743 }
1744 
1745 
1746 int vmw_kms_present(struct vmw_private *dev_priv,
1747                     struct drm_file *file_priv,
1748                     struct vmw_framebuffer *vfb,
1749                     struct vmw_surface *surface,
1750                     uint32_t sid,
1751                     int32_t destX, int32_t destY,
1752                     struct drm_vmw_rect *clips,
1753                     uint32_t num_clips)
1754 {
1755         int ret;
1756 
1757         switch (dev_priv->active_display_unit) {
1758         case vmw_du_screen_target:
1759                 ret = vmw_kms_stdu_surface_dirty(dev_priv, vfb, NULL, clips,
1760                                                  &surface->res, destX, destY,
1761                                                  num_clips, 1, NULL, NULL);
1762                 break;
1763         case vmw_du_screen_object:
1764                 ret = vmw_kms_generic_present(dev_priv, file_priv, vfb, surface,
1765                                               sid, destX, destY, clips,
1766                                               num_clips);
1767                 break;
1768         default:
1769                 WARN_ONCE(true,
1770                           "Present called with invalid display system.\n");
1771                 ret = -ENOSYS;
1772                 break;
1773         }
1774         if (ret)
1775                 return ret;
1776 
1777         vmw_fifo_flush(dev_priv, false);
1778 
1779         return 0;
1780 }
1781 
1782 static void
1783 vmw_kms_create_hotplug_mode_update_property(struct vmw_private *dev_priv)
1784 {
1785         if (dev_priv->hotplug_mode_update_property)
1786                 return;
1787 
1788         dev_priv->hotplug_mode_update_property =
1789                 drm_property_create_range(dev_priv->dev,
1790                                           DRM_MODE_PROP_IMMUTABLE,
1791                                           "hotplug_mode_update", 0, 1);
1792 
1793         if (!dev_priv->hotplug_mode_update_property)
1794                 return;
1795 
1796 }
1797 
1798 int vmw_kms_init(struct vmw_private *dev_priv)
1799 {
1800         struct drm_device *dev = dev_priv->dev;
1801         int ret;
1802 
1803         drm_mode_config_init(dev);
1804         dev->mode_config.funcs = &vmw_kms_funcs;
1805         dev->mode_config.min_width = 1;
1806         dev->mode_config.min_height = 1;
1807         dev->mode_config.max_width = dev_priv->texture_max_width;
1808         dev->mode_config.max_height = dev_priv->texture_max_height;
1809 
1810         drm_mode_create_suggested_offset_properties(dev);
1811         vmw_kms_create_hotplug_mode_update_property(dev_priv);
1812 
1813         ret = vmw_kms_stdu_init_display(dev_priv);
1814         if (ret) {
1815                 ret = vmw_kms_sou_init_display(dev_priv);
1816                 if (ret) /* Fallback */
1817                         ret = vmw_kms_ldu_init_display(dev_priv);
1818         }
1819 
1820         return ret;
1821 }
1822 
1823 int vmw_kms_close(struct vmw_private *dev_priv)
1824 {
1825         int ret = 0;
1826 
1827         /*
1828          * Docs says we should take the lock before calling this function
1829          * but since it destroys encoders and our destructor calls
1830          * drm_encoder_cleanup which takes the lock we deadlock.
1831          */
1832         drm_mode_config_cleanup(dev_priv->dev);
1833         if (dev_priv->active_display_unit == vmw_du_legacy)
1834                 ret = vmw_kms_ldu_close_display(dev_priv);
1835 
1836         return ret;
1837 }
1838 
1839 int vmw_kms_cursor_bypass_ioctl(struct drm_device *dev, void *data,
1840                                 struct drm_file *file_priv)
1841 {
1842         struct drm_vmw_cursor_bypass_arg *arg = data;
1843         struct vmw_display_unit *du;
1844         struct drm_crtc *crtc;
1845         int ret = 0;
1846 
1847 
1848         mutex_lock(&dev->mode_config.mutex);
1849         if (arg->flags & DRM_VMW_CURSOR_BYPASS_ALL) {
1850 
1851                 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
1852                         du = vmw_crtc_to_du(crtc);
1853                         du->hotspot_x = arg->xhot;
1854                         du->hotspot_y = arg->yhot;
1855                 }
1856 
1857                 mutex_unlock(&dev->mode_config.mutex);
1858                 return 0;
1859         }
1860 
1861         crtc = drm_crtc_find(dev, file_priv, arg->crtc_id);
1862         if (!crtc) {
1863                 ret = -ENOENT;
1864                 goto out;
1865         }
1866 
1867         du = vmw_crtc_to_du(crtc);
1868 
1869         du->hotspot_x = arg->xhot;
1870         du->hotspot_y = arg->yhot;
1871 
1872 out:
1873         mutex_unlock(&dev->mode_config.mutex);
1874 
1875         return ret;
1876 }
1877 
1878 int vmw_kms_write_svga(struct vmw_private *vmw_priv,
1879                         unsigned width, unsigned height, unsigned pitch,
1880                         unsigned bpp, unsigned depth)
1881 {
1882         if (vmw_priv->capabilities & SVGA_CAP_PITCHLOCK)
1883                 vmw_write(vmw_priv, SVGA_REG_PITCHLOCK, pitch);
1884         else if (vmw_fifo_have_pitchlock(vmw_priv))
1885                 vmw_mmio_write(pitch, vmw_priv->mmio_virt +
1886                                SVGA_FIFO_PITCHLOCK);
1887         vmw_write(vmw_priv, SVGA_REG_WIDTH, width);
1888         vmw_write(vmw_priv, SVGA_REG_HEIGHT, height);
1889         vmw_write(vmw_priv, SVGA_REG_BITS_PER_PIXEL, bpp);
1890 
1891         if (vmw_read(vmw_priv, SVGA_REG_DEPTH) != depth) {
1892                 DRM_ERROR("Invalid depth %u for %u bpp, host expects %u\n",
1893                           depth, bpp, vmw_read(vmw_priv, SVGA_REG_DEPTH));
1894                 return -EINVAL;
1895         }
1896 
1897         return 0;
1898 }
1899 
1900 int vmw_kms_save_vga(struct vmw_private *vmw_priv)
1901 {
1902         struct vmw_vga_topology_state *save;
1903         uint32_t i;
1904 
1905         vmw_priv->vga_width = vmw_read(vmw_priv, SVGA_REG_WIDTH);
1906         vmw_priv->vga_height = vmw_read(vmw_priv, SVGA_REG_HEIGHT);
1907         vmw_priv->vga_bpp = vmw_read(vmw_priv, SVGA_REG_BITS_PER_PIXEL);
1908         if (vmw_priv->capabilities & SVGA_CAP_PITCHLOCK)
1909                 vmw_priv->vga_pitchlock =
1910                   vmw_read(vmw_priv, SVGA_REG_PITCHLOCK);
1911         else if (vmw_fifo_have_pitchlock(vmw_priv))
1912                 vmw_priv->vga_pitchlock = vmw_mmio_read(vmw_priv->mmio_virt +
1913                                                         SVGA_FIFO_PITCHLOCK);
1914 
1915         if (!(vmw_priv->capabilities & SVGA_CAP_DISPLAY_TOPOLOGY))
1916                 return 0;
1917 
1918         vmw_priv->num_displays = vmw_read(vmw_priv,
1919                                           SVGA_REG_NUM_GUEST_DISPLAYS);
1920 
1921         if (vmw_priv->num_displays == 0)
1922                 vmw_priv->num_displays = 1;
1923 
1924         for (i = 0; i < vmw_priv->num_displays; ++i) {
1925                 save = &vmw_priv->vga_save[i];
1926                 vmw_write(vmw_priv, SVGA_REG_DISPLAY_ID, i);
1927                 save->primary = vmw_read(vmw_priv, SVGA_REG_DISPLAY_IS_PRIMARY);
1928                 save->pos_x = vmw_read(vmw_priv, SVGA_REG_DISPLAY_POSITION_X);
1929                 save->pos_y = vmw_read(vmw_priv, SVGA_REG_DISPLAY_POSITION_Y);
1930                 save->width = vmw_read(vmw_priv, SVGA_REG_DISPLAY_WIDTH);
1931                 save->height = vmw_read(vmw_priv, SVGA_REG_DISPLAY_HEIGHT);
1932                 vmw_write(vmw_priv, SVGA_REG_DISPLAY_ID, SVGA_ID_INVALID);
1933                 if (i == 0 && vmw_priv->num_displays == 1 &&
1934                     save->width == 0 && save->height == 0) {
1935 
1936                         /*
1937                          * It should be fairly safe to assume that these
1938                          * values are uninitialized.
1939                          */
1940 
1941                         save->width = vmw_priv->vga_width - save->pos_x;
1942                         save->height = vmw_priv->vga_height - save->pos_y;
1943                 }
1944         }
1945 
1946         return 0;
1947 }
1948 
1949 int vmw_kms_restore_vga(struct vmw_private *vmw_priv)
1950 {
1951         struct vmw_vga_topology_state *save;
1952         uint32_t i;
1953 
1954         vmw_write(vmw_priv, SVGA_REG_WIDTH, vmw_priv->vga_width);
1955         vmw_write(vmw_priv, SVGA_REG_HEIGHT, vmw_priv->vga_height);
1956         vmw_write(vmw_priv, SVGA_REG_BITS_PER_PIXEL, vmw_priv->vga_bpp);
1957         if (vmw_priv->capabilities & SVGA_CAP_PITCHLOCK)
1958                 vmw_write(vmw_priv, SVGA_REG_PITCHLOCK,
1959                           vmw_priv->vga_pitchlock);
1960         else if (vmw_fifo_have_pitchlock(vmw_priv))
1961                 vmw_mmio_write(vmw_priv->vga_pitchlock,
1962                                vmw_priv->mmio_virt + SVGA_FIFO_PITCHLOCK);
1963 
1964         if (!(vmw_priv->capabilities & SVGA_CAP_DISPLAY_TOPOLOGY))
1965                 return 0;
1966 
1967         for (i = 0; i < vmw_priv->num_displays; ++i) {
1968                 save = &vmw_priv->vga_save[i];
1969                 vmw_write(vmw_priv, SVGA_REG_DISPLAY_ID, i);
1970                 vmw_write(vmw_priv, SVGA_REG_DISPLAY_IS_PRIMARY, save->primary);
1971                 vmw_write(vmw_priv, SVGA_REG_DISPLAY_POSITION_X, save->pos_x);
1972                 vmw_write(vmw_priv, SVGA_REG_DISPLAY_POSITION_Y, save->pos_y);
1973                 vmw_write(vmw_priv, SVGA_REG_DISPLAY_WIDTH, save->width);
1974                 vmw_write(vmw_priv, SVGA_REG_DISPLAY_HEIGHT, save->height);
1975                 vmw_write(vmw_priv, SVGA_REG_DISPLAY_ID, SVGA_ID_INVALID);
1976         }
1977 
1978         return 0;
1979 }
1980 
1981 bool vmw_kms_validate_mode_vram(struct vmw_private *dev_priv,
1982                                 uint32_t pitch,
1983                                 uint32_t height)
1984 {
1985         return ((u64) pitch * (u64) height) < (u64)
1986                 ((dev_priv->active_display_unit == vmw_du_screen_target) ?
1987                  dev_priv->prim_bb_mem : dev_priv->vram_size);
1988 }
1989 
1990 
1991 /**
1992  * Function called by DRM code called with vbl_lock held.
1993  */
1994 u32 vmw_get_vblank_counter(struct drm_device *dev, unsigned int pipe)
1995 {
1996         return 0;
1997 }
1998 
1999 /**
2000  * Function called by DRM code called with vbl_lock held.
2001  */
2002 int vmw_enable_vblank(struct drm_device *dev, unsigned int pipe)
2003 {
2004         return -EINVAL;
2005 }
2006 
2007 /**
2008  * Function called by DRM code called with vbl_lock held.
2009  */
2010 void vmw_disable_vblank(struct drm_device *dev, unsigned int pipe)
2011 {
2012 }
2013 
2014 /**
2015  * vmw_du_update_layout - Update the display unit with topology from resolution
2016  * plugin and generate DRM uevent
2017  * @dev_priv: device private
2018  * @num_rects: number of drm_rect in rects
2019  * @rects: toplogy to update
2020  */
2021 static int vmw_du_update_layout(struct vmw_private *dev_priv,
2022                                 unsigned int num_rects, struct drm_rect *rects)
2023 {
2024         struct drm_device *dev = dev_priv->dev;
2025         struct vmw_display_unit *du;
2026         struct drm_connector *con;
2027         struct drm_connector_list_iter conn_iter;
2028         struct drm_modeset_acquire_ctx ctx;
2029         struct drm_crtc *crtc;
2030         int ret;
2031 
2032         /* Currently gui_x/y is protected with the crtc mutex */
2033         mutex_lock(&dev->mode_config.mutex);
2034         drm_modeset_acquire_init(&ctx, 0);
2035 retry:
2036         drm_for_each_crtc(crtc, dev) {
2037                 ret = drm_modeset_lock(&crtc->mutex, &ctx);
2038                 if (ret < 0) {
2039                         if (ret == -EDEADLK) {
2040                                 drm_modeset_backoff(&ctx);
2041                                 goto retry;
2042                 }
2043                         goto out_fini;
2044                 }
2045         }
2046 
2047         drm_connector_list_iter_begin(dev, &conn_iter);
2048         drm_for_each_connector_iter(con, &conn_iter) {
2049                 du = vmw_connector_to_du(con);
2050                 if (num_rects > du->unit) {
2051                         du->pref_width = drm_rect_width(&rects[du->unit]);
2052                         du->pref_height = drm_rect_height(&rects[du->unit]);
2053                         du->pref_active = true;
2054                         du->gui_x = rects[du->unit].x1;
2055                         du->gui_y = rects[du->unit].y1;
2056                 } else {
2057                         du->pref_width = 800;
2058                         du->pref_height = 600;
2059                         du->pref_active = false;
2060                         du->gui_x = 0;
2061                         du->gui_y = 0;
2062                 }
2063         }
2064         drm_connector_list_iter_end(&conn_iter);
2065 
2066         list_for_each_entry(con, &dev->mode_config.connector_list, head) {
2067                 du = vmw_connector_to_du(con);
2068                 if (num_rects > du->unit) {
2069                         drm_object_property_set_value
2070                           (&con->base, dev->mode_config.suggested_x_property,
2071                            du->gui_x);
2072                         drm_object_property_set_value
2073                           (&con->base, dev->mode_config.suggested_y_property,
2074                            du->gui_y);
2075                 } else {
2076                         drm_object_property_set_value
2077                           (&con->base, dev->mode_config.suggested_x_property,
2078                            0);
2079                         drm_object_property_set_value
2080                           (&con->base, dev->mode_config.suggested_y_property,
2081                            0);
2082                 }
2083                 con->status = vmw_du_connector_detect(con, true);
2084         }
2085 
2086         drm_sysfs_hotplug_event(dev);
2087 out_fini:
2088         drm_modeset_drop_locks(&ctx);
2089         drm_modeset_acquire_fini(&ctx);
2090         mutex_unlock(&dev->mode_config.mutex);
2091  
2092         return 0;
2093 }
2094 
2095 int vmw_du_crtc_gamma_set(struct drm_crtc *crtc,
2096                           u16 *r, u16 *g, u16 *b,
2097                           uint32_t size,
2098                           struct drm_modeset_acquire_ctx *ctx)
2099 {
2100         struct vmw_private *dev_priv = vmw_priv(crtc->dev);
2101         int i;
2102 
2103         for (i = 0; i < size; i++) {
2104                 DRM_DEBUG("%d r/g/b = 0x%04x / 0x%04x / 0x%04x\n", i,
2105                           r[i], g[i], b[i]);
2106                 vmw_write(dev_priv, SVGA_PALETTE_BASE + i * 3 + 0, r[i] >> 8);
2107                 vmw_write(dev_priv, SVGA_PALETTE_BASE + i * 3 + 1, g[i] >> 8);
2108                 vmw_write(dev_priv, SVGA_PALETTE_BASE + i * 3 + 2, b[i] >> 8);
2109         }
2110 
2111         return 0;
2112 }
2113 
2114 int vmw_du_connector_dpms(struct drm_connector *connector, int mode)
2115 {
2116         return 0;
2117 }
2118 
2119 enum drm_connector_status
2120 vmw_du_connector_detect(struct drm_connector *connector, bool force)
2121 {
2122         uint32_t num_displays;
2123         struct drm_device *dev = connector->dev;
2124         struct vmw_private *dev_priv = vmw_priv(dev);
2125         struct vmw_display_unit *du = vmw_connector_to_du(connector);
2126 
2127         num_displays = vmw_read(dev_priv, SVGA_REG_NUM_DISPLAYS);
2128 
2129         return ((vmw_connector_to_du(connector)->unit < num_displays &&
2130                  du->pref_active) ?
2131                 connector_status_connected : connector_status_disconnected);
2132 }
2133 
2134 static struct drm_display_mode vmw_kms_connector_builtin[] = {
2135         /* 640x480@60Hz */
2136         { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 25175, 640, 656,
2137                    752, 800, 0, 480, 489, 492, 525, 0,
2138                    DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
2139         /* 800x600@60Hz */
2140         { DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 40000, 800, 840,
2141                    968, 1056, 0, 600, 601, 605, 628, 0,
2142                    DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
2143         /* 1024x768@60Hz */
2144         { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 65000, 1024, 1048,
2145                    1184, 1344, 0, 768, 771, 777, 806, 0,
2146                    DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
2147         /* 1152x864@75Hz */
2148         { DRM_MODE("1152x864", DRM_MODE_TYPE_DRIVER, 108000, 1152, 1216,
2149                    1344, 1600, 0, 864, 865, 868, 900, 0,
2150                    DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
2151         /* 1280x768@60Hz */
2152         { DRM_MODE("1280x768", DRM_MODE_TYPE_DRIVER, 79500, 1280, 1344,
2153                    1472, 1664, 0, 768, 771, 778, 798, 0,
2154                    DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
2155         /* 1280x800@60Hz */
2156         { DRM_MODE("1280x800", DRM_MODE_TYPE_DRIVER, 83500, 1280, 1352,
2157                    1480, 1680, 0, 800, 803, 809, 831, 0,
2158                    DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
2159         /* 1280x960@60Hz */
2160         { DRM_MODE("1280x960", DRM_MODE_TYPE_DRIVER, 108000, 1280, 1376,
2161                    1488, 1800, 0, 960, 961, 964, 1000, 0,
2162                    DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
2163         /* 1280x1024@60Hz */
2164         { DRM_MODE("1280x1024", DRM_MODE_TYPE_DRIVER, 108000, 1280, 1328,
2165                    1440, 1688, 0, 1024, 1025, 1028, 1066, 0,
2166                    DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
2167         /* 1360x768@60Hz */
2168         { DRM_MODE("1360x768", DRM_MODE_TYPE_DRIVER, 85500, 1360, 1424,
2169                    1536, 1792, 0, 768, 771, 777, 795, 0,
2170                    DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
2171         /* 1440x1050@60Hz */
2172         { DRM_MODE("1400x1050", DRM_MODE_TYPE_DRIVER, 121750, 1400, 1488,
2173                    1632, 1864, 0, 1050, 1053, 1057, 1089, 0,
2174                    DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
2175         /* 1440x900@60Hz */
2176         { DRM_MODE("1440x900", DRM_MODE_TYPE_DRIVER, 106500, 1440, 1520,
2177                    1672, 1904, 0, 900, 903, 909, 934, 0,
2178                    DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
2179         /* 1600x1200@60Hz */
2180         { DRM_MODE("1600x1200", DRM_MODE_TYPE_DRIVER, 162000, 1600, 1664,
2181                    1856, 2160, 0, 1200, 1201, 1204, 1250, 0,
2182                    DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
2183         /* 1680x1050@60Hz */
2184         { DRM_MODE("1680x1050", DRM_MODE_TYPE_DRIVER, 146250, 1680, 1784,
2185                    1960, 2240, 0, 1050, 1053, 1059, 1089, 0,
2186                    DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
2187         /* 1792x1344@60Hz */
2188         { DRM_MODE("1792x1344", DRM_MODE_TYPE_DRIVER, 204750, 1792, 1920,
2189                    2120, 2448, 0, 1344, 1345, 1348, 1394, 0,
2190                    DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
2191         /* 1853x1392@60Hz */
2192         { DRM_MODE("1856x1392", DRM_MODE_TYPE_DRIVER, 218250, 1856, 1952,
2193                    2176, 2528, 0, 1392, 1393, 1396, 1439, 0,
2194                    DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
2195         /* 1920x1200@60Hz */
2196         { DRM_MODE("1920x1200", DRM_MODE_TYPE_DRIVER, 193250, 1920, 2056,
2197                    2256, 2592, 0, 1200, 1203, 1209, 1245, 0,
2198                    DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
2199         /* 1920x1440@60Hz */
2200         { DRM_MODE("1920x1440", DRM_MODE_TYPE_DRIVER, 234000, 1920, 2048,
2201                    2256, 2600, 0, 1440, 1441, 1444, 1500, 0,
2202                    DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
2203         /* 2560x1600@60Hz */
2204         { DRM_MODE("2560x1600", DRM_MODE_TYPE_DRIVER, 348500, 2560, 2752,
2205                    3032, 3504, 0, 1600, 1603, 1609, 1658, 0,
2206                    DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
2207         /* Terminate */
2208         { DRM_MODE("", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) },
2209 };
2210 
2211 /**
2212  * vmw_guess_mode_timing - Provide fake timings for a
2213  * 60Hz vrefresh mode.
2214  *
2215  * @mode - Pointer to a struct drm_display_mode with hdisplay and vdisplay
2216  * members filled in.
2217  */
2218 void vmw_guess_mode_timing(struct drm_display_mode *mode)
2219 {
2220         mode->hsync_start = mode->hdisplay + 50;
2221         mode->hsync_end = mode->hsync_start + 50;
2222         mode->htotal = mode->hsync_end + 50;
2223 
2224         mode->vsync_start = mode->vdisplay + 50;
2225         mode->vsync_end = mode->vsync_start + 50;
2226         mode->vtotal = mode->vsync_end + 50;
2227 
2228         mode->clock = (u32)mode->htotal * (u32)mode->vtotal / 100 * 6;
2229         mode->vrefresh = drm_mode_vrefresh(mode);
2230 }
2231 
2232 
2233 int vmw_du_connector_fill_modes(struct drm_connector *connector,
2234                                 uint32_t max_width, uint32_t max_height)
2235 {
2236         struct vmw_display_unit *du = vmw_connector_to_du(connector);
2237         struct drm_device *dev = connector->dev;
2238         struct vmw_private *dev_priv = vmw_priv(dev);
2239         struct drm_display_mode *mode = NULL;
2240         struct drm_display_mode *bmode;
2241         struct drm_display_mode prefmode = { DRM_MODE("preferred",
2242                 DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED,
2243                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2244                 DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC)
2245         };
2246         int i;
2247         u32 assumed_bpp = 4;
2248 
2249         if (dev_priv->assume_16bpp)
2250                 assumed_bpp = 2;
2251 
2252         max_width  = min(max_width,  dev_priv->texture_max_width);
2253         max_height = min(max_height, dev_priv->texture_max_height);
2254 
2255         /*
2256          * For STDU extra limit for a mode on SVGA_REG_SCREENTARGET_MAX_WIDTH/
2257          * HEIGHT registers.
2258          */
2259         if (dev_priv->active_display_unit == vmw_du_screen_target) {
2260                 max_width  = min(max_width,  dev_priv->stdu_max_width);
2261                 max_height = min(max_height, dev_priv->stdu_max_height);
2262         }
2263 
2264         /* Add preferred mode */
2265         mode = drm_mode_duplicate(dev, &prefmode);
2266         if (!mode)
2267                 return 0;
2268         mode->hdisplay = du->pref_width;
2269         mode->vdisplay = du->pref_height;
2270         vmw_guess_mode_timing(mode);
2271 
2272         if (vmw_kms_validate_mode_vram(dev_priv,
2273                                         mode->hdisplay * assumed_bpp,
2274                                         mode->vdisplay)) {
2275                 drm_mode_probed_add(connector, mode);
2276         } else {
2277                 drm_mode_destroy(dev, mode);
2278                 mode = NULL;
2279         }
2280 
2281         if (du->pref_mode) {
2282                 list_del_init(&du->pref_mode->head);
2283                 drm_mode_destroy(dev, du->pref_mode);
2284         }
2285 
2286         /* mode might be null here, this is intended */
2287         du->pref_mode = mode;
2288 
2289         for (i = 0; vmw_kms_connector_builtin[i].type != 0; i++) {
2290                 bmode = &vmw_kms_connector_builtin[i];
2291                 if (bmode->hdisplay > max_width ||
2292                     bmode->vdisplay > max_height)
2293                         continue;
2294 
2295                 if (!vmw_kms_validate_mode_vram(dev_priv,
2296                                                 bmode->hdisplay * assumed_bpp,
2297                                                 bmode->vdisplay))
2298                         continue;
2299 
2300                 mode = drm_mode_duplicate(dev, bmode);
2301                 if (!mode)
2302                         return 0;
2303                 mode->vrefresh = drm_mode_vrefresh(mode);
2304 
2305                 drm_mode_probed_add(connector, mode);
2306         }
2307 
2308         drm_connector_list_update(connector);
2309         /* Move the prefered mode first, help apps pick the right mode. */
2310         drm_mode_sort(&connector->modes);
2311 
2312         return 1;
2313 }
2314 
2315 /**
2316  * vmw_kms_update_layout_ioctl - Handler for DRM_VMW_UPDATE_LAYOUT ioctl
2317  * @dev: drm device for the ioctl
2318  * @data: data pointer for the ioctl
2319  * @file_priv: drm file for the ioctl call
2320  *
2321  * Update preferred topology of display unit as per ioctl request. The topology
2322  * is expressed as array of drm_vmw_rect.
2323  * e.g.
2324  * [0 0 640 480] [640 0 800 600] [0 480 640 480]
2325  *
2326  * NOTE:
2327  * The x and y offset (upper left) in drm_vmw_rect cannot be less than 0. Beside
2328  * device limit on topology, x + w and y + h (lower right) cannot be greater
2329  * than INT_MAX. So topology beyond these limits will return with error.
2330  *
2331  * Returns:
2332  * Zero on success, negative errno on failure.
2333  */
2334 int vmw_kms_update_layout_ioctl(struct drm_device *dev, void *data,
2335                                 struct drm_file *file_priv)
2336 {
2337         struct vmw_private *dev_priv = vmw_priv(dev);
2338         struct drm_mode_config *mode_config = &dev->mode_config;
2339         struct drm_vmw_update_layout_arg *arg =
2340                 (struct drm_vmw_update_layout_arg *)data;
2341         void __user *user_rects;
2342         struct drm_vmw_rect *rects;
2343         struct drm_rect *drm_rects;
2344         unsigned rects_size;
2345         int ret, i;
2346 
2347         if (!arg->num_outputs) {
2348                 struct drm_rect def_rect = {0, 0, 800, 600};
2349                 VMW_DEBUG_KMS("Default layout x1 = %d y1 = %d x2 = %d y2 = %d\n",
2350                               def_rect.x1, def_rect.y1,
2351                               def_rect.x2, def_rect.y2);
2352                 vmw_du_update_layout(dev_priv, 1, &def_rect);
2353                 return 0;
2354         }
2355 
2356         rects_size = arg->num_outputs * sizeof(struct drm_vmw_rect);
2357         rects = kcalloc(arg->num_outputs, sizeof(struct drm_vmw_rect),
2358                         GFP_KERNEL);
2359         if (unlikely(!rects))
2360                 return -ENOMEM;
2361 
2362         user_rects = (void __user *)(unsigned long)arg->rects;
2363         ret = copy_from_user(rects, user_rects, rects_size);
2364         if (unlikely(ret != 0)) {
2365                 DRM_ERROR("Failed to get rects.\n");
2366                 ret = -EFAULT;
2367                 goto out_free;
2368         }
2369 
2370         drm_rects = (struct drm_rect *)rects;
2371 
2372         VMW_DEBUG_KMS("Layout count = %u\n", arg->num_outputs);
2373         for (i = 0; i < arg->num_outputs; i++) {
2374                 struct drm_vmw_rect curr_rect;
2375 
2376                 /* Verify user-space for overflow as kernel use drm_rect */
2377                 if ((rects[i].x + rects[i].w > INT_MAX) ||
2378                     (rects[i].y + rects[i].h > INT_MAX)) {
2379                         ret = -ERANGE;
2380                         goto out_free;
2381                 }
2382 
2383                 curr_rect = rects[i];
2384                 drm_rects[i].x1 = curr_rect.x;
2385                 drm_rects[i].y1 = curr_rect.y;
2386                 drm_rects[i].x2 = curr_rect.x + curr_rect.w;
2387                 drm_rects[i].y2 = curr_rect.y + curr_rect.h;
2388 
2389                 VMW_DEBUG_KMS("  x1 = %d y1 = %d x2 = %d y2 = %d\n",
2390                               drm_rects[i].x1, drm_rects[i].y1,
2391                               drm_rects[i].x2, drm_rects[i].y2);
2392 
2393                 /*
2394                  * Currently this check is limiting the topology within
2395                  * mode_config->max (which actually is max texture size
2396                  * supported by virtual device). This limit is here to address
2397                  * window managers that create a big framebuffer for whole
2398                  * topology.
2399                  */
2400                 if (drm_rects[i].x1 < 0 ||  drm_rects[i].y1 < 0 ||
2401                     drm_rects[i].x2 > mode_config->max_width ||
2402                     drm_rects[i].y2 > mode_config->max_height) {
2403                         VMW_DEBUG_KMS("Invalid layout %d %d %d %d\n",
2404                                       drm_rects[i].x1, drm_rects[i].y1,
2405                                       drm_rects[i].x2, drm_rects[i].y2);
2406                         ret = -EINVAL;
2407                         goto out_free;
2408                 }
2409         }
2410 
2411         ret = vmw_kms_check_display_memory(dev, arg->num_outputs, drm_rects);
2412 
2413         if (ret == 0)
2414                 vmw_du_update_layout(dev_priv, arg->num_outputs, drm_rects);
2415 
2416 out_free:
2417         kfree(rects);
2418         return ret;
2419 }
2420 
2421 /**
2422  * vmw_kms_helper_dirty - Helper to build commands and perform actions based
2423  * on a set of cliprects and a set of display units.
2424  *
2425  * @dev_priv: Pointer to a device private structure.
2426  * @framebuffer: Pointer to the framebuffer on which to perform the actions.
2427  * @clips: A set of struct drm_clip_rect. Either this os @vclips must be NULL.
2428  * Cliprects are given in framebuffer coordinates.
2429  * @vclips: A set of struct drm_vmw_rect cliprects. Either this or @clips must
2430  * be NULL. Cliprects are given in source coordinates.
2431  * @dest_x: X coordinate offset for the crtc / destination clip rects.
2432  * @dest_y: Y coordinate offset for the crtc / destination clip rects.
2433  * @num_clips: Number of cliprects in the @clips or @vclips array.
2434  * @increment: Integer with which to increment the clip counter when looping.
2435  * Used to skip a predetermined number of clip rects.
2436  * @dirty: Closure structure. See the description of struct vmw_kms_dirty.
2437  */
2438 int vmw_kms_helper_dirty(struct vmw_private *dev_priv,
2439                          struct vmw_framebuffer *framebuffer,
2440                          const struct drm_clip_rect *clips,
2441                          const struct drm_vmw_rect *vclips,
2442                          s32 dest_x, s32 dest_y,
2443                          int num_clips,
2444                          int increment,
2445                          struct vmw_kms_dirty *dirty)
2446 {
2447         struct vmw_display_unit *units[VMWGFX_NUM_DISPLAY_UNITS];
2448         struct drm_crtc *crtc;
2449         u32 num_units = 0;
2450         u32 i, k;
2451 
2452         dirty->dev_priv = dev_priv;
2453 
2454         /* If crtc is passed, no need to iterate over other display units */
2455         if (dirty->crtc) {
2456                 units[num_units++] = vmw_crtc_to_du(dirty->crtc);
2457         } else {
2458                 list_for_each_entry(crtc, &dev_priv->dev->mode_config.crtc_list,
2459                                     head) {
2460                         struct drm_plane *plane = crtc->primary;
2461 
2462                         if (plane->state->fb == &framebuffer->base)
2463                                 units[num_units++] = vmw_crtc_to_du(crtc);
2464                 }
2465         }
2466 
2467         for (k = 0; k < num_units; k++) {
2468                 struct vmw_display_unit *unit = units[k];
2469                 s32 crtc_x = unit->crtc.x;
2470                 s32 crtc_y = unit->crtc.y;
2471                 s32 crtc_width = unit->crtc.mode.hdisplay;
2472                 s32 crtc_height = unit->crtc.mode.vdisplay;
2473                 const struct drm_clip_rect *clips_ptr = clips;
2474                 const struct drm_vmw_rect *vclips_ptr = vclips;
2475 
2476                 dirty->unit = unit;
2477                 if (dirty->fifo_reserve_size > 0) {
2478                         dirty->cmd = VMW_FIFO_RESERVE(dev_priv,
2479                                                       dirty->fifo_reserve_size);
2480                         if (!dirty->cmd)
2481                                 return -ENOMEM;
2482 
2483                         memset(dirty->cmd, 0, dirty->fifo_reserve_size);
2484                 }
2485                 dirty->num_hits = 0;
2486                 for (i = 0; i < num_clips; i++, clips_ptr += increment,
2487                        vclips_ptr += increment) {
2488                         s32 clip_left;
2489                         s32 clip_top;
2490 
2491                         /*
2492                          * Select clip array type. Note that integer type
2493                          * in @clips is unsigned short, whereas in @vclips
2494                          * it's 32-bit.
2495                          */
2496                         if (clips) {
2497                                 dirty->fb_x = (s32) clips_ptr->x1;
2498                                 dirty->fb_y = (s32) clips_ptr->y1;
2499                                 dirty->unit_x2 = (s32) clips_ptr->x2 + dest_x -
2500                                         crtc_x;
2501                                 dirty->unit_y2 = (s32) clips_ptr->y2 + dest_y -
2502                                         crtc_y;
2503                         } else {
2504                                 dirty->fb_x = vclips_ptr->x;
2505                                 dirty->fb_y = vclips_ptr->y;
2506                                 dirty->unit_x2 = dirty->fb_x + vclips_ptr->w +
2507                                         dest_x - crtc_x;
2508                                 dirty->unit_y2 = dirty->fb_y + vclips_ptr->h +
2509                                         dest_y - crtc_y;
2510                         }
2511 
2512                         dirty->unit_x1 = dirty->fb_x + dest_x - crtc_x;
2513                         dirty->unit_y1 = dirty->fb_y + dest_y - crtc_y;
2514 
2515                         /* Skip this clip if it's outside the crtc region */
2516                         if (dirty->unit_x1 >= crtc_width ||
2517                             dirty->unit_y1 >= crtc_height ||
2518                             dirty->unit_x2 <= 0 || dirty->unit_y2 <= 0)
2519                                 continue;
2520 
2521                         /* Clip right and bottom to crtc limits */
2522                         dirty->unit_x2 = min_t(s32, dirty->unit_x2,
2523                                                crtc_width);
2524                         dirty->unit_y2 = min_t(s32, dirty->unit_y2,
2525                                                crtc_height);
2526 
2527                         /* Clip left and top to crtc limits */
2528                         clip_left = min_t(s32, dirty->unit_x1, 0);
2529                         clip_top = min_t(s32, dirty->unit_y1, 0);
2530                         dirty->unit_x1 -= clip_left;
2531                         dirty->unit_y1 -= clip_top;
2532                         dirty->fb_x -= clip_left;
2533                         dirty->fb_y -= clip_top;
2534 
2535                         dirty->clip(dirty);
2536                 }
2537 
2538                 dirty->fifo_commit(dirty);
2539         }
2540 
2541         return 0;
2542 }
2543 
2544 /**
2545  * vmw_kms_helper_validation_finish - Helper for post KMS command submission
2546  * cleanup and fencing
2547  * @dev_priv: Pointer to the device-private struct
2548  * @file_priv: Pointer identifying the client when user-space fencing is used
2549  * @ctx: Pointer to the validation context
2550  * @out_fence: If non-NULL, returned refcounted fence-pointer
2551  * @user_fence_rep: If non-NULL, pointer to user-space address area
2552  * in which to copy user-space fence info
2553  */
2554 void vmw_kms_helper_validation_finish(struct vmw_private *dev_priv,
2555                                       struct drm_file *file_priv,
2556                                       struct vmw_validation_context *ctx,
2557                                       struct vmw_fence_obj **out_fence,
2558                                       struct drm_vmw_fence_rep __user *
2559                                       user_fence_rep)
2560 {
2561         struct vmw_fence_obj *fence = NULL;
2562         uint32_t handle = 0;
2563         int ret = 0;
2564 
2565         if (file_priv || user_fence_rep || vmw_validation_has_bos(ctx) ||
2566             out_fence)
2567                 ret = vmw_execbuf_fence_commands(file_priv, dev_priv, &fence,
2568                                                  file_priv ? &handle : NULL);
2569         vmw_validation_done(ctx, fence);
2570         if (file_priv)
2571                 vmw_execbuf_copy_fence_user(dev_priv, vmw_fpriv(file_priv),
2572                                             ret, user_fence_rep, fence,
2573                                             handle, -1, NULL);
2574         if (out_fence)
2575                 *out_fence = fence;
2576         else
2577                 vmw_fence_obj_unreference(&fence);
2578 }
2579 
2580 /**
2581  * vmw_kms_update_proxy - Helper function to update a proxy surface from
2582  * its backing MOB.
2583  *
2584  * @res: Pointer to the surface resource
2585  * @clips: Clip rects in framebuffer (surface) space.
2586  * @num_clips: Number of clips in @clips.
2587  * @increment: Integer with which to increment the clip counter when looping.
2588  * Used to skip a predetermined number of clip rects.
2589  *
2590  * This function makes sure the proxy surface is updated from its backing MOB
2591  * using the region given by @clips. The surface resource @res and its backing
2592  * MOB needs to be reserved and validated on call.
2593  */
2594 int vmw_kms_update_proxy(struct vmw_resource *res,
2595                          const struct drm_clip_rect *clips,
2596                          unsigned num_clips,
2597                          int increment)
2598 {
2599         struct vmw_private *dev_priv = res->dev_priv;
2600         struct drm_vmw_size *size = &vmw_res_to_srf(res)->base_size;
2601         struct {
2602                 SVGA3dCmdHeader header;
2603                 SVGA3dCmdUpdateGBImage body;
2604         } *cmd;
2605         SVGA3dBox *box;
2606         size_t copy_size = 0;
2607         int i;
2608 
2609         if (!clips)
2610                 return 0;
2611 
2612         cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd) * num_clips);
2613         if (!cmd)
2614                 return -ENOMEM;
2615 
2616         for (i = 0; i < num_clips; ++i, clips += increment, ++cmd) {
2617                 box = &cmd->body.box;
2618 
2619                 cmd->header.id = SVGA_3D_CMD_UPDATE_GB_IMAGE;
2620                 cmd->header.size = sizeof(cmd->body);
2621                 cmd->body.image.sid = res->id;
2622                 cmd->body.image.face = 0;
2623                 cmd->body.image.mipmap = 0;
2624 
2625                 if (clips->x1 > size->width || clips->x2 > size->width ||
2626                     clips->y1 > size->height || clips->y2 > size->height) {
2627                         DRM_ERROR("Invalid clips outsize of framebuffer.\n");
2628                         return -EINVAL;
2629                 }
2630 
2631                 box->x = clips->x1;
2632                 box->y = clips->y1;
2633                 box->z = 0;
2634                 box->w = clips->x2 - clips->x1;
2635                 box->h = clips->y2 - clips->y1;
2636                 box->d = 1;
2637 
2638                 copy_size += sizeof(*cmd);
2639         }
2640 
2641         vmw_fifo_commit(dev_priv, copy_size);
2642 
2643         return 0;
2644 }
2645 
2646 int vmw_kms_fbdev_init_data(struct vmw_private *dev_priv,
2647                             unsigned unit,
2648                             u32 max_width,
2649                             u32 max_height,
2650                             struct drm_connector **p_con,
2651                             struct drm_crtc **p_crtc,
2652                             struct drm_display_mode **p_mode)
2653 {
2654         struct drm_connector *con;
2655         struct vmw_display_unit *du;
2656         struct drm_display_mode *mode;
2657         int i = 0;
2658         int ret = 0;
2659 
2660         mutex_lock(&dev_priv->dev->mode_config.mutex);
2661         list_for_each_entry(con, &dev_priv->dev->mode_config.connector_list,
2662                             head) {
2663                 if (i == unit)
2664                         break;
2665 
2666                 ++i;
2667         }
2668 
2669         if (i != unit) {
2670                 DRM_ERROR("Could not find initial display unit.\n");
2671                 ret = -EINVAL;
2672                 goto out_unlock;
2673         }
2674 
2675         if (list_empty(&con->modes))
2676                 (void) vmw_du_connector_fill_modes(con, max_width, max_height);
2677 
2678         if (list_empty(&con->modes)) {
2679                 DRM_ERROR("Could not find initial display mode.\n");
2680                 ret = -EINVAL;
2681                 goto out_unlock;
2682         }
2683 
2684         du = vmw_connector_to_du(con);
2685         *p_con = con;
2686         *p_crtc = &du->crtc;
2687 
2688         list_for_each_entry(mode, &con->modes, head) {
2689                 if (mode->type & DRM_MODE_TYPE_PREFERRED)
2690                         break;
2691         }
2692 
2693         if (mode->type & DRM_MODE_TYPE_PREFERRED)
2694                 *p_mode = mode;
2695         else {
2696                 WARN_ONCE(true, "Could not find initial preferred mode.\n");
2697                 *p_mode = list_first_entry(&con->modes,
2698                                            struct drm_display_mode,
2699                                            head);
2700         }
2701 
2702  out_unlock:
2703         mutex_unlock(&dev_priv->dev->mode_config.mutex);
2704 
2705         return ret;
2706 }
2707 
2708 /**
2709  * vmw_kms_create_implicit_placement_proparty - Set up the implicit placement
2710  * property.
2711  *
2712  * @dev_priv: Pointer to a device private struct.
2713  *
2714  * Sets up the implicit placement property unless it's already set up.
2715  */
2716 void
2717 vmw_kms_create_implicit_placement_property(struct vmw_private *dev_priv)
2718 {
2719         if (dev_priv->implicit_placement_property)
2720                 return;
2721 
2722         dev_priv->implicit_placement_property =
2723                 drm_property_create_range(dev_priv->dev,
2724                                           DRM_MODE_PROP_IMMUTABLE,
2725                                           "implicit_placement", 0, 1);
2726 }
2727 
2728 /**
2729  * vmw_kms_suspend - Save modesetting state and turn modesetting off.
2730  *
2731  * @dev: Pointer to the drm device
2732  * Return: 0 on success. Negative error code on failure.
2733  */
2734 int vmw_kms_suspend(struct drm_device *dev)
2735 {
2736         struct vmw_private *dev_priv = vmw_priv(dev);
2737 
2738         dev_priv->suspend_state = drm_atomic_helper_suspend(dev);
2739         if (IS_ERR(dev_priv->suspend_state)) {
2740                 int ret = PTR_ERR(dev_priv->suspend_state);
2741 
2742                 DRM_ERROR("Failed kms suspend: %d\n", ret);
2743                 dev_priv->suspend_state = NULL;
2744 
2745                 return ret;
2746         }
2747 
2748         return 0;
2749 }
2750 
2751 
2752 /**
2753  * vmw_kms_resume - Re-enable modesetting and restore state
2754  *
2755  * @dev: Pointer to the drm device
2756  * Return: 0 on success. Negative error code on failure.
2757  *
2758  * State is resumed from a previous vmw_kms_suspend(). It's illegal
2759  * to call this function without a previous vmw_kms_suspend().
2760  */
2761 int vmw_kms_resume(struct drm_device *dev)
2762 {
2763         struct vmw_private *dev_priv = vmw_priv(dev);
2764         int ret;
2765 
2766         if (WARN_ON(!dev_priv->suspend_state))
2767                 return 0;
2768 
2769         ret = drm_atomic_helper_resume(dev, dev_priv->suspend_state);
2770         dev_priv->suspend_state = NULL;
2771 
2772         return ret;
2773 }
2774 
2775 /**
2776  * vmw_kms_lost_device - Notify kms that modesetting capabilities will be lost
2777  *
2778  * @dev: Pointer to the drm device
2779  */
2780 void vmw_kms_lost_device(struct drm_device *dev)
2781 {
2782         drm_atomic_helper_shutdown(dev);
2783 }
2784 
2785 /**
2786  * vmw_du_helper_plane_update - Helper to do plane update on a display unit.
2787  * @update: The closure structure.
2788  *
2789  * Call this helper after setting callbacks in &vmw_du_update_plane to do plane
2790  * update on display unit.
2791  *
2792  * Return: 0 on success or a negative error code on failure.
2793  */
2794 int vmw_du_helper_plane_update(struct vmw_du_update_plane *update)
2795 {
2796         struct drm_plane_state *state = update->plane->state;
2797         struct drm_plane_state *old_state = update->old_state;
2798         struct drm_atomic_helper_damage_iter iter;
2799         struct drm_rect clip;
2800         struct drm_rect bb;
2801         DECLARE_VAL_CONTEXT(val_ctx, NULL, 0);
2802         uint32_t reserved_size = 0;
2803         uint32_t submit_size = 0;
2804         uint32_t curr_size = 0;
2805         uint32_t num_hits = 0;
2806         void *cmd_start;
2807         char *cmd_next;
2808         int ret;
2809 
2810         /*
2811          * Iterate in advance to check if really need plane update and find the
2812          * number of clips that actually are in plane src for fifo allocation.
2813          */
2814         drm_atomic_helper_damage_iter_init(&iter, old_state, state);
2815         drm_atomic_for_each_plane_damage(&iter, &clip)
2816                 num_hits++;
2817 
2818         if (num_hits == 0)
2819                 return 0;
2820 
2821         if (update->vfb->bo) {
2822                 struct vmw_framebuffer_bo *vfbbo =
2823                         container_of(update->vfb, typeof(*vfbbo), base);
2824 
2825                 ret = vmw_validation_add_bo(&val_ctx, vfbbo->buffer, false,
2826                                             update->cpu_blit);
2827         } else {
2828                 struct vmw_framebuffer_surface *vfbs =
2829                         container_of(update->vfb, typeof(*vfbs), base);
2830 
2831                 ret = vmw_validation_add_resource(&val_ctx, &vfbs->surface->res,
2832                                                   0, VMW_RES_DIRTY_NONE, NULL,
2833                                                   NULL);
2834         }
2835 
2836         if (ret)
2837                 return ret;
2838 
2839         ret = vmw_validation_prepare(&val_ctx, update->mutex, update->intr);
2840         if (ret)
2841                 goto out_unref;
2842 
2843         reserved_size = update->calc_fifo_size(update, num_hits);
2844         cmd_start = VMW_FIFO_RESERVE(update->dev_priv, reserved_size);
2845         if (!cmd_start) {
2846                 ret = -ENOMEM;
2847                 goto out_revert;
2848         }
2849 
2850         cmd_next = cmd_start;
2851 
2852         if (update->post_prepare) {
2853                 curr_size = update->post_prepare(update, cmd_next);
2854                 cmd_next += curr_size;
2855                 submit_size += curr_size;
2856         }
2857 
2858         if (update->pre_clip) {
2859                 curr_size = update->pre_clip(update, cmd_next, num_hits);
2860                 cmd_next += curr_size;
2861                 submit_size += curr_size;
2862         }
2863 
2864         bb.x1 = INT_MAX;
2865         bb.y1 = INT_MAX;
2866         bb.x2 = INT_MIN;
2867         bb.y2 = INT_MIN;
2868 
2869         drm_atomic_helper_damage_iter_init(&iter, old_state, state);
2870         drm_atomic_for_each_plane_damage(&iter, &clip) {
2871                 uint32_t fb_x = clip.x1;
2872                 uint32_t fb_y = clip.y1;
2873 
2874                 vmw_du_translate_to_crtc(state, &clip);
2875                 if (update->clip) {
2876                         curr_size = update->clip(update, cmd_next, &clip, fb_x,
2877                                                  fb_y);
2878                         cmd_next += curr_size;
2879                         submit_size += curr_size;
2880                 }
2881                 bb.x1 = min_t(int, bb.x1, clip.x1);
2882                 bb.y1 = min_t(int, bb.y1, clip.y1);
2883                 bb.x2 = max_t(int, bb.x2, clip.x2);
2884                 bb.y2 = max_t(int, bb.y2, clip.y2);
2885         }
2886 
2887         curr_size = update->post_clip(update, cmd_next, &bb);
2888         submit_size += curr_size;
2889 
2890         if (reserved_size < submit_size)
2891                 submit_size = 0;
2892 
2893         vmw_fifo_commit(update->dev_priv, submit_size);
2894 
2895         vmw_kms_helper_validation_finish(update->dev_priv, NULL, &val_ctx,
2896                                          update->out_fence, NULL);
2897         return ret;
2898 
2899 out_revert:
2900         vmw_validation_revert(&val_ctx);
2901 
2902 out_unref:
2903         vmw_validation_unref_lists(&val_ctx);
2904         return ret;
2905 }
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c

DEFINITIONS
