drivers/gpu/drm/vmwgfx/vmwgfx_cotable.c

   1 // SPDX-License-Identifier: GPL-2.0 OR MIT
   2 /**************************************************************************
   3  *
   4  * Copyright 2014-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  * Treat context OTables as resources to make use of the resource
  29  * backing MOB eviction mechanism, that is used to read back the COTable
  30  * whenever the backing MOB is evicted.
  31  */
  32
  33 #include "vmwgfx_bo.h"
  34 #include "vmwgfx_drv.h"
  35 #include "vmwgfx_mksstat.h"
  36 #include "vmwgfx_resource_priv.h"
  37 #include "vmwgfx_so.h"
  38
  39 #include <drm/ttm/ttm_placement.h>
  40
  41 /**
  42  * struct vmw_cotable - Context Object Table resource
  43  *
  44  * @res: struct vmw_resource we are deriving from.
  45  * @ctx: non-refcounted pointer to the owning context.
  46  * @size_read_back: Size of data read back during eviction.
  47  * @seen_entries: Seen entries in command stream for this cotable.
  48  * @type: The cotable type.
  49  * @scrubbed: Whether the cotable has been scrubbed.
  50  * @resource_list: List of resources in the cotable.
  51  */
  52 struct vmw_cotable {
  53         struct vmw_resource res;
  54         struct vmw_resource *ctx;
  55         size_t size_read_back;
  56         int seen_entries;
  57         u32 type;
  58         bool scrubbed;
  59         struct list_head resource_list;
  60 };
  61
  62 /**
  63  * struct vmw_cotable_info - Static info about cotable types
  64  *
  65  * @min_initial_entries: Min number of initial intries at cotable allocation
  66  * for this cotable type.
  67  * @size: Size of each entry.
  68  * @unbind_func: Unbind call-back function.
  69  */
  70 struct vmw_cotable_info {
  71         u32 min_initial_entries;
  72         u32 size;
  73         void (*unbind_func)(struct vmw_private *, struct list_head *,
  74                             bool);
  75 };
  76
  77
  78 /*
  79  * Getting the initial size right is difficult because it all depends
  80  * on what the userspace is doing. The sizes will be aligned up to
  81  * a PAGE_SIZE so we just want to make sure that for majority of apps
  82  * the initial number of entries doesn't require an immediate resize.
  83  * For all cotables except SVGACOTableDXElementLayoutEntry and
  84  * SVGACOTableDXBlendStateEntry the initial number of entries fits
  85  * within the PAGE_SIZE. For SVGACOTableDXElementLayoutEntry and
  86  * SVGACOTableDXBlendStateEntry we want to reserve two pages,
  87  * because that's what all apps will require initially.
  88  */
  89 static const struct vmw_cotable_info co_info[] = {
  90         {1, sizeof(SVGACOTableDXRTViewEntry), &vmw_view_cotable_list_destroy},
  91         {1, sizeof(SVGACOTableDXDSViewEntry), &vmw_view_cotable_list_destroy},
  92         {1, sizeof(SVGACOTableDXSRViewEntry), &vmw_view_cotable_list_destroy},
  93         {PAGE_SIZE/sizeof(SVGACOTableDXElementLayoutEntry) + 1, sizeof(SVGACOTableDXElementLayoutEntry), NULL},
  94         {PAGE_SIZE/sizeof(SVGACOTableDXBlendStateEntry) + 1, sizeof(SVGACOTableDXBlendStateEntry), NULL},
  95         {1, sizeof(SVGACOTableDXDepthStencilEntry), NULL},
  96         {1, sizeof(SVGACOTableDXRasterizerStateEntry), NULL},
  97         {1, sizeof(SVGACOTableDXSamplerEntry), NULL},
  98         {1, sizeof(SVGACOTableDXStreamOutputEntry), &vmw_dx_streamoutput_cotable_list_scrub},
  99         {1, sizeof(SVGACOTableDXQueryEntry), NULL},
 100         {1, sizeof(SVGACOTableDXShaderEntry), &vmw_dx_shader_cotable_list_scrub},
 101         {1, sizeof(SVGACOTableDXUAViewEntry), &vmw_view_cotable_list_destroy}
 102 };
 103
 104 /*
 105  * Cotables with bindings that we remove must be scrubbed first,
 106  * otherwise, the device will swap in an invalid context when we remove
 107  * bindings before scrubbing a cotable...
 108  */
 109 const SVGACOTableType vmw_cotable_scrub_order[] = {
 110         SVGA_COTABLE_RTVIEW,
 111         SVGA_COTABLE_DSVIEW,
 112         SVGA_COTABLE_SRVIEW,
 113         SVGA_COTABLE_DXSHADER,
 114         SVGA_COTABLE_ELEMENTLAYOUT,
 115         SVGA_COTABLE_BLENDSTATE,
 116         SVGA_COTABLE_DEPTHSTENCIL,
 117         SVGA_COTABLE_RASTERIZERSTATE,
 118         SVGA_COTABLE_SAMPLER,
 119         SVGA_COTABLE_STREAMOUTPUT,
 120         SVGA_COTABLE_DXQUERY,
 121         SVGA_COTABLE_UAVIEW,
 122 };
 123
 124 static int vmw_cotable_bind(struct vmw_resource *res,
 125                             struct ttm_validate_buffer *val_buf);
 126 static int vmw_cotable_unbind(struct vmw_resource *res,
 127                               bool readback,
 128                               struct ttm_validate_buffer *val_buf);
 129 static int vmw_cotable_create(struct vmw_resource *res);
 130 static int vmw_cotable_destroy(struct vmw_resource *res);
 131
 132 static const struct vmw_res_func vmw_cotable_func = {
 133         .res_type = vmw_res_cotable,
 134         .needs_guest_memory = true,
 135         .may_evict = true,
 136         .prio = 3,
 137         .dirty_prio = 3,
 138         .type_name = "context guest backed object tables",
 139         .domain = VMW_BO_DOMAIN_MOB,
 140         .busy_domain = VMW_BO_DOMAIN_MOB,
 141         .create = vmw_cotable_create,
 142         .destroy = vmw_cotable_destroy,
 143         .bind = vmw_cotable_bind,
 144         .unbind = vmw_cotable_unbind,
 145 };
 146
 147 /**
 148  * vmw_cotable - Convert a struct vmw_resource pointer to a struct
 149  * vmw_cotable pointer
 150  *
 151  * @res: Pointer to the resource.
 152  */
 153 static struct vmw_cotable *vmw_cotable(struct vmw_resource *res)
 154 {
 155         return container_of(res, struct vmw_cotable, res);
 156 }
 157
 158 /**
 159  * vmw_cotable_destroy - Cotable resource destroy callback
 160  *
 161  * @res: Pointer to the cotable resource.
 162  *
 163  * There is no device cotable destroy command, so this function only
 164  * makes sure that the resource id is set to invalid.
 165  */
 166 static int vmw_cotable_destroy(struct vmw_resource *res)
 167 {
 168         res->id = -1;
 169         return 0;
 170 }
 171
 172 /**
 173  * vmw_cotable_unscrub - Undo a cotable unscrub operation
 174  *
 175  * @res: Pointer to the cotable resource
 176  *
 177  * This function issues commands to (re)bind the cotable to
 178  * its backing mob, which needs to be validated and reserved at this point.
 179  * This is identical to bind() except the function interface looks different.
 180  */
 181 static int vmw_cotable_unscrub(struct vmw_resource *res)
 182 {
 183         struct vmw_cotable *vcotbl = vmw_cotable(res);
 184         struct vmw_private *dev_priv = res->dev_priv;
 185         struct ttm_buffer_object *bo = &res->guest_memory_bo->tbo;
 186         struct {
 187                 SVGA3dCmdHeader header;
 188                 SVGA3dCmdDXSetCOTable body;
 189         } *cmd;
 190
 191         WARN_ON_ONCE(bo->resource->mem_type != VMW_PL_MOB);
 192         dma_resv_assert_held(bo->base.resv);
 193
 194         cmd = VMW_CMD_RESERVE(dev_priv, sizeof(*cmd));
 195         if (!cmd)
 196                 return -ENOMEM;
 197
 198         WARN_ON(vcotbl->ctx->id == SVGA3D_INVALID_ID);
 199         WARN_ON(bo->resource->mem_type != VMW_PL_MOB);
 200         cmd->header.id = SVGA_3D_CMD_DX_SET_COTABLE;
 201         cmd->header.size = sizeof(cmd->body);
 202         cmd->body.cid = vcotbl->ctx->id;
 203         cmd->body.type = vcotbl->type;
 204         cmd->body.mobid = bo->resource->start;
 205         cmd->body.validSizeInBytes = vcotbl->size_read_back;
 206
 207         vmw_cmd_commit_flush(dev_priv, sizeof(*cmd));
 208         vcotbl->scrubbed = false;
 209
 210         return 0;
 211 }
 212
 213 /**
 214  * vmw_cotable_bind - Undo a cotable unscrub operation
 215  *
 216  * @res: Pointer to the cotable resource
 217  * @val_buf: Pointer to a struct ttm_validate_buffer prepared by the caller
 218  * for convenience / fencing.
 219  *
 220  * This function issues commands to (re)bind the cotable to
 221  * its backing mob, which needs to be validated and reserved at this point.
 222  */
 223 static int vmw_cotable_bind(struct vmw_resource *res,
 224                             struct ttm_validate_buffer *val_buf)
 225 {
 226         /*
 227          * The create() callback may have changed @res->backup without
 228          * the caller noticing, and with val_buf->bo still pointing to
 229          * the old backup buffer. Although hackish, and not used currently,
 230          * take the opportunity to correct the value here so that it's not
 231          * misused in the future.
 232          */
 233         val_buf->bo = &res->guest_memory_bo->tbo;
 234
 235         return vmw_cotable_unscrub(res);
 236 }
 237
 238 /**
 239  * vmw_cotable_scrub - Scrub the cotable from the device.
 240  *
 241  * @res: Pointer to the cotable resource.
 242  * @readback: Whether initiate a readback of the cotable data to the backup
 243  * buffer.
 244  *
 245  * In some situations (context swapouts) it might be desirable to make the
 246  * device forget about the cotable without performing a full unbind. A full
 247  * unbind requires reserved backup buffers and it might not be possible to
 248  * reserve them due to locking order violation issues. The vmw_cotable_scrub
 249  * function implements a partial unbind() without that requirement but with the
 250  * following restrictions.
 251  * 1) Before the cotable is again used by the GPU, vmw_cotable_unscrub() must
 252  *    be called.
 253  * 2) Before the cotable backing buffer is used by the CPU, or during the
 254  *    resource destruction, vmw_cotable_unbind() must be called.
 255  */
 256 int vmw_cotable_scrub(struct vmw_resource *res, bool readback)
 257 {
 258         struct vmw_cotable *vcotbl = vmw_cotable(res);
 259         struct vmw_private *dev_priv = res->dev_priv;
 260         size_t submit_size;
 261
 262         struct {
 263                 SVGA3dCmdHeader header;
 264                 SVGA3dCmdDXReadbackCOTable body;
 265         } *cmd0;
 266         struct {
 267                 SVGA3dCmdHeader header;
 268                 SVGA3dCmdDXSetCOTable body;
 269         } *cmd1;
 270
 271         if (vcotbl->scrubbed)
 272                 return 0;
 273
 274         if (co_info[vcotbl->type].unbind_func)
 275                 co_info[vcotbl->type].unbind_func(dev_priv,
 276                                                   &vcotbl->resource_list,
 277                                                   readback);
 278         submit_size = sizeof(*cmd1);
 279         if (readback)
 280                 submit_size += sizeof(*cmd0);
 281
 282         cmd1 = VMW_CMD_RESERVE(dev_priv, submit_size);
 283         if (!cmd1)
 284                 return -ENOMEM;
 285
 286         vcotbl->size_read_back = 0;
 287         if (readback) {
 288                 cmd0 = (void *) cmd1;
 289                 cmd0->header.id = SVGA_3D_CMD_DX_READBACK_COTABLE;
 290                 cmd0->header.size = sizeof(cmd0->body);
 291                 cmd0->body.cid = vcotbl->ctx->id;
 292                 cmd0->body.type = vcotbl->type;
 293                 cmd1 = (void *) &cmd0[1];
 294                 vcotbl->size_read_back = res->guest_memory_size;
 295         }
 296         cmd1->header.id = SVGA_3D_CMD_DX_SET_COTABLE;
 297         cmd1->header.size = sizeof(cmd1->body);
 298         cmd1->body.cid = vcotbl->ctx->id;
 299         cmd1->body.type = vcotbl->type;
 300         cmd1->body.mobid = SVGA3D_INVALID_ID;
 301         cmd1->body.validSizeInBytes = 0;
 302         vmw_cmd_commit_flush(dev_priv, submit_size);
 303         vcotbl->scrubbed = true;
 304
 305         /* Trigger a create() on next validate. */
 306         res->id = -1;
 307
 308         return 0;
 309 }
 310
 311 /**
 312  * vmw_cotable_unbind - Cotable resource unbind callback
 313  *
 314  * @res: Pointer to the cotable resource.
 315  * @readback: Whether to read back cotable data to the backup buffer.
 316  * @val_buf: Pointer to a struct ttm_validate_buffer prepared by the caller
 317  * for convenience / fencing.
 318  *
 319  * Unbinds the cotable from the device and fences the backup buffer.
 320  */
 321 static int vmw_cotable_unbind(struct vmw_resource *res,
 322                               bool readback,
 323                               struct ttm_validate_buffer *val_buf)
 324 {
 325         struct vmw_cotable *vcotbl = vmw_cotable(res);
 326         struct vmw_private *dev_priv = res->dev_priv;
 327         struct ttm_buffer_object *bo = val_buf->bo;
 328         struct vmw_fence_obj *fence;
 329
 330         if (!vmw_resource_mob_attached(res))
 331                 return 0;
 332
 333         WARN_ON_ONCE(bo->resource->mem_type != VMW_PL_MOB);
 334         dma_resv_assert_held(bo->base.resv);
 335
 336         mutex_lock(&dev_priv->binding_mutex);
 337         if (!vcotbl->scrubbed)
 338                 vmw_dx_context_scrub_cotables(vcotbl->ctx, readback);
 339         mutex_unlock(&dev_priv->binding_mutex);
 340         (void) vmw_execbuf_fence_commands(NULL, dev_priv, &fence, NULL);
 341         vmw_bo_fence_single(bo, fence);
 342         if (likely(fence != NULL))
 343                 vmw_fence_obj_unreference(&fence);
 344
 345         return 0;
 346 }
 347
 348 /**
 349  * vmw_cotable_readback - Read back a cotable without unbinding.
 350  *
 351  * @res: The cotable resource.
 352  *
 353  * Reads back a cotable to its backing mob without scrubbing the MOB from
 354  * the cotable. The MOB is fenced for subsequent CPU access.
 355  */
 356 static int vmw_cotable_readback(struct vmw_resource *res)
 357 {
 358         struct vmw_cotable *vcotbl = vmw_cotable(res);
 359         struct vmw_private *dev_priv = res->dev_priv;
 360
 361         struct {
 362                 SVGA3dCmdHeader header;
 363                 SVGA3dCmdDXReadbackCOTable body;
 364         } *cmd;
 365         struct vmw_fence_obj *fence;
 366
 367         if (!vcotbl->scrubbed) {
 368                 cmd = VMW_CMD_RESERVE(dev_priv, sizeof(*cmd));
 369                 if (!cmd)
 370                         return -ENOMEM;
 371
 372                 cmd->header.id = SVGA_3D_CMD_DX_READBACK_COTABLE;
 373                 cmd->header.size = sizeof(cmd->body);
 374                 cmd->body.cid = vcotbl->ctx->id;
 375                 cmd->body.type = vcotbl->type;
 376                 vcotbl->size_read_back = res->guest_memory_size;
 377                 vmw_cmd_commit(dev_priv, sizeof(*cmd));
 378         }
 379
 380         (void) vmw_execbuf_fence_commands(NULL, dev_priv, &fence, NULL);
 381         vmw_bo_fence_single(&res->guest_memory_bo->tbo, fence);
 382         vmw_fence_obj_unreference(&fence);
 383
 384         return 0;
 385 }
 386
 387 /**
 388  * vmw_cotable_resize - Resize a cotable.
 389  *
 390  * @res: The cotable resource.
 391  * @new_size: The new size.
 392  *
 393  * Resizes a cotable and binds the new backup buffer.
 394  * On failure the cotable is left intact.
 395  * Important! This function may not fail once the MOB switch has been
 396  * committed to hardware. That would put the device context in an
 397  * invalid state which we can't currently recover from.
 398  */
 399 static int vmw_cotable_resize(struct vmw_resource *res, size_t new_size)
 400 {
 401         struct ttm_operation_ctx ctx = { false, false };
 402         struct vmw_private *dev_priv = res->dev_priv;
 403         struct vmw_cotable *vcotbl = vmw_cotable(res);
 404         struct vmw_bo *buf, *old_buf = res->guest_memory_bo;
 405         struct ttm_buffer_object *bo, *old_bo = &res->guest_memory_bo->tbo;
 406         size_t old_size = res->guest_memory_size;
 407         size_t old_size_read_back = vcotbl->size_read_back;
 408         size_t cur_size_read_back;
 409         struct ttm_bo_kmap_obj old_map, new_map;
 410         int ret;
 411         size_t i;
 412         struct vmw_bo_params bo_params = {
 413                 .domain = VMW_BO_DOMAIN_MOB,
 414                 .busy_domain = VMW_BO_DOMAIN_MOB,
 415                 .bo_type = ttm_bo_type_device,
 416                 .size = new_size,
 417                 .pin = true
 418         };
 419
 420         MKS_STAT_TIME_DECL(MKSSTAT_KERN_COTABLE_RESIZE);
 421         MKS_STAT_TIME_PUSH(MKSSTAT_KERN_COTABLE_RESIZE);
 422
 423         ret = vmw_cotable_readback(res);
 424         if (ret)
 425                 goto out_done;
 426
 427         cur_size_read_back = vcotbl->size_read_back;
 428         vcotbl->size_read_back = old_size_read_back;
 429
 430         /*
 431          * While device is processing, Allocate and reserve a buffer object
 432          * for the new COTable. Initially pin the buffer object to make sure
 433          * we can use tryreserve without failure.
 434          */
 435         ret = vmw_gem_object_create(dev_priv, &bo_params, &buf);
 436         if (ret) {
 437                 DRM_ERROR("Failed initializing new cotable MOB.\n");
 438                 goto out_done;
 439         }
 440
 441         bo = &buf->tbo;
 442         WARN_ON_ONCE(ttm_bo_reserve(bo, false, true, NULL));
 443
 444         ret = ttm_bo_wait(old_bo, false, false);
 445         if (unlikely(ret != 0)) {
 446                 DRM_ERROR("Failed waiting for cotable unbind.\n");
 447                 goto out_wait;
 448         }
 449
 450         /*
 451          * Do a page by page copy of COTables. This eliminates slow vmap()s.
 452          * This should really be a TTM utility.
 453          */
 454         for (i = 0; i < PFN_UP(old_bo->resource->size); ++i) {
 455                 bool dummy;
 456
 457                 ret = ttm_bo_kmap(old_bo, i, 1, &old_map);
 458                 if (unlikely(ret != 0)) {
 459                         DRM_ERROR("Failed mapping old COTable on resize.\n");
 460                         goto out_wait;
 461                 }
 462                 ret = ttm_bo_kmap(bo, i, 1, &new_map);
 463                 if (unlikely(ret != 0)) {
 464                         DRM_ERROR("Failed mapping new COTable on resize.\n");
 465                         goto out_map_new;
 466                 }
 467                 memcpy(ttm_kmap_obj_virtual(&new_map, &dummy),
 468                        ttm_kmap_obj_virtual(&old_map, &dummy),
 469                        PAGE_SIZE);
 470                 ttm_bo_kunmap(&new_map);
 471                 ttm_bo_kunmap(&old_map);
 472         }
 473
 474         /* Unpin new buffer, and switch backup buffers. */
 475         vmw_bo_placement_set(buf,
 476                              VMW_BO_DOMAIN_MOB,
 477                              VMW_BO_DOMAIN_MOB);
 478         ret = ttm_bo_validate(bo, &buf->placement, &ctx);
 479         if (unlikely(ret != 0)) {
 480                 DRM_ERROR("Failed validating new COTable backup buffer.\n");
 481                 goto out_wait;
 482         }
 483
 484         vmw_resource_mob_detach(res);
 485         res->guest_memory_bo = buf;
 486         res->guest_memory_size = new_size;
 487         vcotbl->size_read_back = cur_size_read_back;
 488
 489         /*
 490          * Now tell the device to switch. If this fails, then we need to
 491          * revert the full resize.
 492          */
 493         ret = vmw_cotable_unscrub(res);
 494         if (ret) {
 495                 DRM_ERROR("Failed switching COTable backup buffer.\n");
 496                 res->guest_memory_bo = old_buf;
 497                 res->guest_memory_size = old_size;
 498                 vcotbl->size_read_back = old_size_read_back;
 499                 vmw_resource_mob_attach(res);
 500                 goto out_wait;
 501         }
 502
 503         vmw_resource_mob_attach(res);
 504         /* Let go of the old mob. */
 505         vmw_user_bo_unref(&old_buf);
 506         res->id = vcotbl->type;
 507
 508         ret = dma_resv_reserve_fences(bo->base.resv, 1);
 509         if (unlikely(ret))
 510                 goto out_wait;
 511
 512         /* Release the pin acquired in vmw_bo_create */
 513         ttm_bo_unpin(bo);
 514
 515         MKS_STAT_TIME_POP(MKSSTAT_KERN_COTABLE_RESIZE);
 516
 517         return 0;
 518
 519 out_map_new:
 520         ttm_bo_kunmap(&old_map);
 521 out_wait:
 522         ttm_bo_unpin(bo);
 523         ttm_bo_unreserve(bo);
 524         vmw_user_bo_unref(&buf);
 525
 526 out_done:
 527         MKS_STAT_TIME_POP(MKSSTAT_KERN_COTABLE_RESIZE);
 528
 529         return ret;
 530 }
 531
 532 /**
 533  * vmw_cotable_create - Cotable resource create callback
 534  *
 535  * @res: Pointer to a cotable resource.
 536  *
 537  * There is no separate create command for cotables, so this callback, which
 538  * is called before bind() in the validation sequence is instead used for two
 539  * things.
 540  * 1) Unscrub the cotable if it is scrubbed and still attached to a backup
 541  *    buffer.
 542  * 2) Resize the cotable if needed.
 543  */
 544 static int vmw_cotable_create(struct vmw_resource *res)
 545 {
 546         struct vmw_cotable *vcotbl = vmw_cotable(res);
 547         size_t new_size = res->guest_memory_size;
 548         size_t needed_size;
 549         int ret;
 550
 551         /* Check whether we need to resize the cotable */
 552         needed_size = (vcotbl->seen_entries + 1) * co_info[vcotbl->type].size;
 553         while (needed_size > new_size)
 554                 new_size *= 2;
 555
 556         if (likely(new_size <= res->guest_memory_size)) {
 557                 if (vcotbl->scrubbed && vmw_resource_mob_attached(res)) {
 558                         ret = vmw_cotable_unscrub(res);
 559                         if (ret)
 560                                 return ret;
 561                 }
 562                 res->id = vcotbl->type;
 563                 return 0;
 564         }
 565
 566         return vmw_cotable_resize(res, new_size);
 567 }
 568
 569 /**
 570  * vmw_hw_cotable_destroy - Cotable hw_destroy callback
 571  *
 572  * @res: Pointer to a cotable resource.
 573  *
 574  * The final (part of resource destruction) destroy callback.
 575  */
 576 static void vmw_hw_cotable_destroy(struct vmw_resource *res)
 577 {
 578         (void) vmw_cotable_destroy(res);
 579 }
 580
 581 /**
 582  * vmw_cotable_free - Cotable resource destructor
 583  *
 584  * @res: Pointer to a cotable resource.
 585  */
 586 static void vmw_cotable_free(struct vmw_resource *res)
 587 {
 588         kfree(res);
 589 }
 590
 591 /**
 592  * vmw_cotable_alloc - Create a cotable resource
 593  *
 594  * @dev_priv: Pointer to a device private struct.
 595  * @ctx: Pointer to the context resource.
 596  * The cotable resource will not add a refcount.
 597  * @type: The cotable type.
 598  */
 599 struct vmw_resource *vmw_cotable_alloc(struct vmw_private *dev_priv,
 600                                        struct vmw_resource *ctx,
 601                                        u32 type)
 602 {
 603         struct vmw_cotable *vcotbl;
 604         int ret;
 605         u32 num_entries;
 606
 607         vcotbl = kzalloc(sizeof(*vcotbl), GFP_KERNEL);
 608         if (unlikely(!vcotbl)) {
 609                 ret = -ENOMEM;
 610                 goto out_no_alloc;
 611         }
 612
 613         ret = vmw_resource_init(dev_priv, &vcotbl->res, true,
 614                                 vmw_cotable_free, &vmw_cotable_func);
 615         if (unlikely(ret != 0))
 616                 goto out_no_init;
 617
 618         INIT_LIST_HEAD(&vcotbl->resource_list);
 619         vcotbl->res.id = type;
 620         vcotbl->res.guest_memory_size = PAGE_SIZE;
 621         num_entries = PAGE_SIZE / co_info[type].size;
 622         if (num_entries < co_info[type].min_initial_entries) {
 623                 vcotbl->res.guest_memory_size = co_info[type].min_initial_entries *
 624                         co_info[type].size;
 625                 vcotbl->res.guest_memory_size = PFN_ALIGN(vcotbl->res.guest_memory_size);
 626         }
 627
 628         vcotbl->scrubbed = true;
 629         vcotbl->seen_entries = -1;
 630         vcotbl->type = type;
 631         vcotbl->ctx = ctx;
 632
 633         vcotbl->res.hw_destroy = vmw_hw_cotable_destroy;
 634
 635         return &vcotbl->res;
 636
 637 out_no_init:
 638         kfree(vcotbl);
 639 out_no_alloc:
 640         return ERR_PTR(ret);
 641 }
 642
 643 /**
 644  * vmw_cotable_notify - Notify the cotable about an item creation
 645  *
 646  * @res: Pointer to a cotable resource.
 647  * @id: Item id.
 648  */
 649 int vmw_cotable_notify(struct vmw_resource *res, int id)
 650 {
 651         struct vmw_cotable *vcotbl = vmw_cotable(res);
 652
 653         if (id < 0 || id >= SVGA_COTABLE_MAX_IDS) {
 654                 DRM_ERROR("Illegal COTable id. Type is %u. Id is %d\n",
 655                           (unsigned) vcotbl->type, id);
 656                 return -EINVAL;
 657         }
 658
 659         if (vcotbl->seen_entries < id) {
 660                 /* Trigger a call to create() on next validate */
 661                 res->id = -1;
 662                 vcotbl->seen_entries = id;
 663         }
 664
 665         return 0;
 666 }
 667
 668 /**
 669  * vmw_cotable_add_resource - add a view to the cotable's list of active views.
 670  *
 671  * @res: pointer struct vmw_resource representing the cotable.
 672  * @head: pointer to the struct list_head member of the resource, dedicated
 673  * to the cotable active resource list.
 674  */
 675 void vmw_cotable_add_resource(struct vmw_resource *res, struct list_head *head)
 676 {
 677         struct vmw_cotable *vcotbl =
 678                 container_of(res, struct vmw_cotable, res);
 679
 680         list_add_tail(head, &vcotbl->resource_list);
 681 }