drivers/gpu/drm/vmwgfx/vmwgfx_context.c

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