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