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_resource_reference 640 (vmw_context_cotable(ctx, SVGA_COTABLE_DXSHADER)); 641 shader->id = user_key; 642 shader->committed = false; 643 INIT_LIST_HEAD(&shader->cotable_head); 644 ret = vmw_resource_init(dev_priv, res, true, 645 vmw_dx_shader_res_free, &vmw_dx_shader_func); 646 if (ret) 647 goto out_resource_init; 648 649 /* 650 * The user_key name-space is not per shader type for DX shaders, 651 * so when hashing, use a single zero shader type. 652 */ 653 ret = vmw_cmdbuf_res_add(man, vmw_cmdbuf_res_shader, 654 vmw_shader_key(user_key, 0), 655 res, list); 656 if (ret) 657 goto out_resource_init; 658 659 res->id = shader->id; 660 res->hw_destroy = vmw_hw_shader_destroy; 661 662 out_resource_init: 663 vmw_resource_unreference(&res); 664 665 return ret; 666 } 667 668 669 670 /** 671 * User-space shader management: 672 */ 673 674 static struct vmw_resource * 675 vmw_user_shader_base_to_res(struct ttm_base_object *base) 676 { 677 return &(container_of(base, struct vmw_user_shader, base)-> 678 shader.res); 679 } 680 681 static void vmw_user_shader_free(struct vmw_resource *res) 682 { 683 struct vmw_user_shader *ushader = 684 container_of(res, struct vmw_user_shader, shader.res); 685 struct vmw_private *dev_priv = res->dev_priv; 686 687 ttm_base_object_kfree(ushader, base); 688 ttm_mem_global_free(vmw_mem_glob(dev_priv), 689 vmw_user_shader_size); 690 } 691 692 static void vmw_shader_free(struct vmw_resource *res) 693 { 694 struct vmw_shader *shader = vmw_res_to_shader(res); 695 struct vmw_private *dev_priv = res->dev_priv; 696 697 kfree(shader); 698 ttm_mem_global_free(vmw_mem_glob(dev_priv), 699 vmw_shader_size); 700 } 701 702 /** 703 * This function is called when user space has no more references on the 704 * base object. It releases the base-object's reference on the resource object. 705 */ 706 707 static void vmw_user_shader_base_release(struct ttm_base_object **p_base) 708 { 709 struct ttm_base_object *base = *p_base; 710 struct vmw_resource *res = vmw_user_shader_base_to_res(base); 711 712 *p_base = NULL; 713 vmw_resource_unreference(&res); 714 } 715 716 int vmw_shader_destroy_ioctl(struct drm_device *dev, void *data, 717 struct drm_file *file_priv) 718 { 719 struct drm_vmw_shader_arg *arg = (struct drm_vmw_shader_arg *)data; 720 struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile; 721 722 return ttm_ref_object_base_unref(tfile, arg->handle, 723 TTM_REF_USAGE); 724 } 725 726 static int vmw_user_shader_alloc(struct vmw_private *dev_priv, 727 struct vmw_buffer_object *buffer, 728 size_t shader_size, 729 size_t offset, 730 SVGA3dShaderType shader_type, 731 uint8_t num_input_sig, 732 uint8_t num_output_sig, 733 struct ttm_object_file *tfile, 734 u32 *handle) 735 { 736 struct vmw_user_shader *ushader; 737 struct vmw_resource *res, *tmp; 738 struct ttm_operation_ctx ctx = { 739 .interruptible = true, 740 .no_wait_gpu = false 741 }; 742 int ret; 743 744 if (unlikely(vmw_user_shader_size == 0)) 745 vmw_user_shader_size = 746 ttm_round_pot(sizeof(struct vmw_user_shader)) + 747 VMW_IDA_ACC_SIZE + TTM_OBJ_EXTRA_SIZE; 748 749 ret = ttm_mem_global_alloc(vmw_mem_glob(dev_priv), 750 vmw_user_shader_size, 751 &ctx); 752 if (unlikely(ret != 0)) { 753 if (ret != -ERESTARTSYS) 754 DRM_ERROR("Out of graphics memory for shader " 755 "creation.\n"); 756 goto out; 757 } 758 759 ushader = kzalloc(sizeof(*ushader), GFP_KERNEL); 760 if (unlikely(!ushader)) { 761 ttm_mem_global_free(vmw_mem_glob(dev_priv), 762 vmw_user_shader_size); 763 ret = -ENOMEM; 764 goto out; 765 } 766 767 res = &ushader->shader.res; 768 ushader->base.shareable = false; 769 ushader->base.tfile = NULL; 770 771 /* 772 * From here on, the destructor takes over resource freeing. 773 */ 774 775 ret = vmw_gb_shader_init(dev_priv, res, shader_size, 776 offset, shader_type, num_input_sig, 777 num_output_sig, buffer, 778 vmw_user_shader_free); 779 if (unlikely(ret != 0)) 780 goto out; 781 782 tmp = vmw_resource_reference(res); 783 ret = ttm_base_object_init(tfile, &ushader->base, false, 784 VMW_RES_SHADER, 785 &vmw_user_shader_base_release, NULL); 786 787 if (unlikely(ret != 0)) { 788 vmw_resource_unreference(&tmp); 789 goto out_err; 790 } 791 792 if (handle) 793 *handle = ushader->base.handle; 794 out_err: 795 vmw_resource_unreference(&res); 796 out: 797 return ret; 798 } 799 800 801 static struct vmw_resource *vmw_shader_alloc(struct vmw_private *dev_priv, 802 struct vmw_buffer_object *buffer, 803 size_t shader_size, 804 size_t offset, 805 SVGA3dShaderType shader_type) 806 { 807 struct vmw_shader *shader; 808 struct vmw_resource *res; 809 struct ttm_operation_ctx ctx = { 810 .interruptible = true, 811 .no_wait_gpu = false 812 }; 813 int ret; 814 815 if (unlikely(vmw_shader_size == 0)) 816 vmw_shader_size = 817 ttm_round_pot(sizeof(struct vmw_shader)) + 818 VMW_IDA_ACC_SIZE; 819 820 ret = ttm_mem_global_alloc(vmw_mem_glob(dev_priv), 821 vmw_shader_size, 822 &ctx); 823 if (unlikely(ret != 0)) { 824 if (ret != -ERESTARTSYS) 825 DRM_ERROR("Out of graphics memory for shader " 826 "creation.\n"); 827 goto out_err; 828 } 829 830 shader = kzalloc(sizeof(*shader), GFP_KERNEL); 831 if (unlikely(!shader)) { 832 ttm_mem_global_free(vmw_mem_glob(dev_priv), 833 vmw_shader_size); 834 ret = -ENOMEM; 835 goto out_err; 836 } 837 838 res = &shader->res; 839 840 /* 841 * From here on, the destructor takes over resource freeing. 842 */ 843 ret = vmw_gb_shader_init(dev_priv, res, shader_size, 844 offset, shader_type, 0, 0, buffer, 845 vmw_shader_free); 846 847 out_err: 848 return ret ? ERR_PTR(ret) : res; 849 } 850 851 852 static int vmw_shader_define(struct drm_device *dev, struct drm_file *file_priv, 853 enum drm_vmw_shader_type shader_type_drm, 854 u32 buffer_handle, size_t size, size_t offset, 855 uint8_t num_input_sig, uint8_t num_output_sig, 856 uint32_t *shader_handle) 857 { 858 struct vmw_private *dev_priv = vmw_priv(dev); 859 struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile; 860 struct vmw_buffer_object *buffer = NULL; 861 SVGA3dShaderType shader_type; 862 int ret; 863 864 if (buffer_handle != SVGA3D_INVALID_ID) { 865 ret = vmw_user_bo_lookup(tfile, buffer_handle, 866 &buffer, NULL); 867 if (unlikely(ret != 0)) { 868 DRM_ERROR("Could not find buffer for shader " 869 "creation.\n"); 870 return ret; 871 } 872 873 if ((u64)buffer->base.num_pages * PAGE_SIZE < 874 (u64)size + (u64)offset) { 875 DRM_ERROR("Illegal buffer- or shader size.\n"); 876 ret = -EINVAL; 877 goto out_bad_arg; 878 } 879 } 880 881 switch (shader_type_drm) { 882 case drm_vmw_shader_type_vs: 883 shader_type = SVGA3D_SHADERTYPE_VS; 884 break; 885 case drm_vmw_shader_type_ps: 886 shader_type = SVGA3D_SHADERTYPE_PS; 887 break; 888 default: 889 DRM_ERROR("Illegal shader type.\n"); 890 ret = -EINVAL; 891 goto out_bad_arg; 892 } 893 894 ret = ttm_read_lock(&dev_priv->reservation_sem, true); 895 if (unlikely(ret != 0)) 896 goto out_bad_arg; 897 898 ret = vmw_user_shader_alloc(dev_priv, buffer, size, offset, 899 shader_type, num_input_sig, 900 num_output_sig, tfile, shader_handle); 901 902 ttm_read_unlock(&dev_priv->reservation_sem); 903 out_bad_arg: 904 vmw_bo_unreference(&buffer); 905 return ret; 906 } 907 908 /** 909 * vmw_shader_id_ok - Check whether a compat shader user key and 910 * shader type are within valid bounds. 911 * 912 * @user_key: User space id of the shader. 913 * @shader_type: Shader type. 914 * 915 * Returns true if valid false if not. 916 */ 917 static bool vmw_shader_id_ok(u32 user_key, SVGA3dShaderType shader_type) 918 { 919 return user_key <= ((1 << 20) - 1) && (unsigned) shader_type < 16; 920 } 921 922 /** 923 * vmw_shader_key - Compute a hash key suitable for a compat shader. 924 * 925 * @user_key: User space id of the shader. 926 * @shader_type: Shader type. 927 * 928 * Returns a hash key suitable for a command buffer managed resource 929 * manager hash table. 930 */ 931 static u32 vmw_shader_key(u32 user_key, SVGA3dShaderType shader_type) 932 { 933 return user_key | (shader_type << 20); 934 } 935 936 /** 937 * vmw_shader_remove - Stage a compat shader for removal. 938 * 939 * @man: Pointer to the compat shader manager identifying the shader namespace. 940 * @user_key: The key that is used to identify the shader. The key is 941 * unique to the shader type. 942 * @shader_type: Shader type. 943 * @list: Caller's list of staged command buffer resource actions. 944 */ 945 int vmw_shader_remove(struct vmw_cmdbuf_res_manager *man, 946 u32 user_key, SVGA3dShaderType shader_type, 947 struct list_head *list) 948 { 949 struct vmw_resource *dummy; 950 951 if (!vmw_shader_id_ok(user_key, shader_type)) 952 return -EINVAL; 953 954 return vmw_cmdbuf_res_remove(man, vmw_cmdbuf_res_shader, 955 vmw_shader_key(user_key, shader_type), 956 list, &dummy); 957 } 958 959 /** 960 * vmw_compat_shader_add - Create a compat shader and stage it for addition 961 * as a command buffer managed resource. 962 * 963 * @man: Pointer to the compat shader manager identifying the shader namespace. 964 * @user_key: The key that is used to identify the shader. The key is 965 * unique to the shader type. 966 * @bytecode: Pointer to the bytecode of the shader. 967 * @shader_type: Shader type. 968 * @tfile: Pointer to a struct ttm_object_file that the guest-backed shader is 969 * to be created with. 970 * @list: Caller's list of staged command buffer resource actions. 971 * 972 */ 973 int vmw_compat_shader_add(struct vmw_private *dev_priv, 974 struct vmw_cmdbuf_res_manager *man, 975 u32 user_key, const void *bytecode, 976 SVGA3dShaderType shader_type, 977 size_t size, 978 struct list_head *list) 979 { 980 struct ttm_operation_ctx ctx = { false, true }; 981 struct vmw_buffer_object *buf; 982 struct ttm_bo_kmap_obj map; 983 bool is_iomem; 984 int ret; 985 struct vmw_resource *res; 986 987 if (!vmw_shader_id_ok(user_key, shader_type)) 988 return -EINVAL; 989 990 /* Allocate and pin a DMA buffer */ 991 buf = kzalloc(sizeof(*buf), GFP_KERNEL); 992 if (unlikely(!buf)) 993 return -ENOMEM; 994 995 ret = vmw_bo_init(dev_priv, buf, size, &vmw_sys_ne_placement, 996 true, vmw_bo_bo_free); 997 if (unlikely(ret != 0)) 998 goto out; 999 1000 ret = ttm_bo_reserve(&buf->base, false, true, NULL); 1001 if (unlikely(ret != 0)) 1002 goto no_reserve; 1003 1004 /* Map and copy shader bytecode. */ 1005 ret = ttm_bo_kmap(&buf->base, 0, PAGE_ALIGN(size) >> PAGE_SHIFT, 1006 &map); 1007 if (unlikely(ret != 0)) { 1008 ttm_bo_unreserve(&buf->base); 1009 goto no_reserve; 1010 } 1011 1012 memcpy(ttm_kmap_obj_virtual(&map, &is_iomem), bytecode, size); 1013 WARN_ON(is_iomem); 1014 1015 ttm_bo_kunmap(&map); 1016 ret = ttm_bo_validate(&buf->base, &vmw_sys_placement, &ctx); 1017 WARN_ON(ret != 0); 1018 ttm_bo_unreserve(&buf->base); 1019 1020 res = vmw_shader_alloc(dev_priv, buf, size, 0, shader_type); 1021 if (unlikely(ret != 0)) 1022 goto no_reserve; 1023 1024 ret = vmw_cmdbuf_res_add(man, vmw_cmdbuf_res_shader, 1025 vmw_shader_key(user_key, shader_type), 1026 res, list); 1027 vmw_resource_unreference(&res); 1028 no_reserve: 1029 vmw_bo_unreference(&buf); 1030 out: 1031 return ret; 1032 } 1033 1034 /** 1035 * vmw_shader_lookup - Look up a compat shader 1036 * 1037 * @man: Pointer to the command buffer managed resource manager identifying 1038 * the shader namespace. 1039 * @user_key: The user space id of the shader. 1040 * @shader_type: The shader type. 1041 * 1042 * Returns a refcounted pointer to a struct vmw_resource if the shader was 1043 * found. An error pointer otherwise. 1044 */ 1045 struct vmw_resource * 1046 vmw_shader_lookup(struct vmw_cmdbuf_res_manager *man, 1047 u32 user_key, 1048 SVGA3dShaderType shader_type) 1049 { 1050 if (!vmw_shader_id_ok(user_key, shader_type)) 1051 return ERR_PTR(-EINVAL); 1052 1053 return vmw_cmdbuf_res_lookup(man, vmw_cmdbuf_res_shader, 1054 vmw_shader_key(user_key, shader_type)); 1055 } 1056 1057 int vmw_shader_define_ioctl(struct drm_device *dev, void *data, 1058 struct drm_file *file_priv) 1059 { 1060 struct drm_vmw_shader_create_arg *arg = 1061 (struct drm_vmw_shader_create_arg *)data; 1062 1063 return vmw_shader_define(dev, file_priv, arg->shader_type, 1064 arg->buffer_handle, 1065 arg->size, arg->offset, 1066 0, 0, 1067 &arg->shader_handle); 1068 } 1069