drivers/gpu/drm/amd/amdgpu/amdgpu_object.c

   1 /*
   2  * Copyright 2009 Jerome Glisse.
   3  * All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the
   7  * "Software"), to deal in the Software without restriction, including
   8  * without limitation the rights to use, copy, modify, merge, publish,
   9  * distribute, sub license, and/or sell copies of the Software, and to
  10  * permit persons to whom the Software is furnished to do so, subject to
  11  * the following conditions:
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  14  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  15  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  16  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
  17  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  18  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  19  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  20  *
  21  * The above copyright notice and this permission notice (including the
  22  * next paragraph) shall be included in all copies or substantial portions
  23  * of the Software.
  24  *
  25  */
  26 /*
  27  * Authors:
  28  *    Jerome Glisse <[email protected]>
  29  *    Thomas Hellstrom <thomas-at-tungstengraphics-dot-com>
  30  *    Dave Airlie
  31  */
  32 #include <linux/list.h>
  33 #include <linux/slab.h>
  34 #include <linux/dma-buf.h>
  35
  36 #include <drm/drm_drv.h>
  37 #include <drm/amdgpu_drm.h>
  38 #include <drm/drm_cache.h>
  39 #include "amdgpu.h"
  40 #include "amdgpu_trace.h"
  41 #include "amdgpu_amdkfd.h"
  42 #include "amdgpu_vram_mgr.h"
  43 #include "amdgpu_vm.h"
  44 #include "amdgpu_dma_buf.h"
  45
  46 /**
  47  * DOC: amdgpu_object
  48  *
  49  * This defines the interfaces to operate on an &amdgpu_bo buffer object which
  50  * represents memory used by driver (VRAM, system memory, etc.). The driver
  51  * provides DRM/GEM APIs to userspace. DRM/GEM APIs then use these interfaces
  52  * to create/destroy/set buffer object which are then managed by the kernel TTM
  53  * memory manager.
  54  * The interfaces are also used internally by kernel clients, including gfx,
  55  * uvd, etc. for kernel managed allocations used by the GPU.
  56  *
  57  */
  58
  59 static void amdgpu_bo_destroy(struct ttm_buffer_object *tbo)
  60 {
  61         struct amdgpu_bo *bo = ttm_to_amdgpu_bo(tbo);
  62
  63         amdgpu_bo_kunmap(bo);
  64
  65         if (bo->tbo.base.import_attach)
  66                 drm_prime_gem_destroy(&bo->tbo.base, bo->tbo.sg);
  67         drm_gem_object_release(&bo->tbo.base);
  68         amdgpu_bo_unref(&bo->parent);
  69         kvfree(bo);
  70 }
  71
  72 static void amdgpu_bo_user_destroy(struct ttm_buffer_object *tbo)
  73 {
  74         struct amdgpu_bo *bo = ttm_to_amdgpu_bo(tbo);
  75         struct amdgpu_bo_user *ubo;
  76
  77         ubo = to_amdgpu_bo_user(bo);
  78         kfree(ubo->metadata);
  79         amdgpu_bo_destroy(tbo);
  80 }
  81
  82 /**
  83  * amdgpu_bo_is_amdgpu_bo - check if the buffer object is an &amdgpu_bo
  84  * @bo: buffer object to be checked
  85  *
  86  * Uses destroy function associated with the object to determine if this is
  87  * an &amdgpu_bo.
  88  *
  89  * Returns:
  90  * true if the object belongs to &amdgpu_bo, false if not.
  91  */
  92 bool amdgpu_bo_is_amdgpu_bo(struct ttm_buffer_object *bo)
  93 {
  94         if (bo->destroy == &amdgpu_bo_destroy ||
  95             bo->destroy == &amdgpu_bo_user_destroy)
  96                 return true;
  97
  98         return false;
  99 }
 100
 101 /**
 102  * amdgpu_bo_placement_from_domain - set buffer's placement
 103  * @abo: &amdgpu_bo buffer object whose placement is to be set
 104  * @domain: requested domain
 105  *
 106  * Sets buffer's placement according to requested domain and the buffer's
 107  * flags.
 108  */
 109 void amdgpu_bo_placement_from_domain(struct amdgpu_bo *abo, u32 domain)
 110 {
 111         struct amdgpu_device *adev = amdgpu_ttm_adev(abo->tbo.bdev);
 112         struct ttm_placement *placement = &abo->placement;
 113         struct ttm_place *places = abo->placements;
 114         u64 flags = abo->flags;
 115         u32 c = 0;
 116
 117         if (domain & AMDGPU_GEM_DOMAIN_VRAM) {
 118                 unsigned int visible_pfn = adev->gmc.visible_vram_size >> PAGE_SHIFT;
 119                 int8_t mem_id = KFD_XCP_MEM_ID(adev, abo->xcp_id);
 120
 121                 if (adev->gmc.mem_partitions && mem_id >= 0) {
 122                         places[c].fpfn = adev->gmc.mem_partitions[mem_id].range.fpfn;
 123                         /*
 124                          * memory partition range lpfn is inclusive start + size - 1
 125                          * TTM place lpfn is exclusive start + size
 126                          */
 127                         places[c].lpfn = adev->gmc.mem_partitions[mem_id].range.lpfn + 1;
 128                 } else {
 129                         places[c].fpfn = 0;
 130                         places[c].lpfn = 0;
 131                 }
 132                 places[c].mem_type = TTM_PL_VRAM;
 133                 places[c].flags = 0;
 134
 135                 if (flags & AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED)
 136                         places[c].lpfn = min_not_zero(places[c].lpfn, visible_pfn);
 137                 else
 138                         places[c].flags |= TTM_PL_FLAG_TOPDOWN;
 139
 140                 if (abo->tbo.type == ttm_bo_type_kernel &&
 141                     flags & AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS)
 142                         places[c].flags |= TTM_PL_FLAG_CONTIGUOUS;
 143
 144                 c++;
 145         }
 146
 147         if (domain & AMDGPU_GEM_DOMAIN_DOORBELL) {
 148                 places[c].fpfn = 0;
 149                 places[c].lpfn = 0;
 150                 places[c].mem_type = AMDGPU_PL_DOORBELL;
 151                 places[c].flags = 0;
 152                 c++;
 153         }
 154
 155         if (domain & AMDGPU_GEM_DOMAIN_GTT) {
 156                 places[c].fpfn = 0;
 157                 places[c].lpfn = 0;
 158                 places[c].mem_type =
 159                         abo->flags & AMDGPU_GEM_CREATE_PREEMPTIBLE ?
 160                         AMDGPU_PL_PREEMPT : TTM_PL_TT;
 161                 places[c].flags = 0;
 162                 /*
 163                  * When GTT is just an alternative to VRAM make sure that we
 164                  * only use it as fallback and still try to fill up VRAM first.
 165                  */
 166                 if (domain & abo->preferred_domains & AMDGPU_GEM_DOMAIN_VRAM &&
 167                     !(adev->flags & AMD_IS_APU))
 168                         places[c].flags |= TTM_PL_FLAG_FALLBACK;
 169                 c++;
 170         }
 171
 172         if (domain & AMDGPU_GEM_DOMAIN_CPU) {
 173                 places[c].fpfn = 0;
 174                 places[c].lpfn = 0;
 175                 places[c].mem_type = TTM_PL_SYSTEM;
 176                 places[c].flags = 0;
 177                 c++;
 178         }
 179
 180         if (domain & AMDGPU_GEM_DOMAIN_GDS) {
 181                 places[c].fpfn = 0;
 182                 places[c].lpfn = 0;
 183                 places[c].mem_type = AMDGPU_PL_GDS;
 184                 places[c].flags = 0;
 185                 c++;
 186         }
 187
 188         if (domain & AMDGPU_GEM_DOMAIN_GWS) {
 189                 places[c].fpfn = 0;
 190                 places[c].lpfn = 0;
 191                 places[c].mem_type = AMDGPU_PL_GWS;
 192                 places[c].flags = 0;
 193                 c++;
 194         }
 195
 196         if (domain & AMDGPU_GEM_DOMAIN_OA) {
 197                 places[c].fpfn = 0;
 198                 places[c].lpfn = 0;
 199                 places[c].mem_type = AMDGPU_PL_OA;
 200                 places[c].flags = 0;
 201                 c++;
 202         }
 203
 204         if (!c) {
 205                 places[c].fpfn = 0;
 206                 places[c].lpfn = 0;
 207                 places[c].mem_type = TTM_PL_SYSTEM;
 208                 places[c].flags = 0;
 209                 c++;
 210         }
 211
 212         BUG_ON(c > AMDGPU_BO_MAX_PLACEMENTS);
 213
 214         placement->num_placement = c;
 215         placement->placement = places;
 216 }
 217
 218 /**
 219  * amdgpu_bo_create_reserved - create reserved BO for kernel use
 220  *
 221  * @adev: amdgpu device object
 222  * @size: size for the new BO
 223  * @align: alignment for the new BO
 224  * @domain: where to place it
 225  * @bo_ptr: used to initialize BOs in structures
 226  * @gpu_addr: GPU addr of the pinned BO
 227  * @cpu_addr: optional CPU address mapping
 228  *
 229  * Allocates and pins a BO for kernel internal use, and returns it still
 230  * reserved.
 231  *
 232  * Note: For bo_ptr new BO is only created if bo_ptr points to NULL.
 233  *
 234  * Returns:
 235  * 0 on success, negative error code otherwise.
 236  */
 237 int amdgpu_bo_create_reserved(struct amdgpu_device *adev,
 238                               unsigned long size, int align,
 239                               u32 domain, struct amdgpu_bo **bo_ptr,
 240                               u64 *gpu_addr, void **cpu_addr)
 241 {
 242         struct amdgpu_bo_param bp;
 243         bool free = false;
 244         int r;
 245
 246         if (!size) {
 247                 amdgpu_bo_unref(bo_ptr);
 248                 return 0;
 249         }
 250
 251         memset(&bp, 0, sizeof(bp));
 252         bp.size = size;
 253         bp.byte_align = align;
 254         bp.domain = domain;
 255         bp.flags = cpu_addr ? AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED
 256                 : AMDGPU_GEM_CREATE_NO_CPU_ACCESS;
 257         bp.flags |= AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS;
 258         bp.type = ttm_bo_type_kernel;
 259         bp.resv = NULL;
 260         bp.bo_ptr_size = sizeof(struct amdgpu_bo);
 261
 262         if (!*bo_ptr) {
 263                 r = amdgpu_bo_create(adev, &bp, bo_ptr);
 264                 if (r) {
 265                         dev_err(adev->dev, "(%d) failed to allocate kernel bo\n",
 266                                 r);
 267                         return r;
 268                 }
 269                 free = true;
 270         }
 271
 272         r = amdgpu_bo_reserve(*bo_ptr, false);
 273         if (r) {
 274                 dev_err(adev->dev, "(%d) failed to reserve kernel bo\n", r);
 275                 goto error_free;
 276         }
 277
 278         r = amdgpu_bo_pin(*bo_ptr, domain);
 279         if (r) {
 280                 dev_err(adev->dev, "(%d) kernel bo pin failed\n", r);
 281                 goto error_unreserve;
 282         }
 283
 284         r = amdgpu_ttm_alloc_gart(&(*bo_ptr)->tbo);
 285         if (r) {
 286                 dev_err(adev->dev, "%p bind failed\n", *bo_ptr);
 287                 goto error_unpin;
 288         }
 289
 290         if (gpu_addr)
 291                 *gpu_addr = amdgpu_bo_gpu_offset(*bo_ptr);
 292
 293         if (cpu_addr) {
 294                 r = amdgpu_bo_kmap(*bo_ptr, cpu_addr);
 295                 if (r) {
 296                         dev_err(adev->dev, "(%d) kernel bo map failed\n", r);
 297                         goto error_unpin;
 298                 }
 299         }
 300
 301         return 0;
 302
 303 error_unpin:
 304         amdgpu_bo_unpin(*bo_ptr);
 305 error_unreserve:
 306         amdgpu_bo_unreserve(*bo_ptr);
 307
 308 error_free:
 309         if (free)
 310                 amdgpu_bo_unref(bo_ptr);
 311
 312         return r;
 313 }
 314
 315 /**
 316  * amdgpu_bo_create_kernel - create BO for kernel use
 317  *
 318  * @adev: amdgpu device object
 319  * @size: size for the new BO
 320  * @align: alignment for the new BO
 321  * @domain: where to place it
 322  * @bo_ptr:  used to initialize BOs in structures
 323  * @gpu_addr: GPU addr of the pinned BO
 324  * @cpu_addr: optional CPU address mapping
 325  *
 326  * Allocates and pins a BO for kernel internal use.
 327  *
 328  * This function is exported to allow the V4L2 isp device
 329  * external to drm device to create and access the kernel BO.
 330  *
 331  * Note: For bo_ptr new BO is only created if bo_ptr points to NULL.
 332  *
 333  * Returns:
 334  * 0 on success, negative error code otherwise.
 335  */
 336 int amdgpu_bo_create_kernel(struct amdgpu_device *adev,
 337                             unsigned long size, int align,
 338                             u32 domain, struct amdgpu_bo **bo_ptr,
 339                             u64 *gpu_addr, void **cpu_addr)
 340 {
 341         int r;
 342
 343         r = amdgpu_bo_create_reserved(adev, size, align, domain, bo_ptr,
 344                                       gpu_addr, cpu_addr);
 345
 346         if (r)
 347                 return r;
 348
 349         if (*bo_ptr)
 350                 amdgpu_bo_unreserve(*bo_ptr);
 351
 352         return 0;
 353 }
 354 EXPORT_SYMBOL(amdgpu_bo_create_kernel);
 355
 356 /**
 357  * amdgpu_bo_create_isp_user - create user BO for isp
 358  *
 359  * @adev: amdgpu device object
 360  * @dma_buf: DMABUF handle for isp buffer
 361  * @domain: where to place it
 362  * @bo:  used to initialize BOs in structures
 363  * @gpu_addr: GPU addr of the pinned BO
 364  *
 365  * Imports isp DMABUF to allocate and pin a user BO for isp internal use. It does
 366  * GART alloc to generate gpu_addr for BO to make it accessible through the
 367  * GART aperture for ISP HW.
 368  *
 369  * This function is exported to allow the V4L2 isp device external to drm device
 370  * to create and access the isp user BO.
 371  *
 372  * Returns:
 373  * 0 on success, negative error code otherwise.
 374  */
 375 int amdgpu_bo_create_isp_user(struct amdgpu_device *adev,
 376                            struct dma_buf *dma_buf, u32 domain, struct amdgpu_bo **bo,
 377                            u64 *gpu_addr)
 378
 379 {
 380         struct drm_gem_object *gem_obj;
 381         int r;
 382
 383         gem_obj = amdgpu_gem_prime_import(&adev->ddev, dma_buf);
 384         *bo = gem_to_amdgpu_bo(gem_obj);
 385         if (!(*bo)) {
 386                 dev_err(adev->dev, "failed to get valid isp user bo\n");
 387                 return -EINVAL;
 388         }
 389
 390         r = amdgpu_bo_reserve(*bo, false);
 391         if (r) {
 392                 dev_err(adev->dev, "(%d) failed to reserve isp user bo\n", r);
 393                 return r;
 394         }
 395
 396         r = amdgpu_bo_pin(*bo, domain);
 397         if (r) {
 398                 dev_err(adev->dev, "(%d) isp user bo pin failed\n", r);
 399                 goto error_unreserve;
 400         }
 401
 402         r = amdgpu_ttm_alloc_gart(&(*bo)->tbo);
 403         if (r) {
 404                 dev_err(adev->dev, "%p bind failed\n", *bo);
 405                 goto error_unpin;
 406         }
 407
 408         if (!WARN_ON(!gpu_addr))
 409                 *gpu_addr = amdgpu_bo_gpu_offset(*bo);
 410
 411         amdgpu_bo_unreserve(*bo);
 412
 413         return 0;
 414
 415 error_unpin:
 416         amdgpu_bo_unpin(*bo);
 417 error_unreserve:
 418         amdgpu_bo_unreserve(*bo);
 419         amdgpu_bo_unref(bo);
 420
 421         return r;
 422 }
 423 EXPORT_SYMBOL(amdgpu_bo_create_isp_user);
 424
 425 /**
 426  * amdgpu_bo_create_kernel_at - create BO for kernel use at specific location
 427  *
 428  * @adev: amdgpu device object
 429  * @offset: offset of the BO
 430  * @size: size of the BO
 431  * @bo_ptr:  used to initialize BOs in structures
 432  * @cpu_addr: optional CPU address mapping
 433  *
 434  * Creates a kernel BO at a specific offset in VRAM.
 435  *
 436  * Returns:
 437  * 0 on success, negative error code otherwise.
 438  */
 439 int amdgpu_bo_create_kernel_at(struct amdgpu_device *adev,
 440                                uint64_t offset, uint64_t size,
 441                                struct amdgpu_bo **bo_ptr, void **cpu_addr)
 442 {
 443         struct ttm_operation_ctx ctx = { false, false };
 444         unsigned int i;
 445         int r;
 446
 447         offset &= PAGE_MASK;
 448         size = ALIGN(size, PAGE_SIZE);
 449
 450         r = amdgpu_bo_create_reserved(adev, size, PAGE_SIZE,
 451                                       AMDGPU_GEM_DOMAIN_VRAM, bo_ptr, NULL,
 452                                       cpu_addr);
 453         if (r)
 454                 return r;
 455
 456         if ((*bo_ptr) == NULL)
 457                 return 0;
 458
 459         /*
 460          * Remove the original mem node and create a new one at the request
 461          * position.
 462          */
 463         if (cpu_addr)
 464                 amdgpu_bo_kunmap(*bo_ptr);
 465
 466         ttm_resource_free(&(*bo_ptr)->tbo, &(*bo_ptr)->tbo.resource);
 467
 468         for (i = 0; i < (*bo_ptr)->placement.num_placement; ++i) {
 469                 (*bo_ptr)->placements[i].fpfn = offset >> PAGE_SHIFT;
 470                 (*bo_ptr)->placements[i].lpfn = (offset + size) >> PAGE_SHIFT;
 471         }
 472         r = ttm_bo_mem_space(&(*bo_ptr)->tbo, &(*bo_ptr)->placement,
 473                              &(*bo_ptr)->tbo.resource, &ctx);
 474         if (r)
 475                 goto error;
 476
 477         if (cpu_addr) {
 478                 r = amdgpu_bo_kmap(*bo_ptr, cpu_addr);
 479                 if (r)
 480                         goto error;
 481         }
 482
 483         amdgpu_bo_unreserve(*bo_ptr);
 484         return 0;
 485
 486 error:
 487         amdgpu_bo_unreserve(*bo_ptr);
 488         amdgpu_bo_unref(bo_ptr);
 489         return r;
 490 }
 491
 492 /**
 493  * amdgpu_bo_free_kernel - free BO for kernel use
 494  *
 495  * @bo: amdgpu BO to free
 496  * @gpu_addr: pointer to where the BO's GPU memory space address was stored
 497  * @cpu_addr: pointer to where the BO's CPU memory space address was stored
 498  *
 499  * unmaps and unpin a BO for kernel internal use.
 500  *
 501  * This function is exported to allow the V4L2 isp device
 502  * external to drm device to free the kernel BO.
 503  */
 504 void amdgpu_bo_free_kernel(struct amdgpu_bo **bo, u64 *gpu_addr,
 505                            void **cpu_addr)
 506 {
 507         if (*bo == NULL)
 508                 return;
 509
 510         WARN_ON(amdgpu_ttm_adev((*bo)->tbo.bdev)->in_suspend);
 511
 512         if (likely(amdgpu_bo_reserve(*bo, true) == 0)) {
 513                 if (cpu_addr)
 514                         amdgpu_bo_kunmap(*bo);
 515
 516                 amdgpu_bo_unpin(*bo);
 517                 amdgpu_bo_unreserve(*bo);
 518         }
 519         amdgpu_bo_unref(bo);
 520
 521         if (gpu_addr)
 522                 *gpu_addr = 0;
 523
 524         if (cpu_addr)
 525                 *cpu_addr = NULL;
 526 }
 527 EXPORT_SYMBOL(amdgpu_bo_free_kernel);
 528
 529 /**
 530  * amdgpu_bo_free_isp_user - free BO for isp use
 531  *
 532  * @bo: amdgpu isp user BO to free
 533  *
 534  * unpin and unref BO for isp internal use.
 535  *
 536  * This function is exported to allow the V4L2 isp device
 537  * external to drm device to free the isp user BO.
 538  */
 539 void amdgpu_bo_free_isp_user(struct amdgpu_bo *bo)
 540 {
 541         if (bo == NULL)
 542                 return;
 543
 544         if (amdgpu_bo_reserve(bo, true) == 0) {
 545                 amdgpu_bo_unpin(bo);
 546                 amdgpu_bo_unreserve(bo);
 547         }
 548         amdgpu_bo_unref(&bo);
 549 }
 550 EXPORT_SYMBOL(amdgpu_bo_free_isp_user);
 551
 552 /* Validate bo size is bit bigger than the request domain */
 553 static bool amdgpu_bo_validate_size(struct amdgpu_device *adev,
 554                                           unsigned long size, u32 domain)
 555 {
 556         struct ttm_resource_manager *man = NULL;
 557
 558         /*
 559          * If GTT is part of requested domains the check must succeed to
 560          * allow fall back to GTT.
 561          */
 562         if (domain & AMDGPU_GEM_DOMAIN_GTT)
 563                 man = ttm_manager_type(&adev->mman.bdev, TTM_PL_TT);
 564         else if (domain & AMDGPU_GEM_DOMAIN_VRAM)
 565                 man = ttm_manager_type(&adev->mman.bdev, TTM_PL_VRAM);
 566         else
 567                 return true;
 568
 569         if (!man) {
 570                 if (domain & AMDGPU_GEM_DOMAIN_GTT)
 571                         WARN_ON_ONCE("GTT domain requested but GTT mem manager uninitialized");
 572                 return false;
 573         }
 574
 575         /* TODO add more domains checks, such as AMDGPU_GEM_DOMAIN_CPU, _DOMAIN_DOORBELL */
 576         if (size < man->size)
 577                 return true;
 578
 579         DRM_DEBUG("BO size %lu > total memory in domain: %llu\n", size, man->size);
 580         return false;
 581 }
 582
 583 bool amdgpu_bo_support_uswc(u64 bo_flags)
 584 {
 585
 586 #ifdef CONFIG_X86_32
 587         /* XXX: Write-combined CPU mappings of GTT seem broken on 32-bit
 588          * See https://bugs.freedesktop.org/show_bug.cgi?id=84627
 589          */
 590         return false;
 591 #elif defined(CONFIG_X86) && !defined(CONFIG_X86_PAT)
 592         /* Don't try to enable write-combining when it can't work, or things
 593          * may be slow
 594          * See https://bugs.freedesktop.org/show_bug.cgi?id=88758
 595          */
 596
 597 #ifndef CONFIG_COMPILE_TEST
 598 #warning Please enable CONFIG_MTRR and CONFIG_X86_PAT for better performance \
 599          thanks to write-combining
 600 #endif
 601
 602         if (bo_flags & AMDGPU_GEM_CREATE_CPU_GTT_USWC)
 603                 DRM_INFO_ONCE("Please enable CONFIG_MTRR and CONFIG_X86_PAT for "
 604                               "better performance thanks to write-combining\n");
 605         return false;
 606 #else
 607         /* For architectures that don't support WC memory,
 608          * mask out the WC flag from the BO
 609          */
 610         if (!drm_arch_can_wc_memory())
 611                 return false;
 612
 613         return true;
 614 #endif
 615 }
 616
 617 /**
 618  * amdgpu_bo_create - create an &amdgpu_bo buffer object
 619  * @adev: amdgpu device object
 620  * @bp: parameters to be used for the buffer object
 621  * @bo_ptr: pointer to the buffer object pointer
 622  *
 623  * Creates an &amdgpu_bo buffer object.
 624  *
 625  * Returns:
 626  * 0 for success or a negative error code on failure.
 627  */
 628 int amdgpu_bo_create(struct amdgpu_device *adev,
 629                                struct amdgpu_bo_param *bp,
 630                                struct amdgpu_bo **bo_ptr)
 631 {
 632         struct ttm_operation_ctx ctx = {
 633                 .interruptible = (bp->type != ttm_bo_type_kernel),
 634                 .no_wait_gpu = bp->no_wait_gpu,
 635                 /* We opt to avoid OOM on system pages allocations */
 636                 .gfp_retry_mayfail = true,
 637                 .allow_res_evict = bp->type != ttm_bo_type_kernel,
 638                 .resv = bp->resv
 639         };
 640         struct amdgpu_bo *bo;
 641         unsigned long page_align, size = bp->size;
 642         int r;
 643
 644         /* Note that GDS/GWS/OA allocates 1 page per byte/resource. */
 645         if (bp->domain & (AMDGPU_GEM_DOMAIN_GWS | AMDGPU_GEM_DOMAIN_OA)) {
 646                 /* GWS and OA don't need any alignment. */
 647                 page_align = bp->byte_align;
 648                 size <<= PAGE_SHIFT;
 649
 650         } else if (bp->domain & AMDGPU_GEM_DOMAIN_GDS) {
 651                 /* Both size and alignment must be a multiple of 4. */
 652                 page_align = ALIGN(bp->byte_align, 4);
 653                 size = ALIGN(size, 4) << PAGE_SHIFT;
 654         } else {
 655                 /* Memory should be aligned at least to a page size. */
 656                 page_align = ALIGN(bp->byte_align, PAGE_SIZE) >> PAGE_SHIFT;
 657                 size = ALIGN(size, PAGE_SIZE);
 658         }
 659
 660         if (!amdgpu_bo_validate_size(adev, size, bp->domain))
 661                 return -ENOMEM;
 662
 663         BUG_ON(bp->bo_ptr_size < sizeof(struct amdgpu_bo));
 664
 665         *bo_ptr = NULL;
 666         bo = kvzalloc(bp->bo_ptr_size, GFP_KERNEL);
 667         if (bo == NULL)
 668                 return -ENOMEM;
 669         drm_gem_private_object_init(adev_to_drm(adev), &bo->tbo.base, size);
 670         bo->tbo.base.funcs = &amdgpu_gem_object_funcs;
 671         bo->vm_bo = NULL;
 672         bo->preferred_domains = bp->preferred_domain ? bp->preferred_domain :
 673                 bp->domain;
 674         bo->allowed_domains = bo->preferred_domains;
 675         if (bp->type != ttm_bo_type_kernel &&
 676             !(bp->flags & AMDGPU_GEM_CREATE_DISCARDABLE) &&
 677             bo->allowed_domains == AMDGPU_GEM_DOMAIN_VRAM)
 678                 bo->allowed_domains |= AMDGPU_GEM_DOMAIN_GTT;
 679
 680         bo->flags = bp->flags;
 681
 682         if (adev->gmc.mem_partitions)
 683                 /* For GPUs with spatial partitioning, bo->xcp_id=-1 means any partition */
 684                 bo->xcp_id = bp->xcp_id_plus1 - 1;
 685         else
 686                 /* For GPUs without spatial partitioning */
 687                 bo->xcp_id = 0;
 688
 689         if (!amdgpu_bo_support_uswc(bo->flags))
 690                 bo->flags &= ~AMDGPU_GEM_CREATE_CPU_GTT_USWC;
 691
 692         bo->tbo.bdev = &adev->mman.bdev;
 693         if (bp->domain & (AMDGPU_GEM_DOMAIN_GWS | AMDGPU_GEM_DOMAIN_OA |
 694                           AMDGPU_GEM_DOMAIN_GDS))
 695                 amdgpu_bo_placement_from_domain(bo, AMDGPU_GEM_DOMAIN_CPU);
 696         else
 697                 amdgpu_bo_placement_from_domain(bo, bp->domain);
 698         if (bp->type == ttm_bo_type_kernel)
 699                 bo->tbo.priority = 2;
 700         else if (!(bp->flags & AMDGPU_GEM_CREATE_DISCARDABLE))
 701                 bo->tbo.priority = 1;
 702
 703         if (!bp->destroy)
 704                 bp->destroy = &amdgpu_bo_destroy;
 705
 706         r = ttm_bo_init_reserved(&adev->mman.bdev, &bo->tbo, bp->type,
 707                                  &bo->placement, page_align, &ctx,  NULL,
 708                                  bp->resv, bp->destroy);
 709         if (unlikely(r != 0))
 710                 return r;
 711
 712         if (!amdgpu_gmc_vram_full_visible(&adev->gmc) &&
 713             amdgpu_res_cpu_visible(adev, bo->tbo.resource))
 714                 amdgpu_cs_report_moved_bytes(adev, ctx.bytes_moved,
 715                                              ctx.bytes_moved);
 716         else
 717                 amdgpu_cs_report_moved_bytes(adev, ctx.bytes_moved, 0);
 718
 719         if (bp->flags & AMDGPU_GEM_CREATE_VRAM_CLEARED &&
 720             bo->tbo.resource->mem_type == TTM_PL_VRAM) {
 721                 struct dma_fence *fence;
 722
 723                 r = amdgpu_ttm_clear_buffer(bo, bo->tbo.base.resv, &fence);
 724                 if (unlikely(r))
 725                         goto fail_unreserve;
 726
 727                 dma_resv_add_fence(bo->tbo.base.resv, fence,
 728                                    DMA_RESV_USAGE_KERNEL);
 729                 dma_fence_put(fence);
 730         }
 731         if (!bp->resv)
 732                 amdgpu_bo_unreserve(bo);
 733         *bo_ptr = bo;
 734
 735         trace_amdgpu_bo_create(bo);
 736
 737         /* Treat CPU_ACCESS_REQUIRED only as a hint if given by UMD */
 738         if (bp->type == ttm_bo_type_device)
 739                 bo->flags &= ~AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED;
 740
 741         return 0;
 742
 743 fail_unreserve:
 744         if (!bp->resv)
 745                 dma_resv_unlock(bo->tbo.base.resv);
 746         amdgpu_bo_unref(&bo);
 747         return r;
 748 }
 749
 750 /**
 751  * amdgpu_bo_create_user - create an &amdgpu_bo_user buffer object
 752  * @adev: amdgpu device object
 753  * @bp: parameters to be used for the buffer object
 754  * @ubo_ptr: pointer to the buffer object pointer
 755  *
 756  * Create a BO to be used by user application;
 757  *
 758  * Returns:
 759  * 0 for success or a negative error code on failure.
 760  */
 761
 762 int amdgpu_bo_create_user(struct amdgpu_device *adev,
 763                           struct amdgpu_bo_param *bp,
 764                           struct amdgpu_bo_user **ubo_ptr)
 765 {
 766         struct amdgpu_bo *bo_ptr;
 767         int r;
 768
 769         bp->bo_ptr_size = sizeof(struct amdgpu_bo_user);
 770         bp->destroy = &amdgpu_bo_user_destroy;
 771         r = amdgpu_bo_create(adev, bp, &bo_ptr);
 772         if (r)
 773                 return r;
 774
 775         *ubo_ptr = to_amdgpu_bo_user(bo_ptr);
 776         return r;
 777 }
 778
 779 /**
 780  * amdgpu_bo_create_vm - create an &amdgpu_bo_vm buffer object
 781  * @adev: amdgpu device object
 782  * @bp: parameters to be used for the buffer object
 783  * @vmbo_ptr: pointer to the buffer object pointer
 784  *
 785  * Create a BO to be for GPUVM.
 786  *
 787  * Returns:
 788  * 0 for success or a negative error code on failure.
 789  */
 790
 791 int amdgpu_bo_create_vm(struct amdgpu_device *adev,
 792                         struct amdgpu_bo_param *bp,
 793                         struct amdgpu_bo_vm **vmbo_ptr)
 794 {
 795         struct amdgpu_bo *bo_ptr;
 796         int r;
 797
 798         /* bo_ptr_size will be determined by the caller and it depends on
 799          * num of amdgpu_vm_pt entries.
 800          */
 801         BUG_ON(bp->bo_ptr_size < sizeof(struct amdgpu_bo_vm));
 802         r = amdgpu_bo_create(adev, bp, &bo_ptr);
 803         if (r)
 804                 return r;
 805
 806         *vmbo_ptr = to_amdgpu_bo_vm(bo_ptr);
 807         return r;
 808 }
 809
 810 /**
 811  * amdgpu_bo_kmap - map an &amdgpu_bo buffer object
 812  * @bo: &amdgpu_bo buffer object to be mapped
 813  * @ptr: kernel virtual address to be returned
 814  *
 815  * Calls ttm_bo_kmap() to set up the kernel virtual mapping; calls
 816  * amdgpu_bo_kptr() to get the kernel virtual address.
 817  *
 818  * Returns:
 819  * 0 for success or a negative error code on failure.
 820  */
 821 int amdgpu_bo_kmap(struct amdgpu_bo *bo, void **ptr)
 822 {
 823         void *kptr;
 824         long r;
 825
 826         if (bo->flags & AMDGPU_GEM_CREATE_NO_CPU_ACCESS)
 827                 return -EPERM;
 828
 829         r = dma_resv_wait_timeout(bo->tbo.base.resv, DMA_RESV_USAGE_KERNEL,
 830                                   false, MAX_SCHEDULE_TIMEOUT);
 831         if (r < 0)
 832                 return r;
 833
 834         kptr = amdgpu_bo_kptr(bo);
 835         if (kptr) {
 836                 if (ptr)
 837                         *ptr = kptr;
 838                 return 0;
 839         }
 840
 841         r = ttm_bo_kmap(&bo->tbo, 0, PFN_UP(bo->tbo.base.size), &bo->kmap);
 842         if (r)
 843                 return r;
 844
 845         if (ptr)
 846                 *ptr = amdgpu_bo_kptr(bo);
 847
 848         return 0;
 849 }
 850
 851 /**
 852  * amdgpu_bo_kptr - returns a kernel virtual address of the buffer object
 853  * @bo: &amdgpu_bo buffer object
 854  *
 855  * Calls ttm_kmap_obj_virtual() to get the kernel virtual address
 856  *
 857  * Returns:
 858  * the virtual address of a buffer object area.
 859  */
 860 void *amdgpu_bo_kptr(struct amdgpu_bo *bo)
 861 {
 862         bool is_iomem;
 863
 864         return ttm_kmap_obj_virtual(&bo->kmap, &is_iomem);
 865 }
 866
 867 /**
 868  * amdgpu_bo_kunmap - unmap an &amdgpu_bo buffer object
 869  * @bo: &amdgpu_bo buffer object to be unmapped
 870  *
 871  * Unmaps a kernel map set up by amdgpu_bo_kmap().
 872  */
 873 void amdgpu_bo_kunmap(struct amdgpu_bo *bo)
 874 {
 875         if (bo->kmap.bo)
 876                 ttm_bo_kunmap(&bo->kmap);
 877 }
 878
 879 /**
 880  * amdgpu_bo_ref - reference an &amdgpu_bo buffer object
 881  * @bo: &amdgpu_bo buffer object
 882  *
 883  * References the contained &ttm_buffer_object.
 884  *
 885  * Returns:
 886  * a refcounted pointer to the &amdgpu_bo buffer object.
 887  */
 888 struct amdgpu_bo *amdgpu_bo_ref(struct amdgpu_bo *bo)
 889 {
 890         if (bo == NULL)
 891                 return NULL;
 892
 893         drm_gem_object_get(&bo->tbo.base);
 894         return bo;
 895 }
 896
 897 /**
 898  * amdgpu_bo_unref - unreference an &amdgpu_bo buffer object
 899  * @bo: &amdgpu_bo buffer object
 900  *
 901  * Unreferences the contained &ttm_buffer_object and clear the pointer
 902  */
 903 void amdgpu_bo_unref(struct amdgpu_bo **bo)
 904 {
 905         if ((*bo) == NULL)
 906                 return;
 907
 908         drm_gem_object_put(&(*bo)->tbo.base);
 909         *bo = NULL;
 910 }
 911
 912 /**
 913  * amdgpu_bo_pin - pin an &amdgpu_bo buffer object
 914  * @bo: &amdgpu_bo buffer object to be pinned
 915  * @domain: domain to be pinned to
 916  *
 917  * Pins the buffer object according to requested domain. If the memory is
 918  * unbound gart memory, binds the pages into gart table. Adjusts pin_count and
 919  * pin_size accordingly.
 920  *
 921  * Pinning means to lock pages in memory along with keeping them at a fixed
 922  * offset. It is required when a buffer can not be moved, for example, when
 923  * a display buffer is being scanned out.
 924  *
 925  * Returns:
 926  * 0 for success or a negative error code on failure.
 927  */
 928 int amdgpu_bo_pin(struct amdgpu_bo *bo, u32 domain)
 929 {
 930         struct amdgpu_device *adev = amdgpu_ttm_adev(bo->tbo.bdev);
 931         struct ttm_operation_ctx ctx = { false, false };
 932         int r, i;
 933
 934         if (amdgpu_ttm_tt_get_usermm(bo->tbo.ttm))
 935                 return -EPERM;
 936
 937         /* Check domain to be pinned to against preferred domains */
 938         if (bo->preferred_domains & domain)
 939                 domain = bo->preferred_domains & domain;
 940
 941         /* A shared bo cannot be migrated to VRAM */
 942         if (bo->tbo.base.import_attach) {
 943                 if (domain & AMDGPU_GEM_DOMAIN_GTT)
 944                         domain = AMDGPU_GEM_DOMAIN_GTT;
 945                 else
 946                         return -EINVAL;
 947         }
 948
 949         if (bo->tbo.pin_count) {
 950                 uint32_t mem_type = bo->tbo.resource->mem_type;
 951                 uint32_t mem_flags = bo->tbo.resource->placement;
 952
 953                 if (!(domain & amdgpu_mem_type_to_domain(mem_type)))
 954                         return -EINVAL;
 955
 956                 if ((mem_type == TTM_PL_VRAM) &&
 957                     (bo->flags & AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS) &&
 958                     !(mem_flags & TTM_PL_FLAG_CONTIGUOUS))
 959                         return -EINVAL;
 960
 961                 ttm_bo_pin(&bo->tbo);
 962                 return 0;
 963         }
 964
 965         /* This assumes only APU display buffers are pinned with (VRAM|GTT).
 966          * See function amdgpu_display_supported_domains()
 967          */
 968         domain = amdgpu_bo_get_preferred_domain(adev, domain);
 969
 970         if (bo->tbo.base.import_attach)
 971                 dma_buf_pin(bo->tbo.base.import_attach);
 972
 973         /* force to pin into visible video ram */
 974         if (!(bo->flags & AMDGPU_GEM_CREATE_NO_CPU_ACCESS))
 975                 bo->flags |= AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED;
 976         amdgpu_bo_placement_from_domain(bo, domain);
 977         for (i = 0; i < bo->placement.num_placement; i++) {
 978                 if (bo->flags & AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS &&
 979                     bo->placements[i].mem_type == TTM_PL_VRAM)
 980                         bo->placements[i].flags |= TTM_PL_FLAG_CONTIGUOUS;
 981         }
 982
 983         r = ttm_bo_validate(&bo->tbo, &bo->placement, &ctx);
 984         if (unlikely(r)) {
 985                 dev_err(adev->dev, "%p pin failed\n", bo);
 986                 goto error;
 987         }
 988
 989         ttm_bo_pin(&bo->tbo);
 990
 991         if (bo->tbo.resource->mem_type == TTM_PL_VRAM) {
 992                 atomic64_add(amdgpu_bo_size(bo), &adev->vram_pin_size);
 993                 atomic64_add(amdgpu_vram_mgr_bo_visible_size(bo),
 994                              &adev->visible_pin_size);
 995         } else if (bo->tbo.resource->mem_type == TTM_PL_TT) {
 996                 atomic64_add(amdgpu_bo_size(bo), &adev->gart_pin_size);
 997         }
 998
 999 error:
1000         return r;
1001 }
1002
1003 /**
1004  * amdgpu_bo_unpin - unpin an &amdgpu_bo buffer object
1005  * @bo: &amdgpu_bo buffer object to be unpinned
1006  *
1007  * Decreases the pin_count, and clears the flags if pin_count reaches 0.
1008  * Changes placement and pin size accordingly.
1009  *
1010  * Returns:
1011  * 0 for success or a negative error code on failure.
1012  */
1013 void amdgpu_bo_unpin(struct amdgpu_bo *bo)
1014 {
1015         struct amdgpu_device *adev = amdgpu_ttm_adev(bo->tbo.bdev);
1016
1017         ttm_bo_unpin(&bo->tbo);
1018         if (bo->tbo.pin_count)
1019                 return;
1020
1021         if (bo->tbo.base.import_attach)
1022                 dma_buf_unpin(bo->tbo.base.import_attach);
1023
1024         if (bo->tbo.resource->mem_type == TTM_PL_VRAM) {
1025                 atomic64_sub(amdgpu_bo_size(bo), &adev->vram_pin_size);
1026                 atomic64_sub(amdgpu_vram_mgr_bo_visible_size(bo),
1027                              &adev->visible_pin_size);
1028         } else if (bo->tbo.resource->mem_type == TTM_PL_TT) {
1029                 atomic64_sub(amdgpu_bo_size(bo), &adev->gart_pin_size);
1030         }
1031
1032 }
1033
1034 static const char * const amdgpu_vram_names[] = {
1035         "UNKNOWN",
1036         "GDDR1",
1037         "DDR2",
1038         "GDDR3",
1039         "GDDR4",
1040         "GDDR5",
1041         "HBM",
1042         "DDR3",
1043         "DDR4",
1044         "GDDR6",
1045         "DDR5",
1046         "LPDDR4",
1047         "LPDDR5"
1048 };
1049
1050 /**
1051  * amdgpu_bo_init - initialize memory manager
1052  * @adev: amdgpu device object
1053  *
1054  * Calls amdgpu_ttm_init() to initialize amdgpu memory manager.
1055  *
1056  * Returns:
1057  * 0 for success or a negative error code on failure.
1058  */
1059 int amdgpu_bo_init(struct amdgpu_device *adev)
1060 {
1061         /* On A+A platform, VRAM can be mapped as WB */
1062         if (!adev->gmc.xgmi.connected_to_cpu && !adev->gmc.is_app_apu) {
1063                 /* reserve PAT memory space to WC for VRAM */
1064                 int r = arch_io_reserve_memtype_wc(adev->gmc.aper_base,
1065                                 adev->gmc.aper_size);
1066
1067                 if (r) {
1068                         DRM_ERROR("Unable to set WC memtype for the aperture base\n");
1069                         return r;
1070                 }
1071
1072                 /* Add an MTRR for the VRAM */
1073                 adev->gmc.vram_mtrr = arch_phys_wc_add(adev->gmc.aper_base,
1074                                 adev->gmc.aper_size);
1075         }
1076
1077         DRM_INFO("Detected VRAM RAM=%lluM, BAR=%lluM\n",
1078                  adev->gmc.mc_vram_size >> 20,
1079                  (unsigned long long)adev->gmc.aper_size >> 20);
1080         DRM_INFO("RAM width %dbits %s\n",
1081                  adev->gmc.vram_width, amdgpu_vram_names[adev->gmc.vram_type]);
1082         return amdgpu_ttm_init(adev);
1083 }
1084
1085 /**
1086  * amdgpu_bo_fini - tear down memory manager
1087  * @adev: amdgpu device object
1088  *
1089  * Reverses amdgpu_bo_init() to tear down memory manager.
1090  */
1091 void amdgpu_bo_fini(struct amdgpu_device *adev)
1092 {
1093         int idx;
1094
1095         amdgpu_ttm_fini(adev);
1096
1097         if (drm_dev_enter(adev_to_drm(adev), &idx)) {
1098                 if (!adev->gmc.xgmi.connected_to_cpu && !adev->gmc.is_app_apu) {
1099                         arch_phys_wc_del(adev->gmc.vram_mtrr);
1100                         arch_io_free_memtype_wc(adev->gmc.aper_base, adev->gmc.aper_size);
1101                 }
1102                 drm_dev_exit(idx);
1103         }
1104 }
1105
1106 /**
1107  * amdgpu_bo_set_tiling_flags - set tiling flags
1108  * @bo: &amdgpu_bo buffer object
1109  * @tiling_flags: new flags
1110  *
1111  * Sets buffer object's tiling flags with the new one. Used by GEM ioctl or
1112  * kernel driver to set the tiling flags on a buffer.
1113  *
1114  * Returns:
1115  * 0 for success or a negative error code on failure.
1116  */
1117 int amdgpu_bo_set_tiling_flags(struct amdgpu_bo *bo, u64 tiling_flags)
1118 {
1119         struct amdgpu_device *adev = amdgpu_ttm_adev(bo->tbo.bdev);
1120         struct amdgpu_bo_user *ubo;
1121
1122         BUG_ON(bo->tbo.type == ttm_bo_type_kernel);
1123         if (adev->family <= AMDGPU_FAMILY_CZ &&
1124             AMDGPU_TILING_GET(tiling_flags, TILE_SPLIT) > 6)
1125                 return -EINVAL;
1126
1127         ubo = to_amdgpu_bo_user(bo);
1128         ubo->tiling_flags = tiling_flags;
1129         return 0;
1130 }
1131
1132 /**
1133  * amdgpu_bo_get_tiling_flags - get tiling flags
1134  * @bo: &amdgpu_bo buffer object
1135  * @tiling_flags: returned flags
1136  *
1137  * Gets buffer object's tiling flags. Used by GEM ioctl or kernel driver to
1138  * set the tiling flags on a buffer.
1139  */
1140 void amdgpu_bo_get_tiling_flags(struct amdgpu_bo *bo, u64 *tiling_flags)
1141 {
1142         struct amdgpu_bo_user *ubo;
1143
1144         BUG_ON(bo->tbo.type == ttm_bo_type_kernel);
1145         dma_resv_assert_held(bo->tbo.base.resv);
1146         ubo = to_amdgpu_bo_user(bo);
1147
1148         if (tiling_flags)
1149                 *tiling_flags = ubo->tiling_flags;
1150 }
1151
1152 /**
1153  * amdgpu_bo_set_metadata - set metadata
1154  * @bo: &amdgpu_bo buffer object
1155  * @metadata: new metadata
1156  * @metadata_size: size of the new metadata
1157  * @flags: flags of the new metadata
1158  *
1159  * Sets buffer object's metadata, its size and flags.
1160  * Used via GEM ioctl.
1161  *
1162  * Returns:
1163  * 0 for success or a negative error code on failure.
1164  */
1165 int amdgpu_bo_set_metadata(struct amdgpu_bo *bo, void *metadata,
1166                            u32 metadata_size, uint64_t flags)
1167 {
1168         struct amdgpu_bo_user *ubo;
1169         void *buffer;
1170
1171         BUG_ON(bo->tbo.type == ttm_bo_type_kernel);
1172         ubo = to_amdgpu_bo_user(bo);
1173         if (!metadata_size) {
1174                 if (ubo->metadata_size) {
1175                         kfree(ubo->metadata);
1176                         ubo->metadata = NULL;
1177                         ubo->metadata_size = 0;
1178                 }
1179                 return 0;
1180         }
1181
1182         if (metadata == NULL)
1183                 return -EINVAL;
1184
1185         buffer = kmemdup(metadata, metadata_size, GFP_KERNEL);
1186         if (buffer == NULL)
1187                 return -ENOMEM;
1188
1189         kfree(ubo->metadata);
1190         ubo->metadata_flags = flags;
1191         ubo->metadata = buffer;
1192         ubo->metadata_size = metadata_size;
1193
1194         return 0;
1195 }
1196
1197 /**
1198  * amdgpu_bo_get_metadata - get metadata
1199  * @bo: &amdgpu_bo buffer object
1200  * @buffer: returned metadata
1201  * @buffer_size: size of the buffer
1202  * @metadata_size: size of the returned metadata
1203  * @flags: flags of the returned metadata
1204  *
1205  * Gets buffer object's metadata, its size and flags. buffer_size shall not be
1206  * less than metadata_size.
1207  * Used via GEM ioctl.
1208  *
1209  * Returns:
1210  * 0 for success or a negative error code on failure.
1211  */
1212 int amdgpu_bo_get_metadata(struct amdgpu_bo *bo, void *buffer,
1213                            size_t buffer_size, uint32_t *metadata_size,
1214                            uint64_t *flags)
1215 {
1216         struct amdgpu_bo_user *ubo;
1217
1218         if (!buffer && !metadata_size)
1219                 return -EINVAL;
1220
1221         BUG_ON(bo->tbo.type == ttm_bo_type_kernel);
1222         ubo = to_amdgpu_bo_user(bo);
1223         if (metadata_size)
1224                 *metadata_size = ubo->metadata_size;
1225
1226         if (buffer) {
1227                 if (buffer_size < ubo->metadata_size)
1228                         return -EINVAL;
1229
1230                 if (ubo->metadata_size)
1231                         memcpy(buffer, ubo->metadata, ubo->metadata_size);
1232         }
1233
1234         if (flags)
1235                 *flags = ubo->metadata_flags;
1236
1237         return 0;
1238 }
1239
1240 /**
1241  * amdgpu_bo_move_notify - notification about a memory move
1242  * @bo: pointer to a buffer object
1243  * @evict: if this move is evicting the buffer from the graphics address space
1244  * @new_mem: new resource for backing the BO
1245  *
1246  * Marks the corresponding &amdgpu_bo buffer object as invalid, also performs
1247  * bookkeeping.
1248  * TTM driver callback which is called when ttm moves a buffer.
1249  */
1250 void amdgpu_bo_move_notify(struct ttm_buffer_object *bo,
1251                            bool evict,
1252                            struct ttm_resource *new_mem)
1253 {
1254         struct amdgpu_device *adev = amdgpu_ttm_adev(bo->bdev);
1255         struct ttm_resource *old_mem = bo->resource;
1256         struct amdgpu_bo *abo;
1257
1258         if (!amdgpu_bo_is_amdgpu_bo(bo))
1259                 return;
1260
1261         abo = ttm_to_amdgpu_bo(bo);
1262         amdgpu_vm_bo_invalidate(adev, abo, evict);
1263
1264         amdgpu_bo_kunmap(abo);
1265
1266         if (abo->tbo.base.dma_buf && !abo->tbo.base.import_attach &&
1267             old_mem && old_mem->mem_type != TTM_PL_SYSTEM)
1268                 dma_buf_move_notify(abo->tbo.base.dma_buf);
1269
1270         /* move_notify is called before move happens */
1271         trace_amdgpu_bo_move(abo, new_mem ? new_mem->mem_type : -1,
1272                              old_mem ? old_mem->mem_type : -1);
1273 }
1274
1275 void amdgpu_bo_get_memory(struct amdgpu_bo *bo,
1276                           struct amdgpu_mem_stats *stats,
1277                           unsigned int sz)
1278 {
1279         const unsigned int domain_to_pl[] = {
1280                 [ilog2(AMDGPU_GEM_DOMAIN_CPU)]      = TTM_PL_SYSTEM,
1281                 [ilog2(AMDGPU_GEM_DOMAIN_GTT)]      = TTM_PL_TT,
1282                 [ilog2(AMDGPU_GEM_DOMAIN_VRAM)]     = TTM_PL_VRAM,
1283                 [ilog2(AMDGPU_GEM_DOMAIN_GDS)]      = AMDGPU_PL_GDS,
1284                 [ilog2(AMDGPU_GEM_DOMAIN_GWS)]      = AMDGPU_PL_GWS,
1285                 [ilog2(AMDGPU_GEM_DOMAIN_OA)]       = AMDGPU_PL_OA,
1286                 [ilog2(AMDGPU_GEM_DOMAIN_DOORBELL)] = AMDGPU_PL_DOORBELL,
1287         };
1288         struct amdgpu_device *adev = amdgpu_ttm_adev(bo->tbo.bdev);
1289         struct ttm_resource *res = bo->tbo.resource;
1290         struct drm_gem_object *obj = &bo->tbo.base;
1291         uint64_t size = amdgpu_bo_size(bo);
1292         unsigned int type;
1293
1294         if (!res) {
1295                 /*
1296                  * If no backing store use one of the preferred domain for basic
1297                  * stats. We take the MSB since that should give a reasonable
1298                  * view.
1299                  */
1300                 BUILD_BUG_ON(TTM_PL_VRAM < TTM_PL_TT ||
1301                              TTM_PL_VRAM < TTM_PL_SYSTEM);
1302                 type = fls(bo->preferred_domains & AMDGPU_GEM_DOMAIN_MASK);
1303                 if (!type)
1304                         return;
1305                 type--;
1306                 if (drm_WARN_ON_ONCE(&adev->ddev,
1307                                      type >= ARRAY_SIZE(domain_to_pl)))
1308                         return;
1309                 type = domain_to_pl[type];
1310         } else {
1311                 type = res->mem_type;
1312         }
1313
1314         if (drm_WARN_ON_ONCE(&adev->ddev, type >= sz))
1315                 return;
1316
1317         /* DRM stats common fields: */
1318
1319         if (drm_gem_object_is_shared_for_memory_stats(obj))
1320                 stats[type].drm.shared += size;
1321         else
1322                 stats[type].drm.private += size;
1323
1324         if (res) {
1325                 stats[type].drm.resident += size;
1326
1327                 if (!dma_resv_test_signaled(obj->resv, DMA_RESV_USAGE_BOOKKEEP))
1328                         stats[type].drm.active += size;
1329                 else if (bo->flags & AMDGPU_GEM_CREATE_DISCARDABLE)
1330                         stats[type].drm.purgeable += size;
1331         }
1332
1333         /* amdgpu specific stats: */
1334
1335         if (bo->preferred_domains & AMDGPU_GEM_DOMAIN_VRAM) {
1336                 stats[TTM_PL_VRAM].requested += size;
1337                 if (type != TTM_PL_VRAM)
1338                         stats[TTM_PL_VRAM].evicted += size;
1339         } else if (bo->preferred_domains & AMDGPU_GEM_DOMAIN_GTT) {
1340                 stats[TTM_PL_TT].requested += size;
1341         }
1342 }
1343
1344 /**
1345  * amdgpu_bo_release_notify - notification about a BO being released
1346  * @bo: pointer to a buffer object
1347  *
1348  * Wipes VRAM buffers whose contents should not be leaked before the
1349  * memory is released.
1350  */
1351 void amdgpu_bo_release_notify(struct ttm_buffer_object *bo)
1352 {
1353         struct amdgpu_device *adev = amdgpu_ttm_adev(bo->bdev);
1354         struct dma_fence *fence = NULL;
1355         struct amdgpu_bo *abo;
1356         int r;
1357
1358         if (!amdgpu_bo_is_amdgpu_bo(bo))
1359                 return;
1360
1361         abo = ttm_to_amdgpu_bo(bo);
1362
1363         WARN_ON(abo->vm_bo);
1364
1365         if (abo->kfd_bo)
1366                 amdgpu_amdkfd_release_notify(abo);
1367
1368         /* We only remove the fence if the resv has individualized. */
1369         WARN_ON_ONCE(bo->type == ttm_bo_type_kernel
1370                         && bo->base.resv != &bo->base._resv);
1371         if (bo->base.resv == &bo->base._resv)
1372                 amdgpu_amdkfd_remove_fence_on_pt_pd_bos(abo);
1373
1374         if (!bo->resource || bo->resource->mem_type != TTM_PL_VRAM ||
1375             !(abo->flags & AMDGPU_GEM_CREATE_VRAM_WIPE_ON_RELEASE) ||
1376             adev->in_suspend || drm_dev_is_unplugged(adev_to_drm(adev)))
1377                 return;
1378
1379         if (WARN_ON_ONCE(!dma_resv_trylock(bo->base.resv)))
1380                 return;
1381
1382         r = amdgpu_fill_buffer(abo, 0, bo->base.resv, &fence, true);
1383         if (!WARN_ON(r)) {
1384                 amdgpu_vram_mgr_set_cleared(bo->resource);
1385                 amdgpu_bo_fence(abo, fence, false);
1386                 dma_fence_put(fence);
1387         }
1388
1389         dma_resv_unlock(bo->base.resv);
1390 }
1391
1392 /**
1393  * amdgpu_bo_fault_reserve_notify - notification about a memory fault
1394  * @bo: pointer to a buffer object
1395  *
1396  * Notifies the driver we are taking a fault on this BO and have reserved it,
1397  * also performs bookkeeping.
1398  * TTM driver callback for dealing with vm faults.
1399  *
1400  * Returns:
1401  * 0 for success or a negative error code on failure.
1402  */
1403 vm_fault_t amdgpu_bo_fault_reserve_notify(struct ttm_buffer_object *bo)
1404 {
1405         struct amdgpu_device *adev = amdgpu_ttm_adev(bo->bdev);
1406         struct ttm_operation_ctx ctx = { false, false };
1407         struct amdgpu_bo *abo = ttm_to_amdgpu_bo(bo);
1408         int r;
1409
1410         /* Remember that this BO was accessed by the CPU */
1411         abo->flags |= AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED;
1412
1413         if (amdgpu_res_cpu_visible(adev, bo->resource))
1414                 return 0;
1415
1416         /* Can't move a pinned BO to visible VRAM */
1417         if (abo->tbo.pin_count > 0)
1418                 return VM_FAULT_SIGBUS;
1419
1420         /* hurrah the memory is not visible ! */
1421         atomic64_inc(&adev->num_vram_cpu_page_faults);
1422         amdgpu_bo_placement_from_domain(abo, AMDGPU_GEM_DOMAIN_VRAM |
1423                                         AMDGPU_GEM_DOMAIN_GTT);
1424
1425         /* Avoid costly evictions; only set GTT as a busy placement */
1426         abo->placements[0].flags |= TTM_PL_FLAG_DESIRED;
1427
1428         r = ttm_bo_validate(bo, &abo->placement, &ctx);
1429         if (unlikely(r == -EBUSY || r == -ERESTARTSYS))
1430                 return VM_FAULT_NOPAGE;
1431         else if (unlikely(r))
1432                 return VM_FAULT_SIGBUS;
1433
1434         /* this should never happen */
1435         if (bo->resource->mem_type == TTM_PL_VRAM &&
1436             !amdgpu_res_cpu_visible(adev, bo->resource))
1437                 return VM_FAULT_SIGBUS;
1438
1439         ttm_bo_move_to_lru_tail_unlocked(bo);
1440         return 0;
1441 }
1442
1443 /**
1444  * amdgpu_bo_fence - add fence to buffer object
1445  *
1446  * @bo: buffer object in question
1447  * @fence: fence to add
1448  * @shared: true if fence should be added shared
1449  *
1450  */
1451 void amdgpu_bo_fence(struct amdgpu_bo *bo, struct dma_fence *fence,
1452                      bool shared)
1453 {
1454         struct dma_resv *resv = bo->tbo.base.resv;
1455         int r;
1456
1457         r = dma_resv_reserve_fences(resv, 1);
1458         if (r) {
1459                 /* As last resort on OOM we block for the fence */
1460                 dma_fence_wait(fence, false);
1461                 return;
1462         }
1463
1464         dma_resv_add_fence(resv, fence, shared ? DMA_RESV_USAGE_READ :
1465                            DMA_RESV_USAGE_WRITE);
1466 }
1467
1468 /**
1469  * amdgpu_bo_sync_wait_resv - Wait for BO reservation fences
1470  *
1471  * @adev: amdgpu device pointer
1472  * @resv: reservation object to sync to
1473  * @sync_mode: synchronization mode
1474  * @owner: fence owner
1475  * @intr: Whether the wait is interruptible
1476  *
1477  * Extract the fences from the reservation object and waits for them to finish.
1478  *
1479  * Returns:
1480  * 0 on success, errno otherwise.
1481  */
1482 int amdgpu_bo_sync_wait_resv(struct amdgpu_device *adev, struct dma_resv *resv,
1483                              enum amdgpu_sync_mode sync_mode, void *owner,
1484                              bool intr)
1485 {
1486         struct amdgpu_sync sync;
1487         int r;
1488
1489         amdgpu_sync_create(&sync);
1490         amdgpu_sync_resv(adev, &sync, resv, sync_mode, owner);
1491         r = amdgpu_sync_wait(&sync, intr);
1492         amdgpu_sync_free(&sync);
1493         return r;
1494 }
1495
1496 /**
1497  * amdgpu_bo_sync_wait - Wrapper for amdgpu_bo_sync_wait_resv
1498  * @bo: buffer object to wait for
1499  * @owner: fence owner
1500  * @intr: Whether the wait is interruptible
1501  *
1502  * Wrapper to wait for fences in a BO.
1503  * Returns:
1504  * 0 on success, errno otherwise.
1505  */
1506 int amdgpu_bo_sync_wait(struct amdgpu_bo *bo, void *owner, bool intr)
1507 {
1508         struct amdgpu_device *adev = amdgpu_ttm_adev(bo->tbo.bdev);
1509
1510         return amdgpu_bo_sync_wait_resv(adev, bo->tbo.base.resv,
1511                                         AMDGPU_SYNC_NE_OWNER, owner, intr);
1512 }
1513
1514 /**
1515  * amdgpu_bo_gpu_offset - return GPU offset of bo
1516  * @bo: amdgpu object for which we query the offset
1517  *
1518  * Note: object should either be pinned or reserved when calling this
1519  * function, it might be useful to add check for this for debugging.
1520  *
1521  * Returns:
1522  * current GPU offset of the object.
1523  */
1524 u64 amdgpu_bo_gpu_offset(struct amdgpu_bo *bo)
1525 {
1526         WARN_ON_ONCE(bo->tbo.resource->mem_type == TTM_PL_SYSTEM);
1527         WARN_ON_ONCE(!dma_resv_is_locked(bo->tbo.base.resv) &&
1528                      !bo->tbo.pin_count && bo->tbo.type != ttm_bo_type_kernel);
1529         WARN_ON_ONCE(bo->tbo.resource->start == AMDGPU_BO_INVALID_OFFSET);
1530         WARN_ON_ONCE(bo->tbo.resource->mem_type == TTM_PL_VRAM &&
1531                      !(bo->flags & AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS));
1532
1533         return amdgpu_bo_gpu_offset_no_check(bo);
1534 }
1535
1536 /**
1537  * amdgpu_bo_gpu_offset_no_check - return GPU offset of bo
1538  * @bo: amdgpu object for which we query the offset
1539  *
1540  * Returns:
1541  * current GPU offset of the object without raising warnings.
1542  */
1543 u64 amdgpu_bo_gpu_offset_no_check(struct amdgpu_bo *bo)
1544 {
1545         struct amdgpu_device *adev = amdgpu_ttm_adev(bo->tbo.bdev);
1546         uint64_t offset = AMDGPU_BO_INVALID_OFFSET;
1547
1548         if (bo->tbo.resource->mem_type == TTM_PL_TT)
1549                 offset = amdgpu_gmc_agp_addr(&bo->tbo);
1550
1551         if (offset == AMDGPU_BO_INVALID_OFFSET)
1552                 offset = (bo->tbo.resource->start << PAGE_SHIFT) +
1553                         amdgpu_ttm_domain_start(adev, bo->tbo.resource->mem_type);
1554
1555         return amdgpu_gmc_sign_extend(offset);
1556 }
1557
1558 /**
1559  * amdgpu_bo_get_preferred_domain - get preferred domain
1560  * @adev: amdgpu device object
1561  * @domain: allowed :ref:`memory domains <amdgpu_memory_domains>`
1562  *
1563  * Returns:
1564  * Which of the allowed domains is preferred for allocating the BO.
1565  */
1566 uint32_t amdgpu_bo_get_preferred_domain(struct amdgpu_device *adev,
1567                                             uint32_t domain)
1568 {
1569         if ((domain == (AMDGPU_GEM_DOMAIN_VRAM | AMDGPU_GEM_DOMAIN_GTT)) &&
1570             ((adev->asic_type == CHIP_CARRIZO) || (adev->asic_type == CHIP_STONEY))) {
1571                 domain = AMDGPU_GEM_DOMAIN_VRAM;
1572                 if (adev->gmc.real_vram_size <= AMDGPU_SG_THRESHOLD)
1573                         domain = AMDGPU_GEM_DOMAIN_GTT;
1574         }
1575         return domain;
1576 }
1577
1578 #if defined(CONFIG_DEBUG_FS)
1579 #define amdgpu_bo_print_flag(m, bo, flag)                       \
1580         do {                                                    \
1581                 if (bo->flags & (AMDGPU_GEM_CREATE_ ## flag)) { \
1582                         seq_printf((m), " " #flag);             \
1583                 }                                               \
1584         } while (0)
1585
1586 /**
1587  * amdgpu_bo_print_info - print BO info in debugfs file
1588  *
1589  * @id: Index or Id of the BO
1590  * @bo: Requested BO for printing info
1591  * @m: debugfs file
1592  *
1593  * Print BO information in debugfs file
1594  *
1595  * Returns:
1596  * Size of the BO in bytes.
1597  */
1598 u64 amdgpu_bo_print_info(int id, struct amdgpu_bo *bo, struct seq_file *m)
1599 {
1600         struct amdgpu_device *adev = amdgpu_ttm_adev(bo->tbo.bdev);
1601         struct dma_buf_attachment *attachment;
1602         struct dma_buf *dma_buf;
1603         const char *placement;
1604         unsigned int pin_count;
1605         u64 size;
1606
1607         if (dma_resv_trylock(bo->tbo.base.resv)) {
1608                 if (!bo->tbo.resource) {
1609                         placement = "NONE";
1610                 } else {
1611                         switch (bo->tbo.resource->mem_type) {
1612                         case TTM_PL_VRAM:
1613                                 if (amdgpu_res_cpu_visible(adev, bo->tbo.resource))
1614                                         placement = "VRAM VISIBLE";
1615                                 else
1616                                         placement = "VRAM";
1617                                 break;
1618                         case TTM_PL_TT:
1619                                 placement = "GTT";
1620                                 break;
1621                         case AMDGPU_PL_GDS:
1622                                 placement = "GDS";
1623                                 break;
1624                         case AMDGPU_PL_GWS:
1625                                 placement = "GWS";
1626                                 break;
1627                         case AMDGPU_PL_OA:
1628                                 placement = "OA";
1629                                 break;
1630                         case AMDGPU_PL_PREEMPT:
1631                                 placement = "PREEMPTIBLE";
1632                                 break;
1633                         case AMDGPU_PL_DOORBELL:
1634                                 placement = "DOORBELL";
1635                                 break;
1636                         case TTM_PL_SYSTEM:
1637                         default:
1638                                 placement = "CPU";
1639                                 break;
1640                         }
1641                 }
1642                 dma_resv_unlock(bo->tbo.base.resv);
1643         } else {
1644                 placement = "UNKNOWN";
1645         }
1646
1647         size = amdgpu_bo_size(bo);
1648         seq_printf(m, "\t\t0x%08x: %12lld byte %s",
1649                         id, size, placement);
1650
1651         pin_count = READ_ONCE(bo->tbo.pin_count);
1652         if (pin_count)
1653                 seq_printf(m, " pin count %d", pin_count);
1654
1655         dma_buf = READ_ONCE(bo->tbo.base.dma_buf);
1656         attachment = READ_ONCE(bo->tbo.base.import_attach);
1657
1658         if (attachment)
1659                 seq_printf(m, " imported from ino:%lu", file_inode(dma_buf->file)->i_ino);
1660         else if (dma_buf)
1661                 seq_printf(m, " exported as ino:%lu", file_inode(dma_buf->file)->i_ino);
1662
1663         amdgpu_bo_print_flag(m, bo, CPU_ACCESS_REQUIRED);
1664         amdgpu_bo_print_flag(m, bo, NO_CPU_ACCESS);
1665         amdgpu_bo_print_flag(m, bo, CPU_GTT_USWC);
1666         amdgpu_bo_print_flag(m, bo, VRAM_CLEARED);
1667         amdgpu_bo_print_flag(m, bo, VRAM_CONTIGUOUS);
1668         amdgpu_bo_print_flag(m, bo, VM_ALWAYS_VALID);
1669         amdgpu_bo_print_flag(m, bo, EXPLICIT_SYNC);
1670
1671         seq_puts(m, "\n");
1672
1673         return size;
1674 }
1675 #endif