drivers/gpu/drm/vmwgfx/vmwgfx_shader.c

   1 // SPDX-License-Identifier: GPL-2.0 OR MIT
   2 /**************************************************************************
   3  *
   4  * Copyright 2009-2023 VMware, Inc., Palo Alto, CA., USA
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  21  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
  22  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  23  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  24  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 #include <drm/ttm/ttm_placement.h>
  29
  30 #include "vmwgfx_binding.h"
  31 #include "vmwgfx_bo.h"
  32 #include "vmwgfx_drv.h"
  33 #include "vmwgfx_resource_priv.h"
  34
  35 struct vmw_shader {
  36         struct vmw_resource res;
  37         SVGA3dShaderType type;
  38         uint32_t size;
  39         uint8_t num_input_sig;
  40         uint8_t num_output_sig;
  41 };
  42
  43 struct vmw_user_shader {
  44         struct ttm_base_object base;
  45         struct vmw_shader shader;
  46 };
  47
  48 struct vmw_dx_shader {
  49         struct vmw_resource res;
  50         struct vmw_resource *ctx;
  51         struct vmw_resource *cotable;
  52         u32 id;
  53         bool committed;
  54         struct list_head cotable_head;
  55 };
  56
  57 static void vmw_user_shader_free(struct vmw_resource *res);
  58 static struct vmw_resource *
  59 vmw_user_shader_base_to_res(struct ttm_base_object *base);
  60
  61 static int vmw_gb_shader_create(struct vmw_resource *res);
  62 static int vmw_gb_shader_bind(struct vmw_resource *res,
  63                                struct ttm_validate_buffer *val_buf);
  64 static int vmw_gb_shader_unbind(struct vmw_resource *res,
  65                                  bool readback,
  66                                  struct ttm_validate_buffer *val_buf);
  67 static int vmw_gb_shader_destroy(struct vmw_resource *res);
  68
  69 static int vmw_dx_shader_create(struct vmw_resource *res);
  70 static int vmw_dx_shader_bind(struct vmw_resource *res,
  71                                struct ttm_validate_buffer *val_buf);
  72 static int vmw_dx_shader_unbind(struct vmw_resource *res,
  73                                  bool readback,
  74                                  struct ttm_validate_buffer *val_buf);
  75 static void vmw_dx_shader_commit_notify(struct vmw_resource *res,
  76                                         enum vmw_cmdbuf_res_state state);
  77 static bool vmw_shader_id_ok(u32 user_key, SVGA3dShaderType shader_type);
  78 static u32 vmw_shader_key(u32 user_key, SVGA3dShaderType shader_type);
  79
  80 static const struct vmw_user_resource_conv user_shader_conv = {
  81         .object_type = VMW_RES_SHADER,
  82         .base_obj_to_res = vmw_user_shader_base_to_res,
  83         .res_free = vmw_user_shader_free
  84 };
  85
  86 const struct vmw_user_resource_conv *user_shader_converter =
  87         &user_shader_conv;
  88
  89
  90 static const struct vmw_res_func vmw_gb_shader_func = {
  91         .res_type = vmw_res_shader,
  92         .needs_guest_memory = true,
  93         .may_evict = true,
  94         .prio = 3,
  95         .dirty_prio = 3,
  96         .type_name = "guest backed shaders",
  97         .domain = VMW_BO_DOMAIN_MOB,
  98         .busy_domain = VMW_BO_DOMAIN_MOB,
  99         .create = vmw_gb_shader_create,
 100         .destroy = vmw_gb_shader_destroy,
 101         .bind = vmw_gb_shader_bind,
 102         .unbind = vmw_gb_shader_unbind
 103 };
 104
 105 static const struct vmw_res_func vmw_dx_shader_func = {
 106         .res_type = vmw_res_shader,
 107         .needs_guest_memory = true,
 108         .may_evict = true,
 109         .prio = 3,
 110         .dirty_prio = 3,
 111         .type_name = "dx shaders",
 112         .domain = VMW_BO_DOMAIN_MOB,
 113         .busy_domain = VMW_BO_DOMAIN_MOB,
 114         .create = vmw_dx_shader_create,
 115         /*
 116          * The destroy callback is only called with a committed resource on
 117          * context destroy, in which case we destroy the cotable anyway,
 118          * so there's no need to destroy DX shaders separately.
 119          */
 120         .destroy = NULL,
 121         .bind = vmw_dx_shader_bind,
 122         .unbind = vmw_dx_shader_unbind,
 123         .commit_notify = vmw_dx_shader_commit_notify,
 124 };
 125
 126 /*
 127  * Shader management:
 128  */
 129
 130 static inline struct vmw_shader *
 131 vmw_res_to_shader(struct vmw_resource *res)
 132 {
 133         return container_of(res, struct vmw_shader, res);
 134 }
 135
 136 /**
 137  * vmw_res_to_dx_shader - typecast a struct vmw_resource to a
 138  * struct vmw_dx_shader
 139  *
 140  * @res: Pointer to the struct vmw_resource.
 141  */
 142 static inline struct vmw_dx_shader *
 143 vmw_res_to_dx_shader(struct vmw_resource *res)
 144 {
 145         return container_of(res, struct vmw_dx_shader, res);
 146 }
 147
 148 static void vmw_hw_shader_destroy(struct vmw_resource *res)
 149 {
 150         if (likely(res->func->destroy))
 151                 (void) res->func->destroy(res);
 152         else
 153                 res->id = -1;
 154 }
 155
 156
 157 static int vmw_gb_shader_init(struct vmw_private *dev_priv,
 158                               struct vmw_resource *res,
 159                               uint32_t size,
 160                               uint64_t offset,
 161                               SVGA3dShaderType type,
 162                               uint8_t num_input_sig,
 163                               uint8_t num_output_sig,
 164                               struct vmw_bo *byte_code,
 165                               void (*res_free) (struct vmw_resource *res))
 166 {
 167         struct vmw_shader *shader = vmw_res_to_shader(res);
 168         int ret;
 169
 170         ret = vmw_resource_init(dev_priv, res, true, res_free,
 171                                 &vmw_gb_shader_func);
 172
 173         if (unlikely(ret != 0)) {
 174                 if (res_free)
 175                         res_free(res);
 176                 else
 177                         kfree(res);
 178                 return ret;
 179         }
 180
 181         res->guest_memory_size = size;
 182         if (byte_code) {
 183                 res->guest_memory_bo = vmw_bo_reference(byte_code);
 184                 res->guest_memory_offset = offset;
 185         }
 186         shader->size = size;
 187         shader->type = type;
 188         shader->num_input_sig = num_input_sig;
 189         shader->num_output_sig = num_output_sig;
 190
 191         res->hw_destroy = vmw_hw_shader_destroy;
 192         return 0;
 193 }
 194
 195 /*
 196  * GB shader code:
 197  */
 198
 199 static int vmw_gb_shader_create(struct vmw_resource *res)
 200 {
 201         struct vmw_private *dev_priv = res->dev_priv;
 202         struct vmw_shader *shader = vmw_res_to_shader(res);
 203         int ret;
 204         struct {
 205                 SVGA3dCmdHeader header;
 206                 SVGA3dCmdDefineGBShader body;
 207         } *cmd;
 208
 209         if (likely(res->id != -1))
 210                 return 0;
 211
 212         ret = vmw_resource_alloc_id(res);
 213         if (unlikely(ret != 0)) {
 214                 DRM_ERROR("Failed to allocate a shader id.\n");
 215                 goto out_no_id;
 216         }
 217
 218         if (unlikely(res->id >= VMWGFX_NUM_GB_SHADER)) {
 219                 ret = -EBUSY;
 220                 goto out_no_fifo;
 221         }
 222
 223         cmd = VMW_CMD_RESERVE(dev_priv, sizeof(*cmd));
 224         if (unlikely(cmd == NULL)) {
 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_cmd_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->resource->mem_type != VMW_PL_MOB);
 256
 257         cmd = VMW_CMD_RESERVE(dev_priv, sizeof(*cmd));
 258         if (unlikely(cmd == NULL))
 259                 return -ENOMEM;
 260
 261         cmd->header.id = SVGA_3D_CMD_BIND_GB_SHADER;
 262         cmd->header.size = sizeof(cmd->body);
 263         cmd->body.shid = res->id;
 264         cmd->body.mobid = bo->resource->start;
 265         cmd->body.offsetInBytes = res->guest_memory_offset;
 266         res->guest_memory_dirty = false;
 267         vmw_cmd_commit(dev_priv, sizeof(*cmd));
 268
 269         return 0;
 270 }
 271
 272 static int vmw_gb_shader_unbind(struct vmw_resource *res,
 273                                 bool readback,
 274                                 struct ttm_validate_buffer *val_buf)
 275 {
 276         struct vmw_private *dev_priv = res->dev_priv;
 277         struct {
 278                 SVGA3dCmdHeader header;
 279                 SVGA3dCmdBindGBShader body;
 280         } *cmd;
 281         struct vmw_fence_obj *fence;
 282
 283         BUG_ON(res->guest_memory_bo->tbo.resource->mem_type != VMW_PL_MOB);
 284
 285         cmd = VMW_CMD_RESERVE(dev_priv, sizeof(*cmd));
 286         if (unlikely(cmd == NULL))
 287                 return -ENOMEM;
 288
 289         cmd->header.id = SVGA_3D_CMD_BIND_GB_SHADER;
 290         cmd->header.size = sizeof(cmd->body);
 291         cmd->body.shid = res->id;
 292         cmd->body.mobid = SVGA3D_INVALID_ID;
 293         cmd->body.offsetInBytes = 0;
 294         vmw_cmd_commit(dev_priv, sizeof(*cmd));
 295
 296         /*
 297          * Create a fence object and fence the backup buffer.
 298          */
 299
 300         (void) vmw_execbuf_fence_commands(NULL, dev_priv,
 301                                           &fence, NULL);
 302
 303         vmw_bo_fence_single(val_buf->bo, fence);
 304
 305         if (likely(fence != NULL))
 306                 vmw_fence_obj_unreference(&fence);
 307
 308         return 0;
 309 }
 310
 311 static int vmw_gb_shader_destroy(struct vmw_resource *res)
 312 {
 313         struct vmw_private *dev_priv = res->dev_priv;
 314         struct {
 315                 SVGA3dCmdHeader header;
 316                 SVGA3dCmdDestroyGBShader body;
 317         } *cmd;
 318
 319         if (likely(res->id == -1))
 320                 return 0;
 321
 322         mutex_lock(&dev_priv->binding_mutex);
 323         vmw_binding_res_list_scrub(&res->binding_head);
 324
 325         cmd = VMW_CMD_RESERVE(dev_priv, sizeof(*cmd));
 326         if (unlikely(cmd == NULL)) {
 327                 mutex_unlock(&dev_priv->binding_mutex);
 328                 return -ENOMEM;
 329         }
 330
 331         cmd->header.id = SVGA_3D_CMD_DESTROY_GB_SHADER;
 332         cmd->header.size = sizeof(cmd->body);
 333         cmd->body.shid = res->id;
 334         vmw_cmd_commit(dev_priv, sizeof(*cmd));
 335         mutex_unlock(&dev_priv->binding_mutex);
 336         vmw_resource_release_id(res);
 337         vmw_fifo_resource_dec(dev_priv);
 338
 339         return 0;
 340 }
 341
 342 /*
 343  * DX shader code:
 344  */
 345
 346 /**
 347  * vmw_dx_shader_commit_notify - Notify that a shader operation has been
 348  * committed to hardware from a user-supplied command stream.
 349  *
 350  * @res: Pointer to the shader resource.
 351  * @state: Indicating whether a creation or removal has been committed.
 352  *
 353  */
 354 static void vmw_dx_shader_commit_notify(struct vmw_resource *res,
 355                                         enum vmw_cmdbuf_res_state state)
 356 {
 357         struct vmw_dx_shader *shader = vmw_res_to_dx_shader(res);
 358         struct vmw_private *dev_priv = res->dev_priv;
 359
 360         if (state == VMW_CMDBUF_RES_ADD) {
 361                 mutex_lock(&dev_priv->binding_mutex);
 362                 vmw_cotable_add_resource(shader->cotable,
 363                                          &shader->cotable_head);
 364                 shader->committed = true;
 365                 res->id = shader->id;
 366                 mutex_unlock(&dev_priv->binding_mutex);
 367         } else {
 368                 mutex_lock(&dev_priv->binding_mutex);
 369                 list_del_init(&shader->cotable_head);
 370                 shader->committed = false;
 371                 res->id = -1;
 372                 mutex_unlock(&dev_priv->binding_mutex);
 373         }
 374 }
 375
 376 /**
 377  * vmw_dx_shader_unscrub - Have the device reattach a MOB to a DX shader.
 378  *
 379  * @res: The shader resource
 380  *
 381  * This function reverts a scrub operation.
 382  */
 383 static int vmw_dx_shader_unscrub(struct vmw_resource *res)
 384 {
 385         struct vmw_dx_shader *shader = vmw_res_to_dx_shader(res);
 386         struct vmw_private *dev_priv = res->dev_priv;
 387         struct {
 388                 SVGA3dCmdHeader header;
 389                 SVGA3dCmdDXBindShader body;
 390         } *cmd;
 391
 392         if (!list_empty(&shader->cotable_head) || !shader->committed)
 393                 return 0;
 394
 395         cmd = VMW_CMD_CTX_RESERVE(dev_priv, sizeof(*cmd), shader->ctx->id);
 396         if (unlikely(cmd == NULL))
 397                 return -ENOMEM;
 398
 399         cmd->header.id = SVGA_3D_CMD_DX_BIND_SHADER;
 400         cmd->header.size = sizeof(cmd->body);
 401         cmd->body.cid = shader->ctx->id;
 402         cmd->body.shid = shader->id;
 403         cmd->body.mobid = res->guest_memory_bo->tbo.resource->start;
 404         cmd->body.offsetInBytes = res->guest_memory_offset;
 405         vmw_cmd_commit(dev_priv, sizeof(*cmd));
 406
 407         vmw_cotable_add_resource(shader->cotable, &shader->cotable_head);
 408
 409         return 0;
 410 }
 411
 412 /**
 413  * vmw_dx_shader_create - The DX shader create callback
 414  *
 415  * @res: The DX shader resource
 416  *
 417  * The create callback is called as part of resource validation and
 418  * makes sure that we unscrub the shader if it's previously been scrubbed.
 419  */
 420 static int vmw_dx_shader_create(struct vmw_resource *res)
 421 {
 422         struct vmw_private *dev_priv = res->dev_priv;
 423         struct vmw_dx_shader *shader = vmw_res_to_dx_shader(res);
 424         int ret = 0;
 425
 426         WARN_ON_ONCE(!shader->committed);
 427
 428         if (vmw_resource_mob_attached(res)) {
 429                 mutex_lock(&dev_priv->binding_mutex);
 430                 ret = vmw_dx_shader_unscrub(res);
 431                 mutex_unlock(&dev_priv->binding_mutex);
 432         }
 433
 434         res->id = shader->id;
 435         return ret;
 436 }
 437
 438 /**
 439  * vmw_dx_shader_bind - The DX shader bind callback
 440  *
 441  * @res: The DX shader resource
 442  * @val_buf: Pointer to the validate buffer.
 443  *
 444  */
 445 static int vmw_dx_shader_bind(struct vmw_resource *res,
 446                               struct ttm_validate_buffer *val_buf)
 447 {
 448         struct vmw_private *dev_priv = res->dev_priv;
 449         struct ttm_buffer_object *bo = val_buf->bo;
 450
 451         BUG_ON(bo->resource->mem_type != VMW_PL_MOB);
 452         mutex_lock(&dev_priv->binding_mutex);
 453         vmw_dx_shader_unscrub(res);
 454         mutex_unlock(&dev_priv->binding_mutex);
 455
 456         return 0;
 457 }
 458
 459 /**
 460  * vmw_dx_shader_scrub - Have the device unbind a MOB from a DX shader.
 461  *
 462  * @res: The shader resource
 463  *
 464  * This function unbinds a MOB from the DX shader without requiring the
 465  * MOB dma_buffer to be reserved. The driver still considers the MOB bound.
 466  * However, once the driver eventually decides to unbind the MOB, it doesn't
 467  * need to access the context.
 468  */
 469 static int vmw_dx_shader_scrub(struct vmw_resource *res)
 470 {
 471         struct vmw_dx_shader *shader = vmw_res_to_dx_shader(res);
 472         struct vmw_private *dev_priv = res->dev_priv;
 473         struct {
 474                 SVGA3dCmdHeader header;
 475                 SVGA3dCmdDXBindShader body;
 476         } *cmd;
 477
 478         if (list_empty(&shader->cotable_head))
 479                 return 0;
 480
 481         WARN_ON_ONCE(!shader->committed);
 482         cmd = VMW_CMD_RESERVE(dev_priv, sizeof(*cmd));
 483         if (unlikely(cmd == NULL))
 484                 return -ENOMEM;
 485
 486         cmd->header.id = SVGA_3D_CMD_DX_BIND_SHADER;
 487         cmd->header.size = sizeof(cmd->body);
 488         cmd->body.cid = shader->ctx->id;
 489         cmd->body.shid = res->id;
 490         cmd->body.mobid = SVGA3D_INVALID_ID;
 491         cmd->body.offsetInBytes = 0;
 492         vmw_cmd_commit(dev_priv, sizeof(*cmd));
 493         res->id = -1;
 494         list_del_init(&shader->cotable_head);
 495
 496         return 0;
 497 }
 498
 499 /**
 500  * vmw_dx_shader_unbind - The dx shader unbind callback.
 501  *
 502  * @res: The shader resource
 503  * @readback: Whether this is a readback unbind. Currently unused.
 504  * @val_buf: MOB buffer information.
 505  */
 506 static int vmw_dx_shader_unbind(struct vmw_resource *res,
 507                                 bool readback,
 508                                 struct ttm_validate_buffer *val_buf)
 509 {
 510         struct vmw_private *dev_priv = res->dev_priv;
 511         struct vmw_fence_obj *fence;
 512         int ret;
 513
 514         BUG_ON(res->guest_memory_bo->tbo.resource->mem_type != VMW_PL_MOB);
 515
 516         mutex_lock(&dev_priv->binding_mutex);
 517         ret = vmw_dx_shader_scrub(res);
 518         mutex_unlock(&dev_priv->binding_mutex);
 519
 520         if (ret)
 521                 return ret;
 522
 523         (void) vmw_execbuf_fence_commands(NULL, dev_priv,
 524                                           &fence, NULL);
 525         vmw_bo_fence_single(val_buf->bo, fence);
 526
 527         if (likely(fence != NULL))
 528                 vmw_fence_obj_unreference(&fence);
 529
 530         return 0;
 531 }
 532
 533 /**
 534  * vmw_dx_shader_cotable_list_scrub - The cotable unbind_func callback for
 535  * DX shaders.
 536  *
 537  * @dev_priv: Pointer to device private structure.
 538  * @list: The list of cotable resources.
 539  * @readback: Whether the call was part of a readback unbind.
 540  *
 541  * Scrubs all shader MOBs so that any subsequent shader unbind or shader
 542  * destroy operation won't need to swap in the context.
 543  */
 544 void vmw_dx_shader_cotable_list_scrub(struct vmw_private *dev_priv,
 545                                       struct list_head *list,
 546                                       bool readback)
 547 {
 548         struct vmw_dx_shader *entry, *next;
 549
 550         lockdep_assert_held_once(&dev_priv->binding_mutex);
 551
 552         list_for_each_entry_safe(entry, next, list, cotable_head) {
 553                 WARN_ON(vmw_dx_shader_scrub(&entry->res));
 554                 if (!readback)
 555                         entry->committed = false;
 556         }
 557 }
 558
 559 /**
 560  * vmw_dx_shader_res_free - The DX shader free callback
 561  *
 562  * @res: The shader resource
 563  *
 564  * Frees the DX shader resource.
 565  */
 566 static void vmw_dx_shader_res_free(struct vmw_resource *res)
 567 {
 568         struct vmw_dx_shader *shader = vmw_res_to_dx_shader(res);
 569
 570         vmw_resource_unreference(&shader->cotable);
 571         kfree(shader);
 572 }
 573
 574 /**
 575  * vmw_dx_shader_add - Add a shader resource as a command buffer managed
 576  * resource.
 577  *
 578  * @man: The command buffer resource manager.
 579  * @ctx: Pointer to the context resource.
 580  * @user_key: The id used for this shader.
 581  * @shader_type: The shader type.
 582  * @list: The list of staged command buffer managed resources.
 583  */
 584 int vmw_dx_shader_add(struct vmw_cmdbuf_res_manager *man,
 585                       struct vmw_resource *ctx,
 586                       u32 user_key,
 587                       SVGA3dShaderType shader_type,
 588                       struct list_head *list)
 589 {
 590         struct vmw_dx_shader *shader;
 591         struct vmw_resource *res;
 592         struct vmw_private *dev_priv = ctx->dev_priv;
 593         int ret;
 594
 595         if (!vmw_shader_id_ok(user_key, shader_type))
 596                 return -EINVAL;
 597
 598         shader = kmalloc(sizeof(*shader), GFP_KERNEL);
 599         if (!shader) {
 600                 return -ENOMEM;
 601         }
 602
 603         res = &shader->res;
 604         shader->ctx = ctx;
 605         shader->cotable = vmw_resource_reference
 606                 (vmw_context_cotable(ctx, SVGA_COTABLE_DXSHADER));
 607         shader->id = user_key;
 608         shader->committed = false;
 609         INIT_LIST_HEAD(&shader->cotable_head);
 610         ret = vmw_resource_init(dev_priv, res, true,
 611                                 vmw_dx_shader_res_free, &vmw_dx_shader_func);
 612         if (ret)
 613                 goto out_resource_init;
 614
 615         /*
 616          * The user_key name-space is not per shader type for DX shaders,
 617          * so when hashing, use a single zero shader type.
 618          */
 619         ret = vmw_cmdbuf_res_add(man, vmw_cmdbuf_res_shader,
 620                                  vmw_shader_key(user_key, 0),
 621                                  res, list);
 622         if (ret)
 623                 goto out_resource_init;
 624
 625         res->id = shader->id;
 626         res->hw_destroy = vmw_hw_shader_destroy;
 627
 628 out_resource_init:
 629         vmw_resource_unreference(&res);
 630
 631         return ret;
 632 }
 633
 634
 635
 636 /*
 637  * User-space shader management:
 638  */
 639
 640 static struct vmw_resource *
 641 vmw_user_shader_base_to_res(struct ttm_base_object *base)
 642 {
 643         return &(container_of(base, struct vmw_user_shader, base)->
 644                  shader.res);
 645 }
 646
 647 static void vmw_user_shader_free(struct vmw_resource *res)
 648 {
 649         struct vmw_user_shader *ushader =
 650                 container_of(res, struct vmw_user_shader, shader.res);
 651
 652         ttm_base_object_kfree(ushader, base);
 653 }
 654
 655 static void vmw_shader_free(struct vmw_resource *res)
 656 {
 657         struct vmw_shader *shader = vmw_res_to_shader(res);
 658
 659         kfree(shader);
 660 }
 661
 662 /*
 663  * This function is called when user space has no more references on the
 664  * base object. It releases the base-object's reference on the resource object.
 665  */
 666
 667 static void vmw_user_shader_base_release(struct ttm_base_object **p_base)
 668 {
 669         struct ttm_base_object *base = *p_base;
 670         struct vmw_resource *res = vmw_user_shader_base_to_res(base);
 671
 672         *p_base = NULL;
 673         vmw_resource_unreference(&res);
 674 }
 675
 676 int vmw_shader_destroy_ioctl(struct drm_device *dev, void *data,
 677                               struct drm_file *file_priv)
 678 {
 679         struct drm_vmw_shader_arg *arg = (struct drm_vmw_shader_arg *)data;
 680         struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;
 681
 682         return ttm_ref_object_base_unref(tfile, arg->handle);
 683 }
 684
 685 static int vmw_user_shader_alloc(struct vmw_private *dev_priv,
 686                                  struct vmw_bo *buffer,
 687                                  size_t shader_size,
 688                                  size_t offset,
 689                                  SVGA3dShaderType shader_type,
 690                                  uint8_t num_input_sig,
 691                                  uint8_t num_output_sig,
 692                                  struct ttm_object_file *tfile,
 693                                  u32 *handle)
 694 {
 695         struct vmw_user_shader *ushader;
 696         struct vmw_resource *res, *tmp;
 697         int ret;
 698
 699         ushader = kzalloc(sizeof(*ushader), GFP_KERNEL);
 700         if (unlikely(!ushader)) {
 701                 ret = -ENOMEM;
 702                 goto out;
 703         }
 704
 705         res = &ushader->shader.res;
 706         ushader->base.shareable = false;
 707         ushader->base.tfile = NULL;
 708
 709         /*
 710          * From here on, the destructor takes over resource freeing.
 711          */
 712
 713         ret = vmw_gb_shader_init(dev_priv, res, shader_size,
 714                                  offset, shader_type, num_input_sig,
 715                                  num_output_sig, buffer,
 716                                  vmw_user_shader_free);
 717         if (unlikely(ret != 0))
 718                 goto out;
 719
 720         tmp = vmw_resource_reference(res);
 721         ret = ttm_base_object_init(tfile, &ushader->base, false,
 722                                    VMW_RES_SHADER,
 723                                    &vmw_user_shader_base_release);
 724
 725         if (unlikely(ret != 0)) {
 726                 vmw_resource_unreference(&tmp);
 727                 goto out_err;
 728         }
 729
 730         if (handle)
 731                 *handle = ushader->base.handle;
 732 out_err:
 733         vmw_resource_unreference(&res);
 734 out:
 735         return ret;
 736 }
 737
 738
 739 static struct vmw_resource *vmw_shader_alloc(struct vmw_private *dev_priv,
 740                                              struct vmw_bo *buffer,
 741                                              size_t shader_size,
 742                                              size_t offset,
 743                                              SVGA3dShaderType shader_type)
 744 {
 745         struct vmw_shader *shader;
 746         struct vmw_resource *res;
 747         int ret;
 748
 749         shader = kzalloc(sizeof(*shader), GFP_KERNEL);
 750         if (unlikely(!shader)) {
 751                 ret = -ENOMEM;
 752                 goto out_err;
 753         }
 754
 755         res = &shader->res;
 756
 757         /*
 758          * From here on, the destructor takes over resource freeing.
 759          */
 760         ret = vmw_gb_shader_init(dev_priv, res, shader_size,
 761                                  offset, shader_type, 0, 0, buffer,
 762                                  vmw_shader_free);
 763
 764 out_err:
 765         return ret ? ERR_PTR(ret) : res;
 766 }
 767
 768
 769 static int vmw_shader_define(struct drm_device *dev, struct drm_file *file_priv,
 770                              enum drm_vmw_shader_type shader_type_drm,
 771                              u32 buffer_handle, size_t size, size_t offset,
 772                              uint8_t num_input_sig, uint8_t num_output_sig,
 773                              uint32_t *shader_handle)
 774 {
 775         struct vmw_private *dev_priv = vmw_priv(dev);
 776         struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;
 777         struct vmw_bo *buffer = NULL;
 778         SVGA3dShaderType shader_type;
 779         int ret;
 780
 781         if (buffer_handle != SVGA3D_INVALID_ID) {
 782                 ret = vmw_user_bo_lookup(file_priv, buffer_handle, &buffer);
 783                 if (unlikely(ret != 0)) {
 784                         VMW_DEBUG_USER("Couldn't find buffer for shader creation.\n");
 785                         return ret;
 786                 }
 787
 788                 if ((u64)buffer->tbo.base.size < (u64)size + (u64)offset) {
 789                         VMW_DEBUG_USER("Illegal buffer- or shader size.\n");
 790                         ret = -EINVAL;
 791                         goto out_bad_arg;
 792                 }
 793         }
 794
 795         switch (shader_type_drm) {
 796         case drm_vmw_shader_type_vs:
 797                 shader_type = SVGA3D_SHADERTYPE_VS;
 798                 break;
 799         case drm_vmw_shader_type_ps:
 800                 shader_type = SVGA3D_SHADERTYPE_PS;
 801                 break;
 802         default:
 803                 VMW_DEBUG_USER("Illegal shader type.\n");
 804                 ret = -EINVAL;
 805                 goto out_bad_arg;
 806         }
 807
 808         ret = vmw_user_shader_alloc(dev_priv, buffer, size, offset,
 809                                     shader_type, num_input_sig,
 810                                     num_output_sig, tfile, shader_handle);
 811 out_bad_arg:
 812         vmw_user_bo_unref(buffer);
 813         return ret;
 814 }
 815
 816 /**
 817  * vmw_shader_id_ok - Check whether a compat shader user key and
 818  * shader type are within valid bounds.
 819  *
 820  * @user_key: User space id of the shader.
 821  * @shader_type: Shader type.
 822  *
 823  * Returns true if valid false if not.
 824  */
 825 static bool vmw_shader_id_ok(u32 user_key, SVGA3dShaderType shader_type)
 826 {
 827         return user_key <= ((1 << 20) - 1) && (unsigned) shader_type < 16;
 828 }
 829
 830 /**
 831  * vmw_shader_key - Compute a hash key suitable for a compat shader.
 832  *
 833  * @user_key: User space id of the shader.
 834  * @shader_type: Shader type.
 835  *
 836  * Returns a hash key suitable for a command buffer managed resource
 837  * manager hash table.
 838  */
 839 static u32 vmw_shader_key(u32 user_key, SVGA3dShaderType shader_type)
 840 {
 841         return user_key | (shader_type << 20);
 842 }
 843
 844 /**
 845  * vmw_shader_remove - Stage a compat shader for removal.
 846  *
 847  * @man: Pointer to the compat shader manager identifying the shader namespace.
 848  * @user_key: The key that is used to identify the shader. The key is
 849  * unique to the shader type.
 850  * @shader_type: Shader type.
 851  * @list: Caller's list of staged command buffer resource actions.
 852  */
 853 int vmw_shader_remove(struct vmw_cmdbuf_res_manager *man,
 854                       u32 user_key, SVGA3dShaderType shader_type,
 855                       struct list_head *list)
 856 {
 857         struct vmw_resource *dummy;
 858
 859         if (!vmw_shader_id_ok(user_key, shader_type))
 860                 return -EINVAL;
 861
 862         return vmw_cmdbuf_res_remove(man, vmw_cmdbuf_res_shader,
 863                                      vmw_shader_key(user_key, shader_type),
 864                                      list, &dummy);
 865 }
 866
 867 /**
 868  * vmw_compat_shader_add - Create a compat shader and stage it for addition
 869  * as a command buffer managed resource.
 870  *
 871  * @dev_priv: Pointer to device private structure.
 872  * @man: Pointer to the compat shader manager identifying the shader namespace.
 873  * @user_key: The key that is used to identify the shader. The key is
 874  * unique to the shader type.
 875  * @bytecode: Pointer to the bytecode of the shader.
 876  * @shader_type: Shader type.
 877  * @size: Command size.
 878  * @list: Caller's list of staged command buffer resource actions.
 879  *
 880  */
 881 int vmw_compat_shader_add(struct vmw_private *dev_priv,
 882                           struct vmw_cmdbuf_res_manager *man,
 883                           u32 user_key, const void *bytecode,
 884                           SVGA3dShaderType shader_type,
 885                           size_t size,
 886                           struct list_head *list)
 887 {
 888         struct ttm_operation_ctx ctx = { false, true };
 889         struct vmw_bo *buf;
 890         struct ttm_bo_kmap_obj map;
 891         bool is_iomem;
 892         int ret;
 893         struct vmw_resource *res;
 894         struct vmw_bo_params bo_params = {
 895                 .domain = VMW_BO_DOMAIN_SYS,
 896                 .busy_domain = VMW_BO_DOMAIN_SYS,
 897                 .bo_type = ttm_bo_type_device,
 898                 .size = size,
 899                 .pin = true
 900         };
 901
 902         if (!vmw_shader_id_ok(user_key, shader_type))
 903                 return -EINVAL;
 904
 905         ret = vmw_bo_create(dev_priv, &bo_params, &buf);
 906         if (unlikely(ret != 0))
 907                 goto out;
 908
 909         ret = ttm_bo_reserve(&buf->tbo, false, true, NULL);
 910         if (unlikely(ret != 0))
 911                 goto no_reserve;
 912
 913         /* Map and copy shader bytecode. */
 914         ret = ttm_bo_kmap(&buf->tbo, 0, PFN_UP(size), &map);
 915         if (unlikely(ret != 0)) {
 916                 ttm_bo_unreserve(&buf->tbo);
 917                 goto no_reserve;
 918         }
 919
 920         memcpy(ttm_kmap_obj_virtual(&map, &is_iomem), bytecode, size);
 921         WARN_ON(is_iomem);
 922
 923         ttm_bo_kunmap(&map);
 924         ret = ttm_bo_validate(&buf->tbo, &buf->placement, &ctx);
 925         WARN_ON(ret != 0);
 926         ttm_bo_unreserve(&buf->tbo);
 927
 928         res = vmw_shader_alloc(dev_priv, buf, size, 0, shader_type);
 929         if (unlikely(ret != 0))
 930                 goto no_reserve;
 931
 932         ret = vmw_cmdbuf_res_add(man, vmw_cmdbuf_res_shader,
 933                                  vmw_shader_key(user_key, shader_type),
 934                                  res, list);
 935         vmw_resource_unreference(&res);
 936 no_reserve:
 937         vmw_bo_unreference(&buf);
 938 out:
 939         return ret;
 940 }
 941
 942 /**
 943  * vmw_shader_lookup - Look up a compat shader
 944  *
 945  * @man: Pointer to the command buffer managed resource manager identifying
 946  * the shader namespace.
 947  * @user_key: The user space id of the shader.
 948  * @shader_type: The shader type.
 949  *
 950  * Returns a refcounted pointer to a struct vmw_resource if the shader was
 951  * found. An error pointer otherwise.
 952  */
 953 struct vmw_resource *
 954 vmw_shader_lookup(struct vmw_cmdbuf_res_manager *man,
 955                   u32 user_key,
 956                   SVGA3dShaderType shader_type)
 957 {
 958         if (!vmw_shader_id_ok(user_key, shader_type))
 959                 return ERR_PTR(-EINVAL);
 960
 961         return vmw_cmdbuf_res_lookup(man, vmw_cmdbuf_res_shader,
 962                                      vmw_shader_key(user_key, shader_type));
 963 }
 964
 965 int vmw_shader_define_ioctl(struct drm_device *dev, void *data,
 966                              struct drm_file *file_priv)
 967 {
 968         struct drm_vmw_shader_create_arg *arg =
 969                 (struct drm_vmw_shader_create_arg *)data;
 970
 971         return vmw_shader_define(dev, file_priv, arg->shader_type,
 972                                  arg->buffer_handle,
 973                                  arg->size, arg->offset,
 974                                  0, 0,
 975                                  &arg->shader_handle);
 976 }