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

   1 /*
   2  * Copyright 2016 Advanced Micro Devices, Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20  * OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  * Authors: Christian König
  23  */
  24
  25 #include "amdgpu.h"
  26
  27 struct amdgpu_vram_mgr {
  28         struct drm_mm mm;
  29         spinlock_t lock;
  30         atomic64_t usage;
  31         atomic64_t vis_usage;
  32 };
  33
  34 /**
  35  * DOC: mem_info_vram_total
  36  *
  37  * The amdgpu driver provides a sysfs API for reporting current total VRAM
  38  * available on the device
  39  * The file mem_info_vram_total is used for this and returns the total
  40  * amount of VRAM in bytes
  41  */
  42 static ssize_t amdgpu_mem_info_vram_total_show(struct device *dev,
  43                 struct device_attribute *attr, char *buf)
  44 {
  45         struct drm_device *ddev = dev_get_drvdata(dev);
  46         struct amdgpu_device *adev = ddev->dev_private;
  47
  48         return snprintf(buf, PAGE_SIZE, "%llu\n", adev->gmc.real_vram_size);
  49 }
  50
  51 /**
  52  * DOC: mem_info_vis_vram_total
  53  *
  54  * The amdgpu driver provides a sysfs API for reporting current total
  55  * visible VRAM available on the device
  56  * The file mem_info_vis_vram_total is used for this and returns the total
  57  * amount of visible VRAM in bytes
  58  */
  59 static ssize_t amdgpu_mem_info_vis_vram_total_show(struct device *dev,
  60                 struct device_attribute *attr, char *buf)
  61 {
  62         struct drm_device *ddev = dev_get_drvdata(dev);
  63         struct amdgpu_device *adev = ddev->dev_private;
  64
  65         return snprintf(buf, PAGE_SIZE, "%llu\n", adev->gmc.visible_vram_size);
  66 }
  67
  68 /**
  69  * DOC: mem_info_vram_used
  70  *
  71  * The amdgpu driver provides a sysfs API for reporting current total VRAM
  72  * available on the device
  73  * The file mem_info_vram_used is used for this and returns the total
  74  * amount of currently used VRAM in bytes
  75  */
  76 static ssize_t amdgpu_mem_info_vram_used_show(struct device *dev,
  77                 struct device_attribute *attr, char *buf)
  78 {
  79         struct drm_device *ddev = dev_get_drvdata(dev);
  80         struct amdgpu_device *adev = ddev->dev_private;
  81
  82         return snprintf(buf, PAGE_SIZE, "%llu\n",
  83                 amdgpu_vram_mgr_usage(&adev->mman.bdev.man[TTM_PL_VRAM]));
  84 }
  85
  86 /**
  87  * DOC: mem_info_vis_vram_used
  88  *
  89  * The amdgpu driver provides a sysfs API for reporting current total of
  90  * used visible VRAM
  91  * The file mem_info_vis_vram_used is used for this and returns the total
  92  * amount of currently used visible VRAM in bytes
  93  */
  94 static ssize_t amdgpu_mem_info_vis_vram_used_show(struct device *dev,
  95                 struct device_attribute *attr, char *buf)
  96 {
  97         struct drm_device *ddev = dev_get_drvdata(dev);
  98         struct amdgpu_device *adev = ddev->dev_private;
  99
 100         return snprintf(buf, PAGE_SIZE, "%llu\n",
 101                 amdgpu_vram_mgr_vis_usage(&adev->mman.bdev.man[TTM_PL_VRAM]));
 102 }
 103
 104 static DEVICE_ATTR(mem_info_vram_total, S_IRUGO,
 105                    amdgpu_mem_info_vram_total_show, NULL);
 106 static DEVICE_ATTR(mem_info_vis_vram_total, S_IRUGO,
 107                    amdgpu_mem_info_vis_vram_total_show,NULL);
 108 static DEVICE_ATTR(mem_info_vram_used, S_IRUGO,
 109                    amdgpu_mem_info_vram_used_show, NULL);
 110 static DEVICE_ATTR(mem_info_vis_vram_used, S_IRUGO,
 111                    amdgpu_mem_info_vis_vram_used_show, NULL);
 112
 113 /**
 114  * amdgpu_vram_mgr_init - init VRAM manager and DRM MM
 115  *
 116  * @man: TTM memory type manager
 117  * @p_size: maximum size of VRAM
 118  *
 119  * Allocate and initialize the VRAM manager.
 120  */
 121 static int amdgpu_vram_mgr_init(struct ttm_mem_type_manager *man,
 122                                 unsigned long p_size)
 123 {
 124         struct amdgpu_device *adev = amdgpu_ttm_adev(man->bdev);
 125         struct amdgpu_vram_mgr *mgr;
 126         int ret;
 127
 128         mgr = kzalloc(sizeof(*mgr), GFP_KERNEL);
 129         if (!mgr)
 130                 return -ENOMEM;
 131
 132         drm_mm_init(&mgr->mm, 0, p_size);
 133         spin_lock_init(&mgr->lock);
 134         man->priv = mgr;
 135
 136         /* Add the two VRAM-related sysfs files */
 137         ret = device_create_file(adev->dev, &dev_attr_mem_info_vram_total);
 138         if (ret) {
 139                 DRM_ERROR("Failed to create device file mem_info_vram_total\n");
 140                 return ret;
 141         }
 142         ret = device_create_file(adev->dev, &dev_attr_mem_info_vis_vram_total);
 143         if (ret) {
 144                 DRM_ERROR("Failed to create device file mem_info_vis_vram_total\n");
 145                 return ret;
 146         }
 147         ret = device_create_file(adev->dev, &dev_attr_mem_info_vram_used);
 148         if (ret) {
 149                 DRM_ERROR("Failed to create device file mem_info_vram_used\n");
 150                 return ret;
 151         }
 152         ret = device_create_file(adev->dev, &dev_attr_mem_info_vis_vram_used);
 153         if (ret) {
 154                 DRM_ERROR("Failed to create device file mem_info_vis_vram_used\n");
 155                 return ret;
 156         }
 157
 158         return 0;
 159 }
 160
 161 /**
 162  * amdgpu_vram_mgr_fini - free and destroy VRAM manager
 163  *
 164  * @man: TTM memory type manager
 165  *
 166  * Destroy and free the VRAM manager, returns -EBUSY if ranges are still
 167  * allocated inside it.
 168  */
 169 static int amdgpu_vram_mgr_fini(struct ttm_mem_type_manager *man)
 170 {
 171         struct amdgpu_device *adev = amdgpu_ttm_adev(man->bdev);
 172         struct amdgpu_vram_mgr *mgr = man->priv;
 173
 174         spin_lock(&mgr->lock);
 175         drm_mm_takedown(&mgr->mm);
 176         spin_unlock(&mgr->lock);
 177         kfree(mgr);
 178         man->priv = NULL;
 179         device_remove_file(adev->dev, &dev_attr_mem_info_vram_total);
 180         device_remove_file(adev->dev, &dev_attr_mem_info_vis_vram_total);
 181         device_remove_file(adev->dev, &dev_attr_mem_info_vram_used);
 182         device_remove_file(adev->dev, &dev_attr_mem_info_vis_vram_used);
 183         return 0;
 184 }
 185
 186 /**
 187  * amdgpu_vram_mgr_vis_size - Calculate visible node size
 188  *
 189  * @adev: amdgpu device structure
 190  * @node: MM node structure
 191  *
 192  * Calculate how many bytes of the MM node are inside visible VRAM
 193  */
 194 static u64 amdgpu_vram_mgr_vis_size(struct amdgpu_device *adev,
 195                                     struct drm_mm_node *node)
 196 {
 197         uint64_t start = node->start << PAGE_SHIFT;
 198         uint64_t end = (node->size + node->start) << PAGE_SHIFT;
 199
 200         if (start >= adev->gmc.visible_vram_size)
 201                 return 0;
 202
 203         return (end > adev->gmc.visible_vram_size ?
 204                 adev->gmc.visible_vram_size : end) - start;
 205 }
 206
 207 /**
 208  * amdgpu_vram_mgr_bo_visible_size - CPU visible BO size
 209  *
 210  * @bo: &amdgpu_bo buffer object (must be in VRAM)
 211  *
 212  * Returns:
 213  * How much of the given &amdgpu_bo buffer object lies in CPU visible VRAM.
 214  */
 215 u64 amdgpu_vram_mgr_bo_visible_size(struct amdgpu_bo *bo)
 216 {
 217         struct amdgpu_device *adev = amdgpu_ttm_adev(bo->tbo.bdev);
 218         struct ttm_mem_reg *mem = &bo->tbo.mem;
 219         struct drm_mm_node *nodes = mem->mm_node;
 220         unsigned pages = mem->num_pages;
 221         u64 usage;
 222
 223         if (amdgpu_gmc_vram_full_visible(&adev->gmc))
 224                 return amdgpu_bo_size(bo);
 225
 226         if (mem->start >= adev->gmc.visible_vram_size >> PAGE_SHIFT)
 227                 return 0;
 228
 229         for (usage = 0; nodes && pages; pages -= nodes->size, nodes++)
 230                 usage += amdgpu_vram_mgr_vis_size(adev, nodes);
 231
 232         return usage;
 233 }
 234
 235 /**
 236  * amdgpu_vram_mgr_virt_start - update virtual start address
 237  *
 238  * @mem: ttm_mem_reg to update
 239  * @node: just allocated node
 240  *
 241  * Calculate a virtual BO start address to easily check if everything is CPU
 242  * accessible.
 243  */
 244 static void amdgpu_vram_mgr_virt_start(struct ttm_mem_reg *mem,
 245                                        struct drm_mm_node *node)
 246 {
 247         unsigned long start;
 248
 249         start = node->start + node->size;
 250         if (start > mem->num_pages)
 251                 start -= mem->num_pages;
 252         else
 253                 start = 0;
 254         mem->start = max(mem->start, start);
 255 }
 256
 257 /**
 258  * amdgpu_vram_mgr_new - allocate new ranges
 259  *
 260  * @man: TTM memory type manager
 261  * @tbo: TTM BO we need this range for
 262  * @place: placement flags and restrictions
 263  * @mem: the resulting mem object
 264  *
 265  * Allocate VRAM for the given BO.
 266  */
 267 static int amdgpu_vram_mgr_new(struct ttm_mem_type_manager *man,
 268                                struct ttm_buffer_object *tbo,
 269                                const struct ttm_place *place,
 270                                struct ttm_mem_reg *mem)
 271 {
 272         struct amdgpu_device *adev = amdgpu_ttm_adev(man->bdev);
 273         struct amdgpu_vram_mgr *mgr = man->priv;
 274         struct drm_mm *mm = &mgr->mm;
 275         struct drm_mm_node *nodes;
 276         enum drm_mm_insert_mode mode;
 277         unsigned long lpfn, num_nodes, pages_per_node, pages_left;
 278         uint64_t usage = 0, vis_usage = 0;
 279         unsigned i;
 280         int r;
 281
 282         lpfn = place->lpfn;
 283         if (!lpfn)
 284                 lpfn = man->size;
 285
 286         if (place->flags & TTM_PL_FLAG_CONTIGUOUS ||
 287             amdgpu_vram_page_split == -1) {
 288                 pages_per_node = ~0ul;
 289                 num_nodes = 1;
 290         } else {
 291                 pages_per_node = max((uint32_t)amdgpu_vram_page_split,
 292                                      mem->page_alignment);
 293                 num_nodes = DIV_ROUND_UP(mem->num_pages, pages_per_node);
 294         }
 295
 296         nodes = kvmalloc_array(num_nodes, sizeof(*nodes),
 297                                GFP_KERNEL | __GFP_ZERO);
 298         if (!nodes)
 299                 return -ENOMEM;
 300
 301         mode = DRM_MM_INSERT_BEST;
 302         if (place->flags & TTM_PL_FLAG_TOPDOWN)
 303                 mode = DRM_MM_INSERT_HIGH;
 304
 305         mem->start = 0;
 306         pages_left = mem->num_pages;
 307
 308         spin_lock(&mgr->lock);
 309         for (i = 0; pages_left >= pages_per_node; ++i) {
 310                 unsigned long pages = rounddown_pow_of_two(pages_left);
 311
 312                 r = drm_mm_insert_node_in_range(mm, &nodes[i], pages,
 313                                                 pages_per_node, 0,
 314                                                 place->fpfn, lpfn,
 315                                                 mode);
 316                 if (unlikely(r))
 317                         break;
 318
 319                 usage += nodes[i].size << PAGE_SHIFT;
 320                 vis_usage += amdgpu_vram_mgr_vis_size(adev, &nodes[i]);
 321                 amdgpu_vram_mgr_virt_start(mem, &nodes[i]);
 322                 pages_left -= pages;
 323         }
 324
 325         for (; pages_left; ++i) {
 326                 unsigned long pages = min(pages_left, pages_per_node);
 327                 uint32_t alignment = mem->page_alignment;
 328
 329                 if (pages == pages_per_node)
 330                         alignment = pages_per_node;
 331
 332                 r = drm_mm_insert_node_in_range(mm, &nodes[i],
 333                                                 pages, alignment, 0,
 334                                                 place->fpfn, lpfn,
 335                                                 mode);
 336                 if (unlikely(r))
 337                         goto error;
 338
 339                 usage += nodes[i].size << PAGE_SHIFT;
 340                 vis_usage += amdgpu_vram_mgr_vis_size(adev, &nodes[i]);
 341                 amdgpu_vram_mgr_virt_start(mem, &nodes[i]);
 342                 pages_left -= pages;
 343         }
 344         spin_unlock(&mgr->lock);
 345
 346         atomic64_add(usage, &mgr->usage);
 347         atomic64_add(vis_usage, &mgr->vis_usage);
 348
 349         mem->mm_node = nodes;
 350
 351         return 0;
 352
 353 error:
 354         while (i--)
 355                 drm_mm_remove_node(&nodes[i]);
 356         spin_unlock(&mgr->lock);
 357
 358         kvfree(nodes);
 359         return r == -ENOSPC ? 0 : r;
 360 }
 361
 362 /**
 363  * amdgpu_vram_mgr_del - free ranges
 364  *
 365  * @man: TTM memory type manager
 366  * @tbo: TTM BO we need this range for
 367  * @place: placement flags and restrictions
 368  * @mem: TTM memory object
 369  *
 370  * Free the allocated VRAM again.
 371  */
 372 static void amdgpu_vram_mgr_del(struct ttm_mem_type_manager *man,
 373                                 struct ttm_mem_reg *mem)
 374 {
 375         struct amdgpu_device *adev = amdgpu_ttm_adev(man->bdev);
 376         struct amdgpu_vram_mgr *mgr = man->priv;
 377         struct drm_mm_node *nodes = mem->mm_node;
 378         uint64_t usage = 0, vis_usage = 0;
 379         unsigned pages = mem->num_pages;
 380
 381         if (!mem->mm_node)
 382                 return;
 383
 384         spin_lock(&mgr->lock);
 385         while (pages) {
 386                 pages -= nodes->size;
 387                 drm_mm_remove_node(nodes);
 388                 usage += nodes->size << PAGE_SHIFT;
 389                 vis_usage += amdgpu_vram_mgr_vis_size(adev, nodes);
 390                 ++nodes;
 391         }
 392         spin_unlock(&mgr->lock);
 393
 394         atomic64_sub(usage, &mgr->usage);
 395         atomic64_sub(vis_usage, &mgr->vis_usage);
 396
 397         kvfree(mem->mm_node);
 398         mem->mm_node = NULL;
 399 }
 400
 401 /**
 402  * amdgpu_vram_mgr_usage - how many bytes are used in this domain
 403  *
 404  * @man: TTM memory type manager
 405  *
 406  * Returns how many bytes are used in this domain.
 407  */
 408 uint64_t amdgpu_vram_mgr_usage(struct ttm_mem_type_manager *man)
 409 {
 410         struct amdgpu_vram_mgr *mgr = man->priv;
 411
 412         return atomic64_read(&mgr->usage);
 413 }
 414
 415 /**
 416  * amdgpu_vram_mgr_vis_usage - how many bytes are used in the visible part
 417  *
 418  * @man: TTM memory type manager
 419  *
 420  * Returns how many bytes are used in the visible part of VRAM
 421  */
 422 uint64_t amdgpu_vram_mgr_vis_usage(struct ttm_mem_type_manager *man)
 423 {
 424         struct amdgpu_vram_mgr *mgr = man->priv;
 425
 426         return atomic64_read(&mgr->vis_usage);
 427 }
 428
 429 /**
 430  * amdgpu_vram_mgr_debug - dump VRAM table
 431  *
 432  * @man: TTM memory type manager
 433  * @printer: DRM printer to use
 434  *
 435  * Dump the table content using printk.
 436  */
 437 static void amdgpu_vram_mgr_debug(struct ttm_mem_type_manager *man,
 438                                   struct drm_printer *printer)
 439 {
 440         struct amdgpu_vram_mgr *mgr = man->priv;
 441
 442         spin_lock(&mgr->lock);
 443         drm_mm_print(&mgr->mm, printer);
 444         spin_unlock(&mgr->lock);
 445
 446         drm_printf(printer, "man size:%llu pages, ram usage:%lluMB, vis usage:%lluMB\n",
 447                    man->size, amdgpu_vram_mgr_usage(man) >> 20,
 448                    amdgpu_vram_mgr_vis_usage(man) >> 20);
 449 }
 450
 451 const struct ttm_mem_type_manager_func amdgpu_vram_mgr_func = {
 452         .init           = amdgpu_vram_mgr_init,
 453         .takedown       = amdgpu_vram_mgr_fini,
 454         .get_node       = amdgpu_vram_mgr_new,
 455         .put_node       = amdgpu_vram_mgr_del,
 456         .debug          = amdgpu_vram_mgr_debug
 457 };