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