drivers/gpu/drm/vmwgfx/vmwgfx_bo.c

   1 // SPDX-License-Identifier: GPL-2.0 OR MIT
   2 /**************************************************************************
   3  *
   4  * Copyright © 2011-2023 VMware, Inc., Palo Alto, CA., USA
   5  * All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the
   9  * "Software"), to deal in the Software without restriction, including
  10  * without limitation the rights to use, copy, modify, merge, publish,
  11  * distribute, sub license, and/or sell copies of the Software, and to
  12  * permit persons to whom the Software is furnished to do so, subject to
  13  * the following conditions:
  14  *
  15  * The above copyright notice and this permission notice (including the
  16  * next paragraph) shall be included in all copies or substantial portions
  17  * of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  22  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
  23  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  24  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  25  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  *
  27  **************************************************************************/
  28
  29 #include "vmwgfx_bo.h"
  30 #include "vmwgfx_drv.h"
  31
  32
  33 #include <drm/ttm/ttm_placement.h>
  34
  35 static void vmw_bo_release(struct vmw_bo *vbo)
  36 {
  37         WARN_ON(vbo->tbo.base.funcs &&
  38                 kref_read(&vbo->tbo.base.refcount) != 0);
  39         vmw_bo_unmap(vbo);
  40         drm_gem_object_release(&vbo->tbo.base);
  41 }
  42
  43 /**
  44  * vmw_bo_free - vmw_bo destructor
  45  *
  46  * @bo: Pointer to the embedded struct ttm_buffer_object
  47  */
  48 static void vmw_bo_free(struct ttm_buffer_object *bo)
  49 {
  50         struct vmw_bo *vbo = to_vmw_bo(&bo->base);
  51
  52         WARN_ON(vbo->dirty);
  53         WARN_ON(!RB_EMPTY_ROOT(&vbo->res_tree));
  54         vmw_bo_release(vbo);
  55         kfree(vbo);
  56 }
  57
  58 /**
  59  * vmw_bo_pin_in_placement - Validate a buffer to placement.
  60  *
  61  * @dev_priv:  Driver private.
  62  * @buf:  DMA buffer to move.
  63  * @placement:  The placement to pin it.
  64  * @interruptible:  Use interruptible wait.
  65  * Return: Zero on success, Negative error code on failure. In particular
  66  * -ERESTARTSYS if interrupted by a signal
  67  */
  68 static int vmw_bo_pin_in_placement(struct vmw_private *dev_priv,
  69                                    struct vmw_bo *buf,
  70                                    struct ttm_placement *placement,
  71                                    bool interruptible)
  72 {
  73         struct ttm_operation_ctx ctx = {interruptible, false };
  74         struct ttm_buffer_object *bo = &buf->tbo;
  75         int ret;
  76
  77         vmw_execbuf_release_pinned_bo(dev_priv);
  78
  79         ret = ttm_bo_reserve(bo, interruptible, false, NULL);
  80         if (unlikely(ret != 0))
  81                 goto err;
  82
  83         ret = ttm_bo_validate(bo, placement, &ctx);
  84         if (!ret)
  85                 vmw_bo_pin_reserved(buf, true);
  86
  87         ttm_bo_unreserve(bo);
  88 err:
  89         return ret;
  90 }
  91
  92
  93 /**
  94  * vmw_bo_pin_in_vram_or_gmr - Move a buffer to vram or gmr.
  95  *
  96  * This function takes the reservation_sem in write mode.
  97  * Flushes and unpins the query bo to avoid failures.
  98  *
  99  * @dev_priv:  Driver private.
 100  * @buf:  DMA buffer to move.
 101  * @interruptible:  Use interruptible wait.
 102  * Return: Zero on success, Negative error code on failure. In particular
 103  * -ERESTARTSYS if interrupted by a signal
 104  */
 105 int vmw_bo_pin_in_vram_or_gmr(struct vmw_private *dev_priv,
 106                               struct vmw_bo *buf,
 107                               bool interruptible)
 108 {
 109         struct ttm_operation_ctx ctx = {interruptible, false };
 110         struct ttm_buffer_object *bo = &buf->tbo;
 111         int ret;
 112
 113         vmw_execbuf_release_pinned_bo(dev_priv);
 114
 115         ret = ttm_bo_reserve(bo, interruptible, false, NULL);
 116         if (unlikely(ret != 0))
 117                 goto err;
 118
 119         vmw_bo_placement_set(buf,
 120                              VMW_BO_DOMAIN_GMR | VMW_BO_DOMAIN_VRAM,
 121                              VMW_BO_DOMAIN_GMR);
 122         ret = ttm_bo_validate(bo, &buf->placement, &ctx);
 123         if (likely(ret == 0) || ret == -ERESTARTSYS)
 124                 goto out_unreserve;
 125
 126         vmw_bo_placement_set(buf,
 127                              VMW_BO_DOMAIN_VRAM,
 128                              VMW_BO_DOMAIN_VRAM);
 129         ret = ttm_bo_validate(bo, &buf->placement, &ctx);
 130
 131 out_unreserve:
 132         if (!ret)
 133                 vmw_bo_pin_reserved(buf, true);
 134
 135         ttm_bo_unreserve(bo);
 136 err:
 137         return ret;
 138 }
 139
 140
 141 /**
 142  * vmw_bo_pin_in_vram - Move a buffer to vram.
 143  *
 144  * This function takes the reservation_sem in write mode.
 145  * Flushes and unpins the query bo to avoid failures.
 146  *
 147  * @dev_priv:  Driver private.
 148  * @buf:  DMA buffer to move.
 149  * @interruptible:  Use interruptible wait.
 150  * Return: Zero on success, Negative error code on failure. In particular
 151  * -ERESTARTSYS if interrupted by a signal
 152  */
 153 int vmw_bo_pin_in_vram(struct vmw_private *dev_priv,
 154                        struct vmw_bo *buf,
 155                        bool interruptible)
 156 {
 157         return vmw_bo_pin_in_placement(dev_priv, buf, &vmw_vram_placement,
 158                                        interruptible);
 159 }
 160
 161
 162 /**
 163  * vmw_bo_pin_in_start_of_vram - Move a buffer to start of vram.
 164  *
 165  * This function takes the reservation_sem in write mode.
 166  * Flushes and unpins the query bo to avoid failures.
 167  *
 168  * @dev_priv:  Driver private.
 169  * @buf:  DMA buffer to pin.
 170  * @interruptible:  Use interruptible wait.
 171  * Return: Zero on success, Negative error code on failure. In particular
 172  * -ERESTARTSYS if interrupted by a signal
 173  */
 174 int vmw_bo_pin_in_start_of_vram(struct vmw_private *dev_priv,
 175                                 struct vmw_bo *buf,
 176                                 bool interruptible)
 177 {
 178         struct ttm_operation_ctx ctx = {interruptible, false };
 179         struct ttm_buffer_object *bo = &buf->tbo;
 180         int ret = 0;
 181
 182         vmw_execbuf_release_pinned_bo(dev_priv);
 183         ret = ttm_bo_reserve(bo, interruptible, false, NULL);
 184         if (unlikely(ret != 0))
 185                 goto err_unlock;
 186
 187         /*
 188          * Is this buffer already in vram but not at the start of it?
 189          * In that case, evict it first because TTM isn't good at handling
 190          * that situation.
 191          */
 192         if (bo->resource->mem_type == TTM_PL_VRAM &&
 193             bo->resource->start < PFN_UP(bo->resource->size) &&
 194             bo->resource->start > 0 &&
 195             buf->tbo.pin_count == 0) {
 196                 ctx.interruptible = false;
 197                 vmw_bo_placement_set(buf,
 198                                      VMW_BO_DOMAIN_SYS,
 199                                      VMW_BO_DOMAIN_SYS);
 200                 (void)ttm_bo_validate(bo, &buf->placement, &ctx);
 201         }
 202
 203         vmw_bo_placement_set(buf,
 204                              VMW_BO_DOMAIN_VRAM,
 205                              VMW_BO_DOMAIN_VRAM);
 206         buf->places[0].lpfn = PFN_UP(bo->resource->size);
 207         ret = ttm_bo_validate(bo, &buf->placement, &ctx);
 208
 209         /* For some reason we didn't end up at the start of vram */
 210         WARN_ON(ret == 0 && bo->resource->start != 0);
 211         if (!ret)
 212                 vmw_bo_pin_reserved(buf, true);
 213
 214         ttm_bo_unreserve(bo);
 215 err_unlock:
 216
 217         return ret;
 218 }
 219
 220
 221 /**
 222  * vmw_bo_unpin - Unpin the buffer given buffer, does not move the buffer.
 223  *
 224  * This function takes the reservation_sem in write mode.
 225  *
 226  * @dev_priv:  Driver private.
 227  * @buf:  DMA buffer to unpin.
 228  * @interruptible:  Use interruptible wait.
 229  * Return: Zero on success, Negative error code on failure. In particular
 230  * -ERESTARTSYS if interrupted by a signal
 231  */
 232 int vmw_bo_unpin(struct vmw_private *dev_priv,
 233                  struct vmw_bo *buf,
 234                  bool interruptible)
 235 {
 236         struct ttm_buffer_object *bo = &buf->tbo;
 237         int ret;
 238
 239         ret = ttm_bo_reserve(bo, interruptible, false, NULL);
 240         if (unlikely(ret != 0))
 241                 goto err;
 242
 243         vmw_bo_pin_reserved(buf, false);
 244
 245         ttm_bo_unreserve(bo);
 246
 247 err:
 248         return ret;
 249 }
 250
 251 /**
 252  * vmw_bo_get_guest_ptr - Get the guest ptr representing the current placement
 253  * of a buffer.
 254  *
 255  * @bo: Pointer to a struct ttm_buffer_object. Must be pinned or reserved.
 256  * @ptr: SVGAGuestPtr returning the result.
 257  */
 258 void vmw_bo_get_guest_ptr(const struct ttm_buffer_object *bo,
 259                           SVGAGuestPtr *ptr)
 260 {
 261         if (bo->resource->mem_type == TTM_PL_VRAM) {
 262                 ptr->gmrId = SVGA_GMR_FRAMEBUFFER;
 263                 ptr->offset = bo->resource->start << PAGE_SHIFT;
 264         } else {
 265                 ptr->gmrId = bo->resource->start;
 266                 ptr->offset = 0;
 267         }
 268 }
 269
 270
 271 /**
 272  * vmw_bo_pin_reserved - Pin or unpin a buffer object without moving it.
 273  *
 274  * @vbo: The buffer object. Must be reserved.
 275  * @pin: Whether to pin or unpin.
 276  *
 277  */
 278 void vmw_bo_pin_reserved(struct vmw_bo *vbo, bool pin)
 279 {
 280         struct ttm_operation_ctx ctx = { false, true };
 281         struct ttm_place pl;
 282         struct ttm_placement placement;
 283         struct ttm_buffer_object *bo = &vbo->tbo;
 284         uint32_t old_mem_type = bo->resource->mem_type;
 285         int ret;
 286
 287         dma_resv_assert_held(bo->base.resv);
 288
 289         if (pin == !!bo->pin_count)
 290                 return;
 291
 292         pl.fpfn = 0;
 293         pl.lpfn = 0;
 294         pl.mem_type = bo->resource->mem_type;
 295         pl.flags = bo->resource->placement;
 296
 297         memset(&placement, 0, sizeof(placement));
 298         placement.num_placement = 1;
 299         placement.placement = &pl;
 300
 301         ret = ttm_bo_validate(bo, &placement, &ctx);
 302
 303         BUG_ON(ret != 0 || bo->resource->mem_type != old_mem_type);
 304
 305         if (pin)
 306                 ttm_bo_pin(bo);
 307         else
 308                 ttm_bo_unpin(bo);
 309 }
 310
 311 /**
 312  * vmw_bo_map_and_cache - Map a buffer object and cache the map
 313  *
 314  * @vbo: The buffer object to map
 315  * Return: A kernel virtual address or NULL if mapping failed.
 316  *
 317  * This function maps a buffer object into the kernel address space, or
 318  * returns the virtual kernel address of an already existing map. The virtual
 319  * address remains valid as long as the buffer object is pinned or reserved.
 320  * The cached map is torn down on either
 321  * 1) Buffer object move
 322  * 2) Buffer object swapout
 323  * 3) Buffer object destruction
 324  *
 325  */
 326 void *vmw_bo_map_and_cache(struct vmw_bo *vbo)
 327 {
 328         struct ttm_buffer_object *bo = &vbo->tbo;
 329         bool not_used;
 330         void *virtual;
 331         int ret;
 332
 333         virtual = ttm_kmap_obj_virtual(&vbo->map, &not_used);
 334         if (virtual)
 335                 return virtual;
 336
 337         ret = ttm_bo_kmap(bo, 0, PFN_UP(bo->base.size), &vbo->map);
 338         if (ret)
 339                 DRM_ERROR("Buffer object map failed: %d.\n", ret);
 340
 341         return ttm_kmap_obj_virtual(&vbo->map, &not_used);
 342 }
 343
 344
 345 /**
 346  * vmw_bo_unmap - Tear down a cached buffer object map.
 347  *
 348  * @vbo: The buffer object whose map we are tearing down.
 349  *
 350  * This function tears down a cached map set up using
 351  * vmw_bo_map_and_cache().
 352  */
 353 void vmw_bo_unmap(struct vmw_bo *vbo)
 354 {
 355         if (vbo->map.bo == NULL)
 356                 return;
 357
 358         ttm_bo_kunmap(&vbo->map);
 359         vbo->map.bo = NULL;
 360 }
 361
 362
 363 /**
 364  * vmw_bo_init - Initialize a vmw buffer object
 365  *
 366  * @dev_priv: Pointer to the device private struct
 367  * @vmw_bo: Buffer object to initialize
 368  * @params: Parameters used to initialize the buffer object
 369  * @destroy: The function used to delete the buffer object
 370  * Returns: Zero on success, negative error code on error.
 371  *
 372  */
 373 static int vmw_bo_init(struct vmw_private *dev_priv,
 374                        struct vmw_bo *vmw_bo,
 375                        struct vmw_bo_params *params,
 376                        void (*destroy)(struct ttm_buffer_object *))
 377 {
 378         struct ttm_operation_ctx ctx = {
 379                 .interruptible = params->bo_type != ttm_bo_type_kernel,
 380                 .no_wait_gpu = false
 381         };
 382         struct ttm_device *bdev = &dev_priv->bdev;
 383         struct drm_device *vdev = &dev_priv->drm;
 384         int ret;
 385
 386         memset(vmw_bo, 0, sizeof(*vmw_bo));
 387
 388         BUILD_BUG_ON(TTM_MAX_BO_PRIORITY <= 3);
 389         vmw_bo->tbo.priority = 3;
 390         vmw_bo->res_tree = RB_ROOT;
 391
 392         params->size = ALIGN(params->size, PAGE_SIZE);
 393         drm_gem_private_object_init(vdev, &vmw_bo->tbo.base, params->size);
 394
 395         vmw_bo_placement_set(vmw_bo, params->domain, params->busy_domain);
 396         ret = ttm_bo_init_reserved(bdev, &vmw_bo->tbo, params->bo_type,
 397                                    &vmw_bo->placement, 0, &ctx, NULL,
 398                                    NULL, destroy);
 399         if (unlikely(ret))
 400                 return ret;
 401
 402         if (params->pin)
 403                 ttm_bo_pin(&vmw_bo->tbo);
 404         ttm_bo_unreserve(&vmw_bo->tbo);
 405
 406         return 0;
 407 }
 408
 409 int vmw_bo_create(struct vmw_private *vmw,
 410                   struct vmw_bo_params *params,
 411                   struct vmw_bo **p_bo)
 412 {
 413         int ret;
 414
 415         *p_bo = kmalloc(sizeof(**p_bo), GFP_KERNEL);
 416         if (unlikely(!*p_bo)) {
 417                 DRM_ERROR("Failed to allocate a buffer.\n");
 418                 return -ENOMEM;
 419         }
 420
 421         /*
 422          * vmw_bo_init will delete the *p_bo object if it fails
 423          */
 424         ret = vmw_bo_init(vmw, *p_bo, params, vmw_bo_free);
 425         if (unlikely(ret != 0))
 426                 goto out_error;
 427
 428         return ret;
 429 out_error:
 430         *p_bo = NULL;
 431         return ret;
 432 }
 433
 434 /**
 435  * vmw_user_bo_synccpu_grab - Grab a struct vmw_bo for cpu
 436  * access, idling previous GPU operations on the buffer and optionally
 437  * blocking it for further command submissions.
 438  *
 439  * @vmw_bo: Pointer to the buffer object being grabbed for CPU access
 440  * @flags: Flags indicating how the grab should be performed.
 441  * Return: Zero on success, Negative error code on error. In particular,
 442  * -EBUSY will be returned if a dontblock operation is requested and the
 443  * buffer object is busy, and -ERESTARTSYS will be returned if a wait is
 444  * interrupted by a signal.
 445  *
 446  * A blocking grab will be automatically released when @tfile is closed.
 447  */
 448 static int vmw_user_bo_synccpu_grab(struct vmw_bo *vmw_bo,
 449                                     uint32_t flags)
 450 {
 451         bool nonblock = !!(flags & drm_vmw_synccpu_dontblock);
 452         struct ttm_buffer_object *bo = &vmw_bo->tbo;
 453         int ret;
 454
 455         if (flags & drm_vmw_synccpu_allow_cs) {
 456                 long lret;
 457
 458                 lret = dma_resv_wait_timeout(bo->base.resv, DMA_RESV_USAGE_READ,
 459                                              true, nonblock ? 0 :
 460                                              MAX_SCHEDULE_TIMEOUT);
 461                 if (!lret)
 462                         return -EBUSY;
 463                 else if (lret < 0)
 464                         return lret;
 465                 return 0;
 466         }
 467
 468         ret = ttm_bo_reserve(bo, true, nonblock, NULL);
 469         if (unlikely(ret != 0))
 470                 return ret;
 471
 472         ret = ttm_bo_wait(bo, true, nonblock);
 473         if (likely(ret == 0))
 474                 atomic_inc(&vmw_bo->cpu_writers);
 475
 476         ttm_bo_unreserve(bo);
 477         if (unlikely(ret != 0))
 478                 return ret;
 479
 480         return ret;
 481 }
 482
 483 /**
 484  * vmw_user_bo_synccpu_release - Release a previous grab for CPU access,
 485  * and unblock command submission on the buffer if blocked.
 486  *
 487  * @filp: Identifying the caller.
 488  * @handle: Handle identifying the buffer object.
 489  * @flags: Flags indicating the type of release.
 490  */
 491 static int vmw_user_bo_synccpu_release(struct drm_file *filp,
 492                                        uint32_t handle,
 493                                        uint32_t flags)
 494 {
 495         struct vmw_bo *vmw_bo;
 496         int ret = vmw_user_bo_lookup(filp, handle, &vmw_bo);
 497
 498         if (!ret) {
 499                 if (!(flags & drm_vmw_synccpu_allow_cs)) {
 500                         atomic_dec(&vmw_bo->cpu_writers);
 501                 }
 502                 vmw_user_bo_unref(&vmw_bo);
 503         }
 504
 505         return ret;
 506 }
 507
 508
 509 /**
 510  * vmw_user_bo_synccpu_ioctl - ioctl function implementing the synccpu
 511  * functionality.
 512  *
 513  * @dev: Identifies the drm device.
 514  * @data: Pointer to the ioctl argument.
 515  * @file_priv: Identifies the caller.
 516  * Return: Zero on success, negative error code on error.
 517  *
 518  * This function checks the ioctl arguments for validity and calls the
 519  * relevant synccpu functions.
 520  */
 521 int vmw_user_bo_synccpu_ioctl(struct drm_device *dev, void *data,
 522                               struct drm_file *file_priv)
 523 {
 524         struct drm_vmw_synccpu_arg *arg =
 525                 (struct drm_vmw_synccpu_arg *) data;
 526         struct vmw_bo *vbo;
 527         int ret;
 528
 529         if ((arg->flags & (drm_vmw_synccpu_read | drm_vmw_synccpu_write)) == 0
 530             || (arg->flags & ~(drm_vmw_synccpu_read | drm_vmw_synccpu_write |
 531                                drm_vmw_synccpu_dontblock |
 532                                drm_vmw_synccpu_allow_cs)) != 0) {
 533                 DRM_ERROR("Illegal synccpu flags.\n");
 534                 return -EINVAL;
 535         }
 536
 537         switch (arg->op) {
 538         case drm_vmw_synccpu_grab:
 539                 ret = vmw_user_bo_lookup(file_priv, arg->handle, &vbo);
 540                 if (unlikely(ret != 0))
 541                         return ret;
 542
 543                 ret = vmw_user_bo_synccpu_grab(vbo, arg->flags);
 544                 vmw_user_bo_unref(&vbo);
 545                 if (unlikely(ret != 0)) {
 546                         if (ret == -ERESTARTSYS || ret == -EBUSY)
 547                                 return -EBUSY;
 548                         DRM_ERROR("Failed synccpu grab on handle 0x%08x.\n",
 549                                   (unsigned int) arg->handle);
 550                         return ret;
 551                 }
 552                 break;
 553         case drm_vmw_synccpu_release:
 554                 ret = vmw_user_bo_synccpu_release(file_priv,
 555                                                   arg->handle,
 556                                                   arg->flags);
 557                 if (unlikely(ret != 0)) {
 558                         DRM_ERROR("Failed synccpu release on handle 0x%08x.\n",
 559                                   (unsigned int) arg->handle);
 560                         return ret;
 561                 }
 562                 break;
 563         default:
 564                 DRM_ERROR("Invalid synccpu operation.\n");
 565                 return -EINVAL;
 566         }
 567
 568         return 0;
 569 }
 570
 571 /**
 572  * vmw_bo_unref_ioctl - Generic handle close ioctl.
 573  *
 574  * @dev: Identifies the drm device.
 575  * @data: Pointer to the ioctl argument.
 576  * @file_priv: Identifies the caller.
 577  * Return: Zero on success, negative error code on error.
 578  *
 579  * This function checks the ioctl arguments for validity and closes a
 580  * handle to a TTM base object, optionally freeing the object.
 581  */
 582 int vmw_bo_unref_ioctl(struct drm_device *dev, void *data,
 583                        struct drm_file *file_priv)
 584 {
 585         struct drm_vmw_unref_dmabuf_arg *arg =
 586             (struct drm_vmw_unref_dmabuf_arg *)data;
 587
 588         return drm_gem_handle_delete(file_priv, arg->handle);
 589 }
 590
 591
 592 /**
 593  * vmw_user_bo_lookup - Look up a vmw user buffer object from a handle.
 594  *
 595  * @filp: The file the handle is registered with.
 596  * @handle: The user buffer object handle
 597  * @out: Pointer to a where a pointer to the embedded
 598  * struct vmw_bo should be placed.
 599  * Return: Zero on success, Negative error code on error.
 600  *
 601  * The vmw buffer object pointer will be refcounted (both ttm and gem)
 602  */
 603 int vmw_user_bo_lookup(struct drm_file *filp,
 604                        u32 handle,
 605                        struct vmw_bo **out)
 606 {
 607         struct drm_gem_object *gobj;
 608
 609         gobj = drm_gem_object_lookup(filp, handle);
 610         if (!gobj) {
 611                 DRM_ERROR("Invalid buffer object handle 0x%08lx.\n",
 612                           (unsigned long)handle);
 613                 return -ESRCH;
 614         }
 615
 616         *out = to_vmw_bo(gobj);
 617
 618         return 0;
 619 }
 620
 621 /**
 622  * vmw_bo_fence_single - Utility function to fence a single TTM buffer
 623  *                       object without unreserving it.
 624  *
 625  * @bo:             Pointer to the struct ttm_buffer_object to fence.
 626  * @fence:          Pointer to the fence. If NULL, this function will
 627  *                  insert a fence into the command stream..
 628  *
 629  * Contrary to the ttm_eu version of this function, it takes only
 630  * a single buffer object instead of a list, and it also doesn't
 631  * unreserve the buffer object, which needs to be done separately.
 632  */
 633 void vmw_bo_fence_single(struct ttm_buffer_object *bo,
 634                          struct vmw_fence_obj *fence)
 635 {
 636         struct ttm_device *bdev = bo->bdev;
 637         struct vmw_private *dev_priv = vmw_priv_from_ttm(bdev);
 638         int ret;
 639
 640         if (fence == NULL)
 641                 vmw_execbuf_fence_commands(NULL, dev_priv, &fence, NULL);
 642         else
 643                 dma_fence_get(&fence->base);
 644
 645         ret = dma_resv_reserve_fences(bo->base.resv, 1);
 646         if (!ret)
 647                 dma_resv_add_fence(bo->base.resv, &fence->base,
 648                                    DMA_RESV_USAGE_KERNEL);
 649         else
 650                 /* Last resort fallback when we are OOM */
 651                 dma_fence_wait(&fence->base, false);
 652         dma_fence_put(&fence->base);
 653 }
 654
 655
 656 /**
 657  * vmw_dumb_create - Create a dumb kms buffer
 658  *
 659  * @file_priv: Pointer to a struct drm_file identifying the caller.
 660  * @dev: Pointer to the drm device.
 661  * @args: Pointer to a struct drm_mode_create_dumb structure
 662  * Return: Zero on success, negative error code on failure.
 663  *
 664  * This is a driver callback for the core drm create_dumb functionality.
 665  * Note that this is very similar to the vmw_bo_alloc ioctl, except
 666  * that the arguments have a different format.
 667  */
 668 int vmw_dumb_create(struct drm_file *file_priv,
 669                     struct drm_device *dev,
 670                     struct drm_mode_create_dumb *args)
 671 {
 672         struct vmw_private *dev_priv = vmw_priv(dev);
 673         struct vmw_bo *vbo;
 674         int cpp = DIV_ROUND_UP(args->bpp, 8);
 675         int ret;
 676
 677         switch (cpp) {
 678         case 1: /* DRM_FORMAT_C8 */
 679         case 2: /* DRM_FORMAT_RGB565 */
 680         case 4: /* DRM_FORMAT_XRGB8888 */
 681                 break;
 682         default:
 683                 /*
 684                  * Dumb buffers don't allow anything else.
 685                  * This is tested via IGT's dumb_buffers
 686                  */
 687                 return -EINVAL;
 688         }
 689
 690         args->pitch = args->width * cpp;
 691         args->size = ALIGN(args->pitch * args->height, PAGE_SIZE);
 692
 693         ret = vmw_gem_object_create_with_handle(dev_priv, file_priv,
 694                                                 args->size, &args->handle,
 695                                                 &vbo);
 696         /* drop reference from allocate - handle holds it now */
 697         drm_gem_object_put(&vbo->tbo.base);
 698         return ret;
 699 }
 700
 701 /**
 702  * vmw_bo_swap_notify - swapout notify callback.
 703  *
 704  * @bo: The buffer object to be swapped out.
 705  */
 706 void vmw_bo_swap_notify(struct ttm_buffer_object *bo)
 707 {
 708         /* Kill any cached kernel maps before swapout */
 709         vmw_bo_unmap(to_vmw_bo(&bo->base));
 710 }
 711
 712
 713 /**
 714  * vmw_bo_move_notify - TTM move_notify_callback
 715  *
 716  * @bo: The TTM buffer object about to move.
 717  * @mem: The struct ttm_resource indicating to what memory
 718  *       region the move is taking place.
 719  *
 720  * Detaches cached maps and device bindings that require that the
 721  * buffer doesn't move.
 722  */
 723 void vmw_bo_move_notify(struct ttm_buffer_object *bo,
 724                         struct ttm_resource *mem)
 725 {
 726         struct vmw_bo *vbo = to_vmw_bo(&bo->base);
 727
 728         /*
 729          * Kill any cached kernel maps before move to or from VRAM.
 730          * With other types of moves, the underlying pages stay the same,
 731          * and the map can be kept.
 732          */
 733         if (mem->mem_type == TTM_PL_VRAM || bo->resource->mem_type == TTM_PL_VRAM)
 734                 vmw_bo_unmap(vbo);
 735
 736         /*
 737          * If we're moving a backup MOB out of MOB placement, then make sure we
 738          * read back all resource content first, and unbind the MOB from
 739          * the resource.
 740          */
 741         if (mem->mem_type != VMW_PL_MOB && bo->resource->mem_type == VMW_PL_MOB)
 742                 vmw_resource_unbind_list(vbo);
 743 }
 744
 745 static u32 placement_flags(u32 domain, u32 desired, u32 fallback)
 746 {
 747         if (desired & fallback & domain)
 748                 return 0;
 749
 750         if (desired & domain)
 751                 return TTM_PL_FLAG_DESIRED;
 752
 753         return TTM_PL_FLAG_FALLBACK;
 754 }
 755
 756 static u32
 757 set_placement_list(struct ttm_place *pl, u32 desired, u32 fallback)
 758 {
 759         u32 domain = desired | fallback;
 760         u32 n = 0;
 761
 762         /*
 763          * The placements are ordered according to our preferences
 764          */
 765         if (domain & VMW_BO_DOMAIN_MOB) {
 766                 pl[n].mem_type = VMW_PL_MOB;
 767                 pl[n].flags = placement_flags(VMW_BO_DOMAIN_MOB, desired,
 768                                               fallback);
 769                 pl[n].fpfn = 0;
 770                 pl[n].lpfn = 0;
 771                 n++;
 772         }
 773         if (domain & VMW_BO_DOMAIN_GMR) {
 774                 pl[n].mem_type = VMW_PL_GMR;
 775                 pl[n].flags = placement_flags(VMW_BO_DOMAIN_GMR, desired,
 776                                               fallback);
 777                 pl[n].fpfn = 0;
 778                 pl[n].lpfn = 0;
 779                 n++;
 780         }
 781         if (domain & VMW_BO_DOMAIN_VRAM) {
 782                 pl[n].mem_type = TTM_PL_VRAM;
 783                 pl[n].flags = placement_flags(VMW_BO_DOMAIN_VRAM, desired,
 784                                               fallback);
 785                 pl[n].fpfn = 0;
 786                 pl[n].lpfn = 0;
 787                 n++;
 788         }
 789         if (domain & VMW_BO_DOMAIN_WAITABLE_SYS) {
 790                 pl[n].mem_type = VMW_PL_SYSTEM;
 791                 pl[n].flags = placement_flags(VMW_BO_DOMAIN_WAITABLE_SYS,
 792                                               desired, fallback);
 793                 pl[n].fpfn = 0;
 794                 pl[n].lpfn = 0;
 795                 n++;
 796         }
 797         if (domain & VMW_BO_DOMAIN_SYS) {
 798                 pl[n].mem_type = TTM_PL_SYSTEM;
 799                 pl[n].flags = placement_flags(VMW_BO_DOMAIN_SYS, desired,
 800                                               fallback);
 801                 pl[n].fpfn = 0;
 802                 pl[n].lpfn = 0;
 803                 n++;
 804         }
 805
 806         WARN_ON(!n);
 807         if (!n) {
 808                 pl[n].mem_type = TTM_PL_SYSTEM;
 809                 pl[n].flags = 0;
 810                 pl[n].fpfn = 0;
 811                 pl[n].lpfn = 0;
 812                 n++;
 813         }
 814         return n;
 815 }
 816
 817 void vmw_bo_placement_set(struct vmw_bo *bo, u32 domain, u32 busy_domain)
 818 {
 819         struct ttm_device *bdev = bo->tbo.bdev;
 820         struct vmw_private *vmw = vmw_priv_from_ttm(bdev);
 821         struct ttm_placement *pl = &bo->placement;
 822         bool mem_compatible = false;
 823         u32 i;
 824
 825         pl->placement = bo->places;
 826         pl->num_placement = set_placement_list(bo->places, domain, busy_domain);
 827
 828         if (drm_debug_enabled(DRM_UT_DRIVER) && bo->tbo.resource) {
 829                 for (i = 0; i < pl->num_placement; ++i) {
 830                         if (bo->tbo.resource->mem_type == TTM_PL_SYSTEM ||
 831                             bo->tbo.resource->mem_type == pl->placement[i].mem_type)
 832                                 mem_compatible = true;
 833                 }
 834                 if (!mem_compatible)
 835                         drm_warn(&vmw->drm,
 836                                  "%s: Incompatible transition from "
 837                                  "bo->base.resource->mem_type = %u to domain = %u\n",
 838                                  __func__, bo->tbo.resource->mem_type, domain);
 839         }
 840
 841 }
 842
 843 void vmw_bo_placement_set_default_accelerated(struct vmw_bo *bo)
 844 {
 845         struct ttm_device *bdev = bo->tbo.bdev;
 846         struct vmw_private *vmw = vmw_priv_from_ttm(bdev);
 847         u32 domain = VMW_BO_DOMAIN_GMR | VMW_BO_DOMAIN_VRAM;
 848
 849         if (vmw->has_mob)
 850                 domain = VMW_BO_DOMAIN_MOB;
 851
 852         vmw_bo_placement_set(bo, domain, domain);
 853 }