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_shader { 35 struct vmw_resource res; 36 SVGA3dShaderType type; 37 uint32_t size; 38 uint8_t num_input_sig; 39 uint8_t num_output_sig; 40 }; 41 42 struct vmw_user_shader { 43 struct ttm_base_object base; 44 struct vmw_shader shader; 45 }; 46 47 struct vmw_dx_shader { 48 struct vmw_resource res; 49 struct vmw_resource *ctx; 50 struct vmw_resource *cotable; 51 u32 id; 52 bool committed; 53 struct list_head cotable_head; 54 }; 55 56 static uint64_t vmw_user_shader_size; 57 static uint64_t vmw_shader_size; 58 static size_t vmw_shader_dx_size; 59 60 static void vmw_user_shader_free(struct vmw_resource *res); 61 static struct vmw_resource * 62 vmw_user_shader_base_to_res(struct ttm_base_object *base); 63 64 static int vmw_gb_shader_create(struct vmw_resource *res); 65 static int vmw_gb_shader_bind(struct vmw_resource *res, 66 struct ttm_validate_buffer *val_buf); 67 static int vmw_gb_shader_unbind(struct vmw_resource *res, 68 bool readback, 69 struct ttm_validate_buffer *val_buf); 70 static int vmw_gb_shader_destroy(struct vmw_resource *res); 71 72 static int vmw_dx_shader_create(struct vmw_resource *res); 73 static int vmw_dx_shader_bind(struct vmw_resource *res, 74 struct ttm_validate_buffer *val_buf); 75 static int vmw_dx_shader_unbind(struct vmw_resource *res, 76 bool readback, 77 struct ttm_validate_buffer *val_buf); 78 static void vmw_dx_shader_commit_notify(struct vmw_resource *res, 79 enum vmw_cmdbuf_res_state state); 80 static bool vmw_shader_id_ok(u32 user_key, SVGA3dShaderType shader_type); 81 static u32 vmw_shader_key(u32 user_key, SVGA3dShaderType shader_type); 82 static uint64_t vmw_user_shader_size; 83 84 static const struct vmw_user_resource_conv user_shader_conv = { 85 .object_type = VMW_RES_SHADER, 86 .base_obj_to_res = vmw_user_shader_base_to_res, 87 .res_free = vmw_user_shader_free 88 }; 89 90 const struct vmw_user_resource_conv *user_shader_converter = 91 &user_shader_conv; 92 93 94 static const struct vmw_res_func vmw_gb_shader_func = { 95 .res_type = vmw_res_shader, 96 .needs_backup = true, 97 .may_evict = true, 98 .type_name = "guest backed shaders", 99 .backup_placement = &vmw_mob_placement, 100 .create = vmw_gb_shader_create, 101 .destroy = vmw_gb_shader_destroy, 102 .bind = vmw_gb_shader_bind, 103 .unbind = vmw_gb_shader_unbind 104 }; 105 106 static const struct vmw_res_func vmw_dx_shader_func = { 107 .res_type = vmw_res_shader, 108 .needs_backup = true, 109 .may_evict = false, 110 .type_name = "dx shaders", 111 .backup_placement = &vmw_mob_placement, 112 .create = vmw_dx_shader_create, 113 /* 114 * The destroy callback is only called with a committed resource on 115 * context destroy, in which case we destroy the cotable anyway, 116 * so there's no need to destroy DX shaders separately. 117 */ 118 .destroy = NULL, 119 .bind = vmw_dx_shader_bind, 120 .unbind = vmw_dx_shader_unbind, 121 .commit_notify = vmw_dx_shader_commit_notify, 122 }; 123 124 /** 125 * Shader management: 126 */ 127 128 static inline struct vmw_shader * 129 vmw_res_to_shader(struct vmw_resource *res) 130 { 131 return container_of(res, struct vmw_shader, res); 132 } 133 134 /** 135 * vmw_res_to_dx_shader - typecast a struct vmw_resource to a 136 * struct vmw_dx_shader 137 * 138 * @res: Pointer to the struct vmw_resource. 139 */ 140 static inline struct vmw_dx_shader * 141 vmw_res_to_dx_shader(struct vmw_resource *res) 142 { 143 return container_of(res, struct vmw_dx_shader, res); 144 } 145 146 static void vmw_hw_shader_destroy(struct vmw_resource *res) 147 { 148 if (likely(res->func->destroy)) 149 (void) res->func->destroy(res); 150 else 151 res->id = -1; 152 } 153 154 155 static int vmw_gb_shader_init(struct vmw_private *dev_priv, 156 struct vmw_resource *res, 157 uint32_t size, 158 uint64_t offset, 159 SVGA3dShaderType type, 160 uint8_t num_input_sig, 161 uint8_t num_output_sig, 162 struct vmw_buffer_object *byte_code, 163 void (*res_free) (struct vmw_resource *res)) 164 { 165 struct vmw_shader *shader = vmw_res_to_shader(res); 166 int ret; 167 168 ret = vmw_resource_init(dev_priv, res, true, res_free, 169 &vmw_gb_shader_func); 170 171 if (unlikely(ret != 0)) { 172 if (res_free) 173 res_free(res); 174 else 175 kfree(res); 176 return ret; 177 } 178 179 res->backup_size = size; 180 if (byte_code) { 181 res->backup = vmw_bo_reference(byte_code); 182 res->backup_offset = offset; 183 } 184 shader->size = size; 185 shader->type = type; 186 shader->num_input_sig = num_input_sig; 187 shader->num_output_sig = num_output_sig; 188 189 res->hw_destroy = vmw_hw_shader_destroy; 190 return 0; 191 } 192 193 /* 194 * GB shader code: 195 */ 196 197 static int vmw_gb_shader_create(struct vmw_resource *res) 198 { 199 struct vmw_private *dev_priv = res->dev_priv; 200 struct vmw_shader *shader = vmw_res_to_shader(res); 201 int ret; 202 struct { 203 SVGA3dCmdHeader header; 204 SVGA3dCmdDefineGBShader body; 205 } *cmd; 206 207 if (likely(res->id != -1)) 208 return 0; 209 210 ret = vmw_resource_alloc_id(res); 211 if (unlikely(ret != 0)) { 212 DRM_ERROR("Failed to allocate a shader id.\n"); 213 goto out_no_id; 214 } 215 216 if (unlikely(res->id >= VMWGFX_NUM_GB_SHADER)) { 217 ret = -EBUSY; 218 goto out_no_fifo; 219 } 220 221 cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd)); 222 if (unlikely(cmd == NULL)) { 223 DRM_ERROR("Failed reserving FIFO space for shader " 224 "creation.\n"); 225 ret = -ENOMEM; 226 goto out_no_fifo; 227 } 228 229 cmd->header.id = SVGA_3D_CMD_DEFINE_GB_SHADER; 230 cmd->header.size = sizeof(cmd->body); 231 cmd->body.shid = res->id; 232 cmd->body.type = shader->type; 233 cmd->body.sizeInBytes = shader->size; 234 vmw_fifo_commit(dev_priv, sizeof(*cmd)); 235 vmw_fifo_resource_inc(dev_priv); 236 237 return 0; 238 239 out_no_fifo: 240 vmw_resource_release_id(res); 241 out_no_id: 242 return ret; 243 } 244 245 static int vmw_gb_shader_bind(struct vmw_resource *res, 246 struct ttm_validate_buffer *val_buf) 247 { 248 struct vmw_private *dev_priv = res->dev_priv; 249 struct { 250 SVGA3dCmdHeader header; 251 SVGA3dCmdBindGBShader body; 252 } *cmd; 253 struct ttm_buffer_object *bo = val_buf->bo; 254 255 BUG_ON(bo->mem.mem_type != VMW_PL_MOB); 256 257 cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd)); 258 if (unlikely(cmd == NULL)) { 259 DRM_ERROR("Failed reserving FIFO space for shader " 260 "binding.\n"); 261 return -ENOMEM; 262 } 263 264 cmd->header.id = SVGA_3D_CMD_BIND_GB_SHADER; 265 cmd->header.size = sizeof(cmd->body); 266 cmd->body.shid = res->id; 267 cmd->body.mobid = bo->mem.start; 268 cmd->body.offsetInBytes = res->backup_offset; 269 res->backup_dirty = false; 270 vmw_fifo_commit(dev_priv, sizeof(*cmd)); 271 272 return 0; 273 } 274 275 static int vmw_gb_shader_unbind(struct vmw_resource *res, 276 bool readback, 277 struct ttm_validate_buffer *val_buf) 278 { 279 struct vmw_private *dev_priv = res->dev_priv; 280 struct { 281 SVGA3dCmdHeader header; 282 SVGA3dCmdBindGBShader body; 283 } *cmd; 284 struct vmw_fence_obj *fence; 285 286 BUG_ON(res->backup->base.mem.mem_type != VMW_PL_MOB); 287 288 cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd)); 289 if (unlikely(cmd == NULL)) { 290 DRM_ERROR("Failed reserving FIFO space for shader " 291 "unbinding.\n"); 292 return -ENOMEM; 293 } 294 295 cmd->header.id = SVGA_3D_CMD_BIND_GB_SHADER; 296 cmd->header.size = sizeof(cmd->body); 297 cmd->body.shid = res->id; 298 cmd->body.mobid = SVGA3D_INVALID_ID; 299 cmd->body.offsetInBytes = 0; 300 vmw_fifo_commit(dev_priv, sizeof(*cmd)); 301 302 /* 303 * Create a fence object and fence the backup buffer. 304 */ 305 306 (void) vmw_execbuf_fence_commands(NULL, dev_priv, 307 &fence, NULL); 308 309 vmw_bo_fence_single(val_buf->bo, fence); 310 311 if (likely(fence != NULL)) 312 vmw_fence_obj_unreference(&fence); 313 314 return 0; 315 } 316 317 static int vmw_gb_shader_destroy(struct vmw_resource *res) 318 { 319 struct vmw_private *dev_priv = res->dev_priv; 320 struct { 321 SVGA3dCmdHeader header; 322 SVGA3dCmdDestroyGBShader body; 323 } *cmd; 324 325 if (likely(res->id == -1)) 326 return 0; 327 328 mutex_lock(&dev_priv->binding_mutex); 329 vmw_binding_res_list_scrub(&res->binding_head); 330 331 cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd)); 332 if (unlikely(cmd == NULL)) { 333 DRM_ERROR("Failed reserving FIFO space for shader " 334 "destruction.\n"); 335 mutex_unlock(&dev_priv->binding_mutex); 336 return -ENOMEM; 337 } 338 339 cmd->header.id = SVGA_3D_CMD_DESTROY_GB_SHADER; 340 cmd->header.size = sizeof(cmd->body); 341 cmd->body.shid = res->id; 342 vmw_fifo_commit(dev_priv, sizeof(*cmd)); 343 mutex_unlock(&dev_priv->binding_mutex); 344 vmw_resource_release_id(res); 345 vmw_fifo_resource_dec(dev_priv); 346 347 return 0; 348 } 349 350 /* 351 * DX shader code: 352 */ 353 354 /** 355 * vmw_dx_shader_commit_notify - Notify that a shader operation has been 356 * committed to hardware from a user-supplied command stream. 357 * 358 * @res: Pointer to the shader resource. 359 * @state: Indicating whether a creation or removal has been committed. 360 * 361 */ 362 static void vmw_dx_shader_commit_notify(struct vmw_resource *res, 363 enum vmw_cmdbuf_res_state state) 364 { 365 struct vmw_dx_shader *shader = vmw_res_to_dx_shader(res); 366 struct vmw_private *dev_priv = res->dev_priv; 367 368 if (state == VMW_CMDBUF_RES_ADD) { 369 mutex_lock(&dev_priv->binding_mutex); 370 vmw_cotable_add_resource(shader->cotable, 371 &shader->cotable_head); 372 shader->committed = true; 373 res->id = shader->id; 374 mutex_unlock(&dev_priv->binding_mutex); 375 } else { 376 mutex_lock(&dev_priv->binding_mutex); 377 list_del_init(&shader->cotable_head); 378 shader->committed = false; 379 res->id = -1; 380 mutex_unlock(&dev_priv->binding_mutex); 381 } 382 } 383 384 /** 385 * vmw_dx_shader_unscrub - Have the device reattach a MOB to a DX shader. 386 * 387 * @res: The shader resource 388 * 389 * This function reverts a scrub operation. 390 */ 391 static int vmw_dx_shader_unscrub(struct vmw_resource *res) 392 { 393 struct vmw_dx_shader *shader = vmw_res_to_dx_shader(res); 394 struct vmw_private *dev_priv = res->dev_priv; 395 struct { 396 SVGA3dCmdHeader header; 397 SVGA3dCmdDXBindShader body; 398 } *cmd; 399 400 if (!list_empty(&shader->cotable_head) || !shader->committed) 401 return 0; 402 403 cmd = vmw_fifo_reserve_dx(dev_priv, sizeof(*cmd), 404 shader->ctx->id); 405 if (unlikely(cmd == NULL)) { 406 DRM_ERROR("Failed reserving FIFO space for shader " 407 "scrubbing.\n"); 408 return -ENOMEM; 409 } 410 411 cmd->header.id = SVGA_3D_CMD_DX_BIND_SHADER; 412 cmd->header.size = sizeof(cmd->body); 413 cmd->body.cid = shader->ctx->id; 414 cmd->body.shid = shader->id; 415 cmd->body.mobid = res->backup->base.mem.start; 416 cmd->body.offsetInBytes = res->backup_offset; 417 vmw_fifo_commit(dev_priv, sizeof(*cmd)); 418 419 vmw_cotable_add_resource(shader->cotable, &shader->cotable_head); 420 421 return 0; 422 } 423 424 /** 425 * vmw_dx_shader_create - The DX shader create callback 426 * 427 * @res: The DX shader resource 428 * 429 * The create callback is called as part of resource validation and 430 * makes sure that we unscrub the shader if it's previously been scrubbed. 431 */ 432 static int vmw_dx_shader_create(struct vmw_resource *res) 433 { 434 struct vmw_private *dev_priv = res->dev_priv; 435 struct vmw_dx_shader *shader = vmw_res_to_dx_shader(res); 436 int ret = 0; 437 438 WARN_ON_ONCE(!shader->committed); 439 440 if (!list_empty(&res->mob_head)) { 441 mutex_lock(&dev_priv->binding_mutex); 442 ret = vmw_dx_shader_unscrub(res); 443 mutex_unlock(&dev_priv->binding_mutex); 444 } 445 446 res->id = shader->id; 447 return ret; 448 } 449 450 /** 451 * vmw_dx_shader_bind - The DX shader bind callback 452 * 453 * @res: The DX shader resource 454 * @val_buf: Pointer to the validate buffer. 455 * 456 */ 457 static int vmw_dx_shader_bind(struct vmw_resource *res, 458 struct ttm_validate_buffer *val_buf) 459 { 460 struct vmw_private *dev_priv = res->dev_priv; 461 struct ttm_buffer_object *bo = val_buf->bo; 462 463 BUG_ON(bo->mem.mem_type != VMW_PL_MOB); 464 mutex_lock(&dev_priv->binding_mutex); 465 vmw_dx_shader_unscrub(res); 466 mutex_unlock(&dev_priv->binding_mutex); 467 468 return 0; 469 } 470 471 /** 472 * vmw_dx_shader_scrub - Have the device unbind a MOB from a DX shader. 473 * 474 * @res: The shader resource 475 * 476 * This function unbinds a MOB from the DX shader without requiring the 477 * MOB dma_buffer to be reserved. The driver still considers the MOB bound. 478 * However, once the driver eventually decides to unbind the MOB, it doesn't 479 * need to access the context. 480 */ 481 static int vmw_dx_shader_scrub(struct vmw_resource *res) 482 { 483 struct vmw_dx_shader *shader = vmw_res_to_dx_shader(res); 484 struct vmw_private *dev_priv = res->dev_priv; 485 struct { 486 SVGA3dCmdHeader header; 487 SVGA3dCmdDXBindShader body; 488 } *cmd; 489 490 if (list_empty(&shader->cotable_head)) 491 return 0; 492 493 WARN_ON_ONCE(!shader->committed); 494 cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd)); 495 if (unlikely(cmd == NULL)) { 496 DRM_ERROR("Failed reserving FIFO space for shader " 497 "scrubbing.\n"); 498 return -ENOMEM; 499 } 500 501 cmd->header.id = SVGA_3D_CMD_DX_BIND_SHADER; 502 cmd->header.size = sizeof(cmd->body); 503 cmd->body.cid = shader->ctx->id; 504 cmd->body.shid = res->id; 505 cmd->body.mobid = SVGA3D_INVALID_ID; 506 cmd->body.offsetInBytes = 0; 507 vmw_fifo_commit(dev_priv, sizeof(*cmd)); 508 res->id = -1; 509 list_del_init(&shader->cotable_head); 510 511 return 0; 512 } 513 514 /** 515 * vmw_dx_shader_unbind - The dx shader unbind callback. 516 * 517 * @res: The shader resource 518 * @readback: Whether this is a readback unbind. Currently unused. 519 * @val_buf: MOB buffer information. 520 */ 521 static int vmw_dx_shader_unbind(struct vmw_resource *res, 522 bool readback, 523 struct ttm_validate_buffer *val_buf) 524 { 525 struct vmw_private *dev_priv = res->dev_priv; 526 struct vmw_fence_obj *fence; 527 int ret; 528 529 BUG_ON(res->backup->base.mem.mem_type != VMW_PL_MOB); 530 531 mutex_lock(&dev_priv->binding_mutex); 532 ret = vmw_dx_shader_scrub(res); 533 mutex_unlock(&dev_priv->binding_mutex); 534 535 if (ret) 536 return ret; 537 538 (void) vmw_execbuf_fence_commands(NULL, dev_priv, 539 &fence, NULL); 540 vmw_bo_fence_single(val_buf->bo, fence); 541 542 if (likely(fence != NULL)) 543 vmw_fence_obj_unreference(&fence); 544 545 return 0; 546 } 547 548 /** 549 * vmw_dx_shader_cotable_list_scrub - The cotable unbind_func callback for 550 * DX shaders. 551 * 552 * @dev_priv: Pointer to device private structure. 553 * @list: The list of cotable resources. 554 * @readback: Whether the call was part of a readback unbind. 555 * 556 * Scrubs all shader MOBs so that any subsequent shader unbind or shader 557 * destroy operation won't need to swap in the context. 558 */ 559 void vmw_dx_shader_cotable_list_scrub(struct vmw_private *dev_priv, 560 struct list_head *list, 561 bool readback) 562 { 563 struct vmw_dx_shader *entry, *next; 564 565 lockdep_assert_held_once(&dev_priv->binding_mutex); 566 567 list_for_each_entry_safe(entry, next, list, cotable_head) { 568 WARN_ON(vmw_dx_shader_scrub(&entry->res)); 569 if (!readback) 570 entry->committed = false; 571 } 572 } 573 574 /** 575 * vmw_dx_shader_res_free - The DX shader free callback 576 * 577 * @res: The shader resource 578 * 579 * Frees the DX shader resource and updates memory accounting. 580 */ 581 static void vmw_dx_shader_res_free(struct vmw_resource *res) 582 { 583 struct vmw_private *dev_priv = res->dev_priv; 584 struct vmw_dx_shader *shader = vmw_res_to_dx_shader(res); 585 586 vmw_resource_unreference(&shader->cotable); 587 kfree(shader); 588 ttm_mem_global_free(vmw_mem_glob(dev_priv), vmw_shader_dx_size); 589 } 590 591 /** 592 * vmw_dx_shader_add - Add a shader resource as a command buffer managed 593 * resource. 594 * 595 * @man: The command buffer resource manager. 596 * @ctx: Pointer to the context resource. 597 * @user_key: The id used for this shader. 598 * @shader_type: The shader type. 599 * @list: The list of staged command buffer managed resources. 600 */ 601 int vmw_dx_shader_add(struct vmw_cmdbuf_res_manager *man, 602 struct vmw_resource *ctx, 603 u32 user_key, 604 SVGA3dShaderType shader_type, 605 struct list_head *list) 606 { 607 struct vmw_dx_shader *shader; 608 struct vmw_resource *res; 609 struct vmw_private *dev_priv = ctx->dev_priv; 610 struct ttm_operation_ctx ttm_opt_ctx = { 611 .interruptible = true, 612 .no_wait_gpu = false 613 }; 614 int ret; 615 616 if (!vmw_shader_dx_size) 617 vmw_shader_dx_size = ttm_round_pot(sizeof(*shader)); 618 619 if (!vmw_shader_id_ok(user_key, shader_type)) 620 return -EINVAL; 621 622 ret = ttm_mem_global_alloc(vmw_mem_glob(dev_priv), vmw_shader_dx_size, 623 &ttm_opt_ctx); 624 if (ret) { 625 if (ret != -ERESTARTSYS) 626 DRM_ERROR("Out of graphics memory for shader " 627 "creation.\n"); 628 return ret; 629 } 630 631 shader = kmalloc(sizeof(*shader), GFP_KERNEL); 632 if (!shader) { 633 ttm_mem_global_free(vmw_mem_glob(dev_priv), vmw_shader_dx_size); 634 return -ENOMEM; 635 } 636 637 res = &shader->res; 638 shader->ctx = ctx; 639 shader->cotable = vmw_context_cotable(ctx, SVGA_COTABLE_DXSHADER); 640 shader->id = user_key; 641 shader->committed = false; 642 INIT_LIST_HEAD(&shader->cotable_head); 643 ret = vmw_resource_init(dev_priv, res, true, 644 vmw_dx_shader_res_free, &vmw_dx_shader_func); 645 if (ret) 646 goto out_resource_init; 647 648 /* 649 * The user_key name-space is not per shader type for DX shaders, 650 * so when hashing, use a single zero shader type. 651 */ 652 ret = vmw_cmdbuf_res_add(man, vmw_cmdbuf_res_shader, 653 vmw_shader_key(user_key, 0), 654 res, list); 655 if (ret) 656 goto out_resource_init; 657 658 res->id = shader->id; 659 res->hw_destroy = vmw_hw_shader_destroy; 660 661 out_resource_init: 662 vmw_resource_unreference(&res); 663 664 return ret; 665 } 666 667 668 669 /** 670 * User-space shader management: 671 */ 672 673 static struct vmw_resource * 674 vmw_user_shader_base_to_res(struct ttm_base_object *base) 675 { 676 return &(container_of(base, struct vmw_user_shader, base)-> 677 shader.res); 678 } 679 680 static void vmw_user_shader_free(struct vmw_resource *res) 681 { 682 struct vmw_user_shader *ushader = 683 container_of(res, struct vmw_user_shader, shader.res); 684 struct vmw_private *dev_priv = res->dev_priv; 685 686 ttm_base_object_kfree(ushader, base); 687 ttm_mem_global_free(vmw_mem_glob(dev_priv), 688 vmw_user_shader_size); 689 } 690 691 static void vmw_shader_free(struct vmw_resource *res) 692 { 693 struct vmw_shader *shader = vmw_res_to_shader(res); 694 struct vmw_private *dev_priv = res->dev_priv; 695 696 kfree(shader); 697 ttm_mem_global_free(vmw_mem_glob(dev_priv), 698 vmw_shader_size); 699 } 700 701 /** 702 * This function is called when user space has no more references on the 703 * base object. It releases the base-object's reference on the resource object. 704 */ 705 706 static void vmw_user_shader_base_release(struct ttm_base_object **p_base) 707 { 708 struct ttm_base_object *base = *p_base; 709 struct vmw_resource *res = vmw_user_shader_base_to_res(base); 710 711 *p_base = NULL; 712 vmw_resource_unreference(&res); 713 } 714 715 int vmw_shader_destroy_ioctl(struct drm_device *dev, void *data, 716 struct drm_file *file_priv) 717 { 718 struct drm_vmw_shader_arg *arg = (struct drm_vmw_shader_arg *)data; 719 struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile; 720 721 return ttm_ref_object_base_unref(tfile, arg->handle, 722 TTM_REF_USAGE); 723 } 724 725 static int vmw_user_shader_alloc(struct vmw_private *dev_priv, 726 struct vmw_buffer_object *buffer, 727 size_t shader_size, 728 size_t offset, 729 SVGA3dShaderType shader_type, 730 uint8_t num_input_sig, 731 uint8_t num_output_sig, 732 struct ttm_object_file *tfile, 733 u32 *handle) 734 { 735 struct vmw_user_shader *ushader; 736 struct vmw_resource *res, *tmp; 737 struct ttm_operation_ctx ctx = { 738 .interruptible = true, 739 .no_wait_gpu = false 740 }; 741 int ret; 742 743 if (unlikely(vmw_user_shader_size == 0)) 744 vmw_user_shader_size = 745 ttm_round_pot(sizeof(struct vmw_user_shader)) + 746 VMW_IDA_ACC_SIZE + TTM_OBJ_EXTRA_SIZE; 747 748 ret = ttm_mem_global_alloc(vmw_mem_glob(dev_priv), 749 vmw_user_shader_size, 750 &ctx); 751 if (unlikely(ret != 0)) { 752 if (ret != -ERESTARTSYS) 753 DRM_ERROR("Out of graphics memory for shader " 754 "creation.\n"); 755 goto out; 756 } 757 758 ushader = kzalloc(sizeof(*ushader), GFP_KERNEL); 759 if (unlikely(!ushader)) { 760 ttm_mem_global_free(vmw_mem_glob(dev_priv), 761 vmw_user_shader_size); 762 ret = -ENOMEM; 763 goto out; 764 } 765 766 res = &ushader->shader.res; 767 ushader->base.shareable = false; 768 ushader->base.tfile = NULL; 769 770 /* 771 * From here on, the destructor takes over resource freeing. 772 */ 773 774 ret = vmw_gb_shader_init(dev_priv, res, shader_size, 775 offset, shader_type, num_input_sig, 776 num_output_sig, buffer, 777 vmw_user_shader_free); 778 if (unlikely(ret != 0)) 779 goto out; 780 781 tmp = vmw_resource_reference(res); 782 ret = ttm_base_object_init(tfile, &ushader->base, false, 783 VMW_RES_SHADER, 784 &vmw_user_shader_base_release, NULL); 785 786 if (unlikely(ret != 0)) { 787 vmw_resource_unreference(&tmp); 788 goto out_err; 789 } 790 791 if (handle) 792 *handle = ushader->base.handle; 793 out_err: 794 vmw_resource_unreference(&res); 795 out: 796 return ret; 797 } 798 799 800 static struct vmw_resource *vmw_shader_alloc(struct vmw_private *dev_priv, 801 struct vmw_buffer_object *buffer, 802 size_t shader_size, 803 size_t offset, 804 SVGA3dShaderType shader_type) 805 { 806 struct vmw_shader *shader; 807 struct vmw_resource *res; 808 struct ttm_operation_ctx ctx = { 809 .interruptible = true, 810 .no_wait_gpu = false 811 }; 812 int ret; 813 814 if (unlikely(vmw_shader_size == 0)) 815 vmw_shader_size = 816 ttm_round_pot(sizeof(struct vmw_shader)) + 817 VMW_IDA_ACC_SIZE; 818 819 ret = ttm_mem_global_alloc(vmw_mem_glob(dev_priv), 820 vmw_shader_size, 821 &ctx); 822 if (unlikely(ret != 0)) { 823 if (ret != -ERESTARTSYS) 824 DRM_ERROR("Out of graphics memory for shader " 825 "creation.\n"); 826 goto out_err; 827 } 828 829 shader = kzalloc(sizeof(*shader), GFP_KERNEL); 830 if (unlikely(!shader)) { 831 ttm_mem_global_free(vmw_mem_glob(dev_priv), 832 vmw_shader_size); 833 ret = -ENOMEM; 834 goto out_err; 835 } 836 837 res = &shader->res; 838 839 /* 840 * From here on, the destructor takes over resource freeing. 841 */ 842 ret = vmw_gb_shader_init(dev_priv, res, shader_size, 843 offset, shader_type, 0, 0, buffer, 844 vmw_shader_free); 845 846 out_err: 847 return ret ? ERR_PTR(ret) : res; 848 } 849 850 851 static int vmw_shader_define(struct drm_device *dev, struct drm_file *file_priv, 852 enum drm_vmw_shader_type shader_type_drm, 853 u32 buffer_handle, size_t size, size_t offset, 854 uint8_t num_input_sig, uint8_t num_output_sig, 855 uint32_t *shader_handle) 856 { 857 struct vmw_private *dev_priv = vmw_priv(dev); 858 struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile; 859 struct vmw_buffer_object *buffer = NULL; 860 SVGA3dShaderType shader_type; 861 int ret; 862 863 if (buffer_handle != SVGA3D_INVALID_ID) { 864 ret = vmw_user_bo_lookup(tfile, buffer_handle, 865 &buffer, NULL); 866 if (unlikely(ret != 0)) { 867 DRM_ERROR("Could not find buffer for shader " 868 "creation.\n"); 869 return ret; 870 } 871 872 if ((u64)buffer->base.num_pages * PAGE_SIZE < 873 (u64)size + (u64)offset) { 874 DRM_ERROR("Illegal buffer- or shader size.\n"); 875 ret = -EINVAL; 876 goto out_bad_arg; 877 } 878 } 879 880 switch (shader_type_drm) { 881 case drm_vmw_shader_type_vs: 882 shader_type = SVGA3D_SHADERTYPE_VS; 883 break; 884 case drm_vmw_shader_type_ps: 885 shader_type = SVGA3D_SHADERTYPE_PS; 886 break; 887 default: 888 DRM_ERROR("Illegal shader type.\n"); 889 ret = -EINVAL; 890 goto out_bad_arg; 891 } 892 893 ret = ttm_read_lock(&dev_priv->reservation_sem, true); 894 if (unlikely(ret != 0)) 895 goto out_bad_arg; 896 897 ret = vmw_user_shader_alloc(dev_priv, buffer, size, offset, 898 shader_type, num_input_sig, 899 num_output_sig, tfile, shader_handle); 900 901 ttm_read_unlock(&dev_priv->reservation_sem); 902 out_bad_arg: 903 vmw_bo_unreference(&buffer); 904 return ret; 905 } 906 907 /** 908 * vmw_shader_id_ok - Check whether a compat shader user key and 909 * shader type are within valid bounds. 910 * 911 * @user_key: User space id of the shader. 912 * @shader_type: Shader type. 913 * 914 * Returns true if valid false if not. 915 */ 916 static bool vmw_shader_id_ok(u32 user_key, SVGA3dShaderType shader_type) 917 { 918 return user_key <= ((1 << 20) - 1) && (unsigned) shader_type < 16; 919 } 920 921 /** 922 * vmw_shader_key - Compute a hash key suitable for a compat shader. 923 * 924 * @user_key: User space id of the shader. 925 * @shader_type: Shader type. 926 * 927 * Returns a hash key suitable for a command buffer managed resource 928 * manager hash table. 929 */ 930 static u32 vmw_shader_key(u32 user_key, SVGA3dShaderType shader_type) 931 { 932 return user_key | (shader_type << 20); 933 } 934 935 /** 936 * vmw_shader_remove - Stage a compat shader for removal. 937 * 938 * @man: Pointer to the compat shader manager identifying the shader namespace. 939 * @user_key: The key that is used to identify the shader. The key is 940 * unique to the shader type. 941 * @shader_type: Shader type. 942 * @list: Caller's list of staged command buffer resource actions. 943 */ 944 int vmw_shader_remove(struct vmw_cmdbuf_res_manager *man, 945 u32 user_key, SVGA3dShaderType shader_type, 946 struct list_head *list) 947 { 948 struct vmw_resource *dummy; 949 950 if (!vmw_shader_id_ok(user_key, shader_type)) 951 return -EINVAL; 952 953 return vmw_cmdbuf_res_remove(man, vmw_cmdbuf_res_shader, 954 vmw_shader_key(user_key, shader_type), 955 list, &dummy); 956 } 957 958 /** 959 * vmw_compat_shader_add - Create a compat shader and stage it for addition 960 * as a command buffer managed resource. 961 * 962 * @man: Pointer to the compat shader manager identifying the shader namespace. 963 * @user_key: The key that is used to identify the shader. The key is 964 * unique to the shader type. 965 * @bytecode: Pointer to the bytecode of the shader. 966 * @shader_type: Shader type. 967 * @tfile: Pointer to a struct ttm_object_file that the guest-backed shader is 968 * to be created with. 969 * @list: Caller's list of staged command buffer resource actions. 970 * 971 */ 972 int vmw_compat_shader_add(struct vmw_private *dev_priv, 973 struct vmw_cmdbuf_res_manager *man, 974 u32 user_key, const void *bytecode, 975 SVGA3dShaderType shader_type, 976 size_t size, 977 struct list_head *list) 978 { 979 struct ttm_operation_ctx ctx = { false, true }; 980 struct vmw_buffer_object *buf; 981 struct ttm_bo_kmap_obj map; 982 bool is_iomem; 983 int ret; 984 struct vmw_resource *res; 985 986 if (!vmw_shader_id_ok(user_key, shader_type)) 987 return -EINVAL; 988 989 /* Allocate and pin a DMA buffer */ 990 buf = kzalloc(sizeof(*buf), GFP_KERNEL); 991 if (unlikely(!buf)) 992 return -ENOMEM; 993 994 ret = vmw_bo_init(dev_priv, buf, size, &vmw_sys_ne_placement, 995 true, vmw_bo_bo_free); 996 if (unlikely(ret != 0)) 997 goto out; 998 999 ret = ttm_bo_reserve(&buf->base, false, true, NULL); 1000 if (unlikely(ret != 0)) 1001 goto no_reserve; 1002 1003 /* Map and copy shader bytecode. */ 1004 ret = ttm_bo_kmap(&buf->base, 0, PAGE_ALIGN(size) >> PAGE_SHIFT, 1005 &map); 1006 if (unlikely(ret != 0)) { 1007 ttm_bo_unreserve(&buf->base); 1008 goto no_reserve; 1009 } 1010 1011 memcpy(ttm_kmap_obj_virtual(&map, &is_iomem), bytecode, size); 1012 WARN_ON(is_iomem); 1013 1014 ttm_bo_kunmap(&map); 1015 ret = ttm_bo_validate(&buf->base, &vmw_sys_placement, &ctx); 1016 WARN_ON(ret != 0); 1017 ttm_bo_unreserve(&buf->base); 1018 1019 res = vmw_shader_alloc(dev_priv, buf, size, 0, shader_type); 1020 if (unlikely(ret != 0)) 1021 goto no_reserve; 1022 1023 ret = vmw_cmdbuf_res_add(man, vmw_cmdbuf_res_shader, 1024 vmw_shader_key(user_key, shader_type), 1025 res, list); 1026 vmw_resource_unreference(&res); 1027 no_reserve: 1028 vmw_bo_unreference(&buf); 1029 out: 1030 return ret; 1031 } 1032 1033 /** 1034 * vmw_shader_lookup - Look up a compat shader 1035 * 1036 * @man: Pointer to the command buffer managed resource manager identifying 1037 * the shader namespace. 1038 * @user_key: The user space id of the shader. 1039 * @shader_type: The shader type. 1040 * 1041 * Returns a refcounted pointer to a struct vmw_resource if the shader was 1042 * found. An error pointer otherwise. 1043 */ 1044 struct vmw_resource * 1045 vmw_shader_lookup(struct vmw_cmdbuf_res_manager *man, 1046 u32 user_key, 1047 SVGA3dShaderType shader_type) 1048 { 1049 if (!vmw_shader_id_ok(user_key, shader_type)) 1050 return ERR_PTR(-EINVAL); 1051 1052 return vmw_cmdbuf_res_lookup(man, vmw_cmdbuf_res_shader, 1053 vmw_shader_key(user_key, shader_type)); 1054 } 1055 1056 int vmw_shader_define_ioctl(struct drm_device *dev, void *data, 1057 struct drm_file *file_priv) 1058 { 1059 struct drm_vmw_shader_create_arg *arg = 1060 (struct drm_vmw_shader_create_arg *)data; 1061 1062 return vmw_shader_define(dev, file_priv, arg->shader_type, 1063 arg->buffer_handle, 1064 arg->size, arg->offset, 1065 0, 0, 1066 &arg->shader_handle); 1067 } 1068