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/ttm/ttm_placement.h> 29 30 #include "vmwgfx_drv.h" 31 #include "vmwgfx_resource_priv.h" 32 #include "vmwgfx_binding.h" 33 34 struct vmw_user_context { 35 struct ttm_base_object base; 36 struct vmw_resource res; 37 struct vmw_ctx_binding_state *cbs; 38 struct vmw_cmdbuf_res_manager *man; 39 struct vmw_resource *cotables[SVGA_COTABLE_DX10_MAX]; 40 spinlock_t cotable_lock; 41 struct vmw_buffer_object *dx_query_mob; 42 }; 43 44 static void vmw_user_context_free(struct vmw_resource *res); 45 static struct vmw_resource * 46 vmw_user_context_base_to_res(struct ttm_base_object *base); 47 48 static int vmw_gb_context_create(struct vmw_resource *res); 49 static int vmw_gb_context_bind(struct vmw_resource *res, 50 struct ttm_validate_buffer *val_buf); 51 static int vmw_gb_context_unbind(struct vmw_resource *res, 52 bool readback, 53 struct ttm_validate_buffer *val_buf); 54 static int vmw_gb_context_destroy(struct vmw_resource *res); 55 static int vmw_dx_context_create(struct vmw_resource *res); 56 static int vmw_dx_context_bind(struct vmw_resource *res, 57 struct ttm_validate_buffer *val_buf); 58 static int vmw_dx_context_unbind(struct vmw_resource *res, 59 bool readback, 60 struct ttm_validate_buffer *val_buf); 61 static int vmw_dx_context_destroy(struct vmw_resource *res); 62 63 static uint64_t vmw_user_context_size; 64 65 static const struct vmw_user_resource_conv user_context_conv = { 66 .object_type = VMW_RES_CONTEXT, 67 .base_obj_to_res = vmw_user_context_base_to_res, 68 .res_free = vmw_user_context_free 69 }; 70 71 const struct vmw_user_resource_conv *user_context_converter = 72 &user_context_conv; 73 74 75 static const struct vmw_res_func vmw_legacy_context_func = { 76 .res_type = vmw_res_context, 77 .needs_backup = false, 78 .may_evict = false, 79 .type_name = "legacy contexts", 80 .backup_placement = NULL, 81 .create = NULL, 82 .destroy = NULL, 83 .bind = NULL, 84 .unbind = NULL 85 }; 86 87 static const struct vmw_res_func vmw_gb_context_func = { 88 .res_type = vmw_res_context, 89 .needs_backup = true, 90 .may_evict = true, 91 .type_name = "guest backed contexts", 92 .backup_placement = &vmw_mob_placement, 93 .create = vmw_gb_context_create, 94 .destroy = vmw_gb_context_destroy, 95 .bind = vmw_gb_context_bind, 96 .unbind = vmw_gb_context_unbind 97 }; 98 99 static const struct vmw_res_func vmw_dx_context_func = { 100 .res_type = vmw_res_dx_context, 101 .needs_backup = true, 102 .may_evict = true, 103 .type_name = "dx contexts", 104 .backup_placement = &vmw_mob_placement, 105 .create = vmw_dx_context_create, 106 .destroy = vmw_dx_context_destroy, 107 .bind = vmw_dx_context_bind, 108 .unbind = vmw_dx_context_unbind 109 }; 110 111 /** 112 * Context management: 113 */ 114 115 static void vmw_context_cotables_unref(struct vmw_user_context *uctx) 116 { 117 struct vmw_resource *res; 118 int i; 119 120 for (i = 0; i < SVGA_COTABLE_DX10_MAX; ++i) { 121 spin_lock(&uctx->cotable_lock); 122 res = uctx->cotables[i]; 123 uctx->cotables[i] = NULL; 124 spin_unlock(&uctx->cotable_lock); 125 126 if (res) 127 vmw_resource_unreference(&res); 128 } 129 } 130 131 static void vmw_hw_context_destroy(struct vmw_resource *res) 132 { 133 struct vmw_user_context *uctx = 134 container_of(res, struct vmw_user_context, res); 135 struct vmw_private *dev_priv = res->dev_priv; 136 struct { 137 SVGA3dCmdHeader header; 138 SVGA3dCmdDestroyContext body; 139 } *cmd; 140 141 142 if (res->func->destroy == vmw_gb_context_destroy || 143 res->func->destroy == vmw_dx_context_destroy) { 144 mutex_lock(&dev_priv->cmdbuf_mutex); 145 vmw_cmdbuf_res_man_destroy(uctx->man); 146 mutex_lock(&dev_priv->binding_mutex); 147 vmw_binding_state_kill(uctx->cbs); 148 (void) res->func->destroy(res); 149 mutex_unlock(&dev_priv->binding_mutex); 150 if (dev_priv->pinned_bo != NULL && 151 !dev_priv->query_cid_valid) 152 __vmw_execbuf_release_pinned_bo(dev_priv, NULL); 153 mutex_unlock(&dev_priv->cmdbuf_mutex); 154 vmw_context_cotables_unref(uctx); 155 return; 156 } 157 158 vmw_execbuf_release_pinned_bo(dev_priv); 159 cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd)); 160 if (unlikely(cmd == NULL)) 161 return; 162 163 cmd->header.id = SVGA_3D_CMD_CONTEXT_DESTROY; 164 cmd->header.size = sizeof(cmd->body); 165 cmd->body.cid = res->id; 166 167 vmw_fifo_commit(dev_priv, sizeof(*cmd)); 168 vmw_fifo_resource_dec(dev_priv); 169 } 170 171 static int vmw_gb_context_init(struct vmw_private *dev_priv, 172 bool dx, 173 struct vmw_resource *res, 174 void (*res_free)(struct vmw_resource *res)) 175 { 176 int ret, i; 177 struct vmw_user_context *uctx = 178 container_of(res, struct vmw_user_context, res); 179 180 res->backup_size = (dx ? sizeof(SVGADXContextMobFormat) : 181 SVGA3D_CONTEXT_DATA_SIZE); 182 ret = vmw_resource_init(dev_priv, res, true, 183 res_free, 184 dx ? &vmw_dx_context_func : 185 &vmw_gb_context_func); 186 if (unlikely(ret != 0)) 187 goto out_err; 188 189 if (dev_priv->has_mob) { 190 uctx->man = vmw_cmdbuf_res_man_create(dev_priv); 191 if (IS_ERR(uctx->man)) { 192 ret = PTR_ERR(uctx->man); 193 uctx->man = NULL; 194 goto out_err; 195 } 196 } 197 198 uctx->cbs = vmw_binding_state_alloc(dev_priv); 199 if (IS_ERR(uctx->cbs)) { 200 ret = PTR_ERR(uctx->cbs); 201 goto out_err; 202 } 203 204 spin_lock_init(&uctx->cotable_lock); 205 206 if (dx) { 207 for (i = 0; i < SVGA_COTABLE_DX10_MAX; ++i) { 208 uctx->cotables[i] = vmw_cotable_alloc(dev_priv, 209 &uctx->res, i); 210 if (IS_ERR(uctx->cotables[i])) { 211 ret = PTR_ERR(uctx->cotables[i]); 212 goto out_cotables; 213 } 214 } 215 } 216 217 res->hw_destroy = vmw_hw_context_destroy; 218 return 0; 219 220 out_cotables: 221 vmw_context_cotables_unref(uctx); 222 out_err: 223 if (res_free) 224 res_free(res); 225 else 226 kfree(res); 227 return ret; 228 } 229 230 static int vmw_context_init(struct vmw_private *dev_priv, 231 struct vmw_resource *res, 232 void (*res_free)(struct vmw_resource *res), 233 bool dx) 234 { 235 int ret; 236 237 struct { 238 SVGA3dCmdHeader header; 239 SVGA3dCmdDefineContext body; 240 } *cmd; 241 242 if (dev_priv->has_mob) 243 return vmw_gb_context_init(dev_priv, dx, res, res_free); 244 245 ret = vmw_resource_init(dev_priv, res, false, 246 res_free, &vmw_legacy_context_func); 247 248 if (unlikely(ret != 0)) { 249 DRM_ERROR("Failed to allocate a resource id.\n"); 250 goto out_early; 251 } 252 253 if (unlikely(res->id >= SVGA3D_MAX_CONTEXT_IDS)) { 254 DRM_ERROR("Out of hw context ids.\n"); 255 vmw_resource_unreference(&res); 256 return -ENOMEM; 257 } 258 259 cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd)); 260 if (unlikely(cmd == NULL)) { 261 vmw_resource_unreference(&res); 262 return -ENOMEM; 263 } 264 265 cmd->header.id = SVGA_3D_CMD_CONTEXT_DEFINE; 266 cmd->header.size = sizeof(cmd->body); 267 cmd->body.cid = res->id; 268 269 vmw_fifo_commit(dev_priv, sizeof(*cmd)); 270 vmw_fifo_resource_inc(dev_priv); 271 res->hw_destroy = vmw_hw_context_destroy; 272 return 0; 273 274 out_early: 275 if (res_free == NULL) 276 kfree(res); 277 else 278 res_free(res); 279 return ret; 280 } 281 282 283 /* 284 * GB context. 285 */ 286 287 static int vmw_gb_context_create(struct vmw_resource *res) 288 { 289 struct vmw_private *dev_priv = res->dev_priv; 290 int ret; 291 struct { 292 SVGA3dCmdHeader header; 293 SVGA3dCmdDefineGBContext body; 294 } *cmd; 295 296 if (likely(res->id != -1)) 297 return 0; 298 299 ret = vmw_resource_alloc_id(res); 300 if (unlikely(ret != 0)) { 301 DRM_ERROR("Failed to allocate a context id.\n"); 302 goto out_no_id; 303 } 304 305 if (unlikely(res->id >= VMWGFX_NUM_GB_CONTEXT)) { 306 ret = -EBUSY; 307 goto out_no_fifo; 308 } 309 310 cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd)); 311 if (unlikely(cmd == NULL)) { 312 ret = -ENOMEM; 313 goto out_no_fifo; 314 } 315 316 cmd->header.id = SVGA_3D_CMD_DEFINE_GB_CONTEXT; 317 cmd->header.size = sizeof(cmd->body); 318 cmd->body.cid = res->id; 319 vmw_fifo_commit(dev_priv, sizeof(*cmd)); 320 vmw_fifo_resource_inc(dev_priv); 321 322 return 0; 323 324 out_no_fifo: 325 vmw_resource_release_id(res); 326 out_no_id: 327 return ret; 328 } 329 330 static int vmw_gb_context_bind(struct vmw_resource *res, 331 struct ttm_validate_buffer *val_buf) 332 { 333 struct vmw_private *dev_priv = res->dev_priv; 334 struct { 335 SVGA3dCmdHeader header; 336 SVGA3dCmdBindGBContext body; 337 } *cmd; 338 struct ttm_buffer_object *bo = val_buf->bo; 339 340 BUG_ON(bo->mem.mem_type != VMW_PL_MOB); 341 342 cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd)); 343 if (unlikely(cmd == NULL)) 344 return -ENOMEM; 345 346 cmd->header.id = SVGA_3D_CMD_BIND_GB_CONTEXT; 347 cmd->header.size = sizeof(cmd->body); 348 cmd->body.cid = res->id; 349 cmd->body.mobid = bo->mem.start; 350 cmd->body.validContents = res->backup_dirty; 351 res->backup_dirty = false; 352 vmw_fifo_commit(dev_priv, sizeof(*cmd)); 353 354 return 0; 355 } 356 357 static int vmw_gb_context_unbind(struct vmw_resource *res, 358 bool readback, 359 struct ttm_validate_buffer *val_buf) 360 { 361 struct vmw_private *dev_priv = res->dev_priv; 362 struct ttm_buffer_object *bo = val_buf->bo; 363 struct vmw_fence_obj *fence; 364 struct vmw_user_context *uctx = 365 container_of(res, struct vmw_user_context, res); 366 367 struct { 368 SVGA3dCmdHeader header; 369 SVGA3dCmdReadbackGBContext body; 370 } *cmd1; 371 struct { 372 SVGA3dCmdHeader header; 373 SVGA3dCmdBindGBContext body; 374 } *cmd2; 375 uint32_t submit_size; 376 uint8_t *cmd; 377 378 379 BUG_ON(bo->mem.mem_type != VMW_PL_MOB); 380 381 mutex_lock(&dev_priv->binding_mutex); 382 vmw_binding_state_scrub(uctx->cbs); 383 384 submit_size = sizeof(*cmd2) + (readback ? sizeof(*cmd1) : 0); 385 386 cmd = VMW_FIFO_RESERVE(dev_priv, submit_size); 387 if (unlikely(cmd == NULL)) { 388 mutex_unlock(&dev_priv->binding_mutex); 389 return -ENOMEM; 390 } 391 392 cmd2 = (void *) cmd; 393 if (readback) { 394 cmd1 = (void *) cmd; 395 cmd1->header.id = SVGA_3D_CMD_READBACK_GB_CONTEXT; 396 cmd1->header.size = sizeof(cmd1->body); 397 cmd1->body.cid = res->id; 398 cmd2 = (void *) (&cmd1[1]); 399 } 400 cmd2->header.id = SVGA_3D_CMD_BIND_GB_CONTEXT; 401 cmd2->header.size = sizeof(cmd2->body); 402 cmd2->body.cid = res->id; 403 cmd2->body.mobid = SVGA3D_INVALID_ID; 404 405 vmw_fifo_commit(dev_priv, submit_size); 406 mutex_unlock(&dev_priv->binding_mutex); 407 408 /* 409 * Create a fence object and fence the backup buffer. 410 */ 411 412 (void) vmw_execbuf_fence_commands(NULL, dev_priv, 413 &fence, NULL); 414 415 vmw_bo_fence_single(bo, fence); 416 417 if (likely(fence != NULL)) 418 vmw_fence_obj_unreference(&fence); 419 420 return 0; 421 } 422 423 static int vmw_gb_context_destroy(struct vmw_resource *res) 424 { 425 struct vmw_private *dev_priv = res->dev_priv; 426 struct { 427 SVGA3dCmdHeader header; 428 SVGA3dCmdDestroyGBContext body; 429 } *cmd; 430 431 if (likely(res->id == -1)) 432 return 0; 433 434 cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd)); 435 if (unlikely(cmd == NULL)) 436 return -ENOMEM; 437 438 cmd->header.id = SVGA_3D_CMD_DESTROY_GB_CONTEXT; 439 cmd->header.size = sizeof(cmd->body); 440 cmd->body.cid = res->id; 441 vmw_fifo_commit(dev_priv, sizeof(*cmd)); 442 if (dev_priv->query_cid == res->id) 443 dev_priv->query_cid_valid = false; 444 vmw_resource_release_id(res); 445 vmw_fifo_resource_dec(dev_priv); 446 447 return 0; 448 } 449 450 /* 451 * DX context. 452 */ 453 454 static int vmw_dx_context_create(struct vmw_resource *res) 455 { 456 struct vmw_private *dev_priv = res->dev_priv; 457 int ret; 458 struct { 459 SVGA3dCmdHeader header; 460 SVGA3dCmdDXDefineContext body; 461 } *cmd; 462 463 if (likely(res->id != -1)) 464 return 0; 465 466 ret = vmw_resource_alloc_id(res); 467 if (unlikely(ret != 0)) { 468 DRM_ERROR("Failed to allocate a context id.\n"); 469 goto out_no_id; 470 } 471 472 if (unlikely(res->id >= VMWGFX_NUM_DXCONTEXT)) { 473 ret = -EBUSY; 474 goto out_no_fifo; 475 } 476 477 cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd)); 478 if (unlikely(cmd == NULL)) { 479 ret = -ENOMEM; 480 goto out_no_fifo; 481 } 482 483 cmd->header.id = SVGA_3D_CMD_DX_DEFINE_CONTEXT; 484 cmd->header.size = sizeof(cmd->body); 485 cmd->body.cid = res->id; 486 vmw_fifo_commit(dev_priv, sizeof(*cmd)); 487 vmw_fifo_resource_inc(dev_priv); 488 489 return 0; 490 491 out_no_fifo: 492 vmw_resource_release_id(res); 493 out_no_id: 494 return ret; 495 } 496 497 static int vmw_dx_context_bind(struct vmw_resource *res, 498 struct ttm_validate_buffer *val_buf) 499 { 500 struct vmw_private *dev_priv = res->dev_priv; 501 struct { 502 SVGA3dCmdHeader header; 503 SVGA3dCmdDXBindContext body; 504 } *cmd; 505 struct ttm_buffer_object *bo = val_buf->bo; 506 507 BUG_ON(bo->mem.mem_type != VMW_PL_MOB); 508 509 cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd)); 510 if (unlikely(cmd == NULL)) 511 return -ENOMEM; 512 513 cmd->header.id = SVGA_3D_CMD_DX_BIND_CONTEXT; 514 cmd->header.size = sizeof(cmd->body); 515 cmd->body.cid = res->id; 516 cmd->body.mobid = bo->mem.start; 517 cmd->body.validContents = res->backup_dirty; 518 res->backup_dirty = false; 519 vmw_fifo_commit(dev_priv, sizeof(*cmd)); 520 521 522 return 0; 523 } 524 525 /** 526 * vmw_dx_context_scrub_cotables - Scrub all bindings and 527 * cotables from a context 528 * 529 * @ctx: Pointer to the context resource 530 * @readback: Whether to save the otable contents on scrubbing. 531 * 532 * COtables must be unbound before their context, but unbinding requires 533 * the backup buffer being reserved, whereas scrubbing does not. 534 * This function scrubs all cotables of a context, potentially reading back 535 * the contents into their backup buffers. However, scrubbing cotables 536 * also makes the device context invalid, so scrub all bindings first so 537 * that doesn't have to be done later with an invalid context. 538 */ 539 void vmw_dx_context_scrub_cotables(struct vmw_resource *ctx, 540 bool readback) 541 { 542 struct vmw_user_context *uctx = 543 container_of(ctx, struct vmw_user_context, res); 544 int i; 545 546 vmw_binding_state_scrub(uctx->cbs); 547 for (i = 0; i < SVGA_COTABLE_DX10_MAX; ++i) { 548 struct vmw_resource *res; 549 550 /* Avoid racing with ongoing cotable destruction. */ 551 spin_lock(&uctx->cotable_lock); 552 res = uctx->cotables[vmw_cotable_scrub_order[i]]; 553 if (res) 554 res = vmw_resource_reference_unless_doomed(res); 555 spin_unlock(&uctx->cotable_lock); 556 if (!res) 557 continue; 558 559 WARN_ON(vmw_cotable_scrub(res, readback)); 560 vmw_resource_unreference(&res); 561 } 562 } 563 564 static int vmw_dx_context_unbind(struct vmw_resource *res, 565 bool readback, 566 struct ttm_validate_buffer *val_buf) 567 { 568 struct vmw_private *dev_priv = res->dev_priv; 569 struct ttm_buffer_object *bo = val_buf->bo; 570 struct vmw_fence_obj *fence; 571 struct vmw_user_context *uctx = 572 container_of(res, struct vmw_user_context, res); 573 574 struct { 575 SVGA3dCmdHeader header; 576 SVGA3dCmdDXReadbackContext body; 577 } *cmd1; 578 struct { 579 SVGA3dCmdHeader header; 580 SVGA3dCmdDXBindContext body; 581 } *cmd2; 582 uint32_t submit_size; 583 uint8_t *cmd; 584 585 586 BUG_ON(bo->mem.mem_type != VMW_PL_MOB); 587 588 mutex_lock(&dev_priv->binding_mutex); 589 vmw_dx_context_scrub_cotables(res, readback); 590 591 if (uctx->dx_query_mob && uctx->dx_query_mob->dx_query_ctx && 592 readback) { 593 WARN_ON(uctx->dx_query_mob->dx_query_ctx != res); 594 if (vmw_query_readback_all(uctx->dx_query_mob)) 595 DRM_ERROR("Failed to read back query states\n"); 596 } 597 598 submit_size = sizeof(*cmd2) + (readback ? sizeof(*cmd1) : 0); 599 600 cmd = VMW_FIFO_RESERVE(dev_priv, submit_size); 601 if (unlikely(cmd == NULL)) { 602 mutex_unlock(&dev_priv->binding_mutex); 603 return -ENOMEM; 604 } 605 606 cmd2 = (void *) cmd; 607 if (readback) { 608 cmd1 = (void *) cmd; 609 cmd1->header.id = SVGA_3D_CMD_DX_READBACK_CONTEXT; 610 cmd1->header.size = sizeof(cmd1->body); 611 cmd1->body.cid = res->id; 612 cmd2 = (void *) (&cmd1[1]); 613 } 614 cmd2->header.id = SVGA_3D_CMD_DX_BIND_CONTEXT; 615 cmd2->header.size = sizeof(cmd2->body); 616 cmd2->body.cid = res->id; 617 cmd2->body.mobid = SVGA3D_INVALID_ID; 618 619 vmw_fifo_commit(dev_priv, submit_size); 620 mutex_unlock(&dev_priv->binding_mutex); 621 622 /* 623 * Create a fence object and fence the backup buffer. 624 */ 625 626 (void) vmw_execbuf_fence_commands(NULL, dev_priv, 627 &fence, NULL); 628 629 vmw_bo_fence_single(bo, fence); 630 631 if (likely(fence != NULL)) 632 vmw_fence_obj_unreference(&fence); 633 634 return 0; 635 } 636 637 static int vmw_dx_context_destroy(struct vmw_resource *res) 638 { 639 struct vmw_private *dev_priv = res->dev_priv; 640 struct { 641 SVGA3dCmdHeader header; 642 SVGA3dCmdDXDestroyContext body; 643 } *cmd; 644 645 if (likely(res->id == -1)) 646 return 0; 647 648 cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd)); 649 if (unlikely(cmd == NULL)) 650 return -ENOMEM; 651 652 cmd->header.id = SVGA_3D_CMD_DX_DESTROY_CONTEXT; 653 cmd->header.size = sizeof(cmd->body); 654 cmd->body.cid = res->id; 655 vmw_fifo_commit(dev_priv, sizeof(*cmd)); 656 if (dev_priv->query_cid == res->id) 657 dev_priv->query_cid_valid = false; 658 vmw_resource_release_id(res); 659 vmw_fifo_resource_dec(dev_priv); 660 661 return 0; 662 } 663 664 /** 665 * User-space context management: 666 */ 667 668 static struct vmw_resource * 669 vmw_user_context_base_to_res(struct ttm_base_object *base) 670 { 671 return &(container_of(base, struct vmw_user_context, base)->res); 672 } 673 674 static void vmw_user_context_free(struct vmw_resource *res) 675 { 676 struct vmw_user_context *ctx = 677 container_of(res, struct vmw_user_context, res); 678 struct vmw_private *dev_priv = res->dev_priv; 679 680 if (ctx->cbs) 681 vmw_binding_state_free(ctx->cbs); 682 683 (void) vmw_context_bind_dx_query(res, NULL); 684 685 ttm_base_object_kfree(ctx, base); 686 ttm_mem_global_free(vmw_mem_glob(dev_priv), 687 vmw_user_context_size); 688 } 689 690 /** 691 * This function is called when user space has no more references on the 692 * base object. It releases the base-object's reference on the resource object. 693 */ 694 695 static void vmw_user_context_base_release(struct ttm_base_object **p_base) 696 { 697 struct ttm_base_object *base = *p_base; 698 struct vmw_user_context *ctx = 699 container_of(base, struct vmw_user_context, base); 700 struct vmw_resource *res = &ctx->res; 701 702 *p_base = NULL; 703 vmw_resource_unreference(&res); 704 } 705 706 int vmw_context_destroy_ioctl(struct drm_device *dev, void *data, 707 struct drm_file *file_priv) 708 { 709 struct drm_vmw_context_arg *arg = (struct drm_vmw_context_arg *)data; 710 struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile; 711 712 return ttm_ref_object_base_unref(tfile, arg->cid, TTM_REF_USAGE); 713 } 714 715 static int vmw_context_define(struct drm_device *dev, void *data, 716 struct drm_file *file_priv, bool dx) 717 { 718 struct vmw_private *dev_priv = vmw_priv(dev); 719 struct vmw_user_context *ctx; 720 struct vmw_resource *res; 721 struct vmw_resource *tmp; 722 struct drm_vmw_context_arg *arg = (struct drm_vmw_context_arg *)data; 723 struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile; 724 struct ttm_operation_ctx ttm_opt_ctx = { 725 .interruptible = true, 726 .no_wait_gpu = false 727 }; 728 int ret; 729 730 if (!dev_priv->has_dx && dx) { 731 VMW_DEBUG_USER("DX contexts not supported by device.\n"); 732 return -EINVAL; 733 } 734 735 if (unlikely(vmw_user_context_size == 0)) 736 vmw_user_context_size = ttm_round_pot(sizeof(*ctx)) + 737 ((dev_priv->has_mob) ? vmw_cmdbuf_res_man_size() : 0) + 738 + VMW_IDA_ACC_SIZE + TTM_OBJ_EXTRA_SIZE; 739 740 ret = ttm_read_lock(&dev_priv->reservation_sem, true); 741 if (unlikely(ret != 0)) 742 return ret; 743 744 ret = ttm_mem_global_alloc(vmw_mem_glob(dev_priv), 745 vmw_user_context_size, 746 &ttm_opt_ctx); 747 if (unlikely(ret != 0)) { 748 if (ret != -ERESTARTSYS) 749 DRM_ERROR("Out of graphics memory for context" 750 " creation.\n"); 751 goto out_unlock; 752 } 753 754 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); 755 if (unlikely(!ctx)) { 756 ttm_mem_global_free(vmw_mem_glob(dev_priv), 757 vmw_user_context_size); 758 ret = -ENOMEM; 759 goto out_unlock; 760 } 761 762 res = &ctx->res; 763 ctx->base.shareable = false; 764 ctx->base.tfile = NULL; 765 766 /* 767 * From here on, the destructor takes over resource freeing. 768 */ 769 770 ret = vmw_context_init(dev_priv, res, vmw_user_context_free, dx); 771 if (unlikely(ret != 0)) 772 goto out_unlock; 773 774 tmp = vmw_resource_reference(&ctx->res); 775 ret = ttm_base_object_init(tfile, &ctx->base, false, VMW_RES_CONTEXT, 776 &vmw_user_context_base_release, NULL); 777 778 if (unlikely(ret != 0)) { 779 vmw_resource_unreference(&tmp); 780 goto out_err; 781 } 782 783 arg->cid = ctx->base.handle; 784 out_err: 785 vmw_resource_unreference(&res); 786 out_unlock: 787 ttm_read_unlock(&dev_priv->reservation_sem); 788 return ret; 789 } 790 791 int vmw_context_define_ioctl(struct drm_device *dev, void *data, 792 struct drm_file *file_priv) 793 { 794 return vmw_context_define(dev, data, file_priv, false); 795 } 796 797 int vmw_extended_context_define_ioctl(struct drm_device *dev, void *data, 798 struct drm_file *file_priv) 799 { 800 union drm_vmw_extended_context_arg *arg = (typeof(arg)) data; 801 struct drm_vmw_context_arg *rep = &arg->rep; 802 803 switch (arg->req) { 804 case drm_vmw_context_legacy: 805 return vmw_context_define(dev, rep, file_priv, false); 806 case drm_vmw_context_dx: 807 return vmw_context_define(dev, rep, file_priv, true); 808 default: 809 break; 810 } 811 return -EINVAL; 812 } 813 814 /** 815 * vmw_context_binding_list - Return a list of context bindings 816 * 817 * @ctx: The context resource 818 * 819 * Returns the current list of bindings of the given context. Note that 820 * this list becomes stale as soon as the dev_priv::binding_mutex is unlocked. 821 */ 822 struct list_head *vmw_context_binding_list(struct vmw_resource *ctx) 823 { 824 struct vmw_user_context *uctx = 825 container_of(ctx, struct vmw_user_context, res); 826 827 return vmw_binding_state_list(uctx->cbs); 828 } 829 830 struct vmw_cmdbuf_res_manager *vmw_context_res_man(struct vmw_resource *ctx) 831 { 832 return container_of(ctx, struct vmw_user_context, res)->man; 833 } 834 835 struct vmw_resource *vmw_context_cotable(struct vmw_resource *ctx, 836 SVGACOTableType cotable_type) 837 { 838 if (cotable_type >= SVGA_COTABLE_DX10_MAX) 839 return ERR_PTR(-EINVAL); 840 841 return container_of(ctx, struct vmw_user_context, res)-> 842 cotables[cotable_type]; 843 } 844 845 /** 846 * vmw_context_binding_state - 847 * Return a pointer to a context binding state structure 848 * 849 * @ctx: The context resource 850 * 851 * Returns the current state of bindings of the given context. Note that 852 * this state becomes stale as soon as the dev_priv::binding_mutex is unlocked. 853 */ 854 struct vmw_ctx_binding_state * 855 vmw_context_binding_state(struct vmw_resource *ctx) 856 { 857 return container_of(ctx, struct vmw_user_context, res)->cbs; 858 } 859 860 /** 861 * vmw_context_bind_dx_query - 862 * Sets query MOB for the context. If @mob is NULL, then this function will 863 * remove the association between the MOB and the context. This function 864 * assumes the binding_mutex is held. 865 * 866 * @ctx_res: The context resource 867 * @mob: a reference to the query MOB 868 * 869 * Returns -EINVAL if a MOB has already been set and does not match the one 870 * specified in the parameter. 0 otherwise. 871 */ 872 int vmw_context_bind_dx_query(struct vmw_resource *ctx_res, 873 struct vmw_buffer_object *mob) 874 { 875 struct vmw_user_context *uctx = 876 container_of(ctx_res, struct vmw_user_context, res); 877 878 if (mob == NULL) { 879 if (uctx->dx_query_mob) { 880 uctx->dx_query_mob->dx_query_ctx = NULL; 881 vmw_bo_unreference(&uctx->dx_query_mob); 882 uctx->dx_query_mob = NULL; 883 } 884 885 return 0; 886 } 887 888 /* Can only have one MOB per context for queries */ 889 if (uctx->dx_query_mob && uctx->dx_query_mob != mob) 890 return -EINVAL; 891 892 mob->dx_query_ctx = ctx_res; 893 894 if (!uctx->dx_query_mob) 895 uctx->dx_query_mob = vmw_bo_reference(mob); 896 897 return 0; 898 } 899 900 /** 901 * vmw_context_get_dx_query_mob - Returns non-counted reference to DX query mob 902 * 903 * @ctx_res: The context resource 904 */ 905 struct vmw_buffer_object * 906 vmw_context_get_dx_query_mob(struct vmw_resource *ctx_res) 907 { 908 struct vmw_user_context *uctx = 909 container_of(ctx_res, struct vmw_user_context, res); 910 911 return uctx->dx_query_mob; 912 } 913