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 <linux/dma-mapping.h> 26 #include <drm/ttm/ttm_range_manager.h> 27 28 #include "amdgpu.h" 29 #include "amdgpu_vm.h" 30 #include "amdgpu_res_cursor.h" 31 #include "amdgpu_atomfirmware.h" 32 #include "atom.h" 33 34 struct amdgpu_vram_reservation { 35 struct list_head node; 36 struct drm_mm_node mm_node; 37 }; 38 39 static inline struct amdgpu_vram_mgr * 40 to_vram_mgr(struct ttm_resource_manager *man) 41 { 42 return container_of(man, struct amdgpu_vram_mgr, manager); 43 } 44 45 static inline struct amdgpu_device * 46 to_amdgpu_device(struct amdgpu_vram_mgr *mgr) 47 { 48 return container_of(mgr, struct amdgpu_device, mman.vram_mgr); 49 } 50 51 /** 52 * DOC: mem_info_vram_total 53 * 54 * The amdgpu driver provides a sysfs API for reporting current total VRAM 55 * available on the device 56 * The file mem_info_vram_total is used for this and returns the total 57 * amount of VRAM in bytes 58 */ 59 static ssize_t amdgpu_mem_info_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 = drm_to_adev(ddev); 64 65 return sysfs_emit(buf, "%llu\n", adev->gmc.real_vram_size); 66 } 67 68 /** 69 * DOC: mem_info_vis_vram_total 70 * 71 * The amdgpu driver provides a sysfs API for reporting current total 72 * visible VRAM available on the device 73 * The file mem_info_vis_vram_total is used for this and returns the total 74 * amount of visible VRAM in bytes 75 */ 76 static ssize_t amdgpu_mem_info_vis_vram_total_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 = drm_to_adev(ddev); 81 82 return sysfs_emit(buf, "%llu\n", adev->gmc.visible_vram_size); 83 } 84 85 /** 86 * DOC: mem_info_vram_used 87 * 88 * The amdgpu driver provides a sysfs API for reporting current total VRAM 89 * available on the device 90 * The file mem_info_vram_used is used for this and returns the total 91 * amount of currently used VRAM in bytes 92 */ 93 static ssize_t amdgpu_mem_info_vram_used_show(struct device *dev, 94 struct device_attribute *attr, 95 char *buf) 96 { 97 struct drm_device *ddev = dev_get_drvdata(dev); 98 struct amdgpu_device *adev = drm_to_adev(ddev); 99 struct ttm_resource_manager *man; 100 101 man = ttm_manager_type(&adev->mman.bdev, TTM_PL_VRAM); 102 return sysfs_emit(buf, "%llu\n", amdgpu_vram_mgr_usage(man)); 103 } 104 105 /** 106 * DOC: mem_info_vis_vram_used 107 * 108 * The amdgpu driver provides a sysfs API for reporting current total of 109 * used visible VRAM 110 * The file mem_info_vis_vram_used is used for this and returns the total 111 * amount of currently used visible VRAM in bytes 112 */ 113 static ssize_t amdgpu_mem_info_vis_vram_used_show(struct device *dev, 114 struct device_attribute *attr, 115 char *buf) 116 { 117 struct drm_device *ddev = dev_get_drvdata(dev); 118 struct amdgpu_device *adev = drm_to_adev(ddev); 119 struct ttm_resource_manager *man; 120 121 man = ttm_manager_type(&adev->mman.bdev, TTM_PL_VRAM); 122 return sysfs_emit(buf, "%llu\n", amdgpu_vram_mgr_vis_usage(man)); 123 } 124 125 /** 126 * DOC: mem_info_vram_vendor 127 * 128 * The amdgpu driver provides a sysfs API for reporting the vendor of the 129 * installed VRAM 130 * The file mem_info_vram_vendor is used for this and returns the name of the 131 * vendor. 132 */ 133 static ssize_t amdgpu_mem_info_vram_vendor(struct device *dev, 134 struct device_attribute *attr, 135 char *buf) 136 { 137 struct drm_device *ddev = dev_get_drvdata(dev); 138 struct amdgpu_device *adev = drm_to_adev(ddev); 139 140 switch (adev->gmc.vram_vendor) { 141 case SAMSUNG: 142 return sysfs_emit(buf, "samsung\n"); 143 case INFINEON: 144 return sysfs_emit(buf, "infineon\n"); 145 case ELPIDA: 146 return sysfs_emit(buf, "elpida\n"); 147 case ETRON: 148 return sysfs_emit(buf, "etron\n"); 149 case NANYA: 150 return sysfs_emit(buf, "nanya\n"); 151 case HYNIX: 152 return sysfs_emit(buf, "hynix\n"); 153 case MOSEL: 154 return sysfs_emit(buf, "mosel\n"); 155 case WINBOND: 156 return sysfs_emit(buf, "winbond\n"); 157 case ESMT: 158 return sysfs_emit(buf, "esmt\n"); 159 case MICRON: 160 return sysfs_emit(buf, "micron\n"); 161 default: 162 return sysfs_emit(buf, "unknown\n"); 163 } 164 } 165 166 static DEVICE_ATTR(mem_info_vram_total, S_IRUGO, 167 amdgpu_mem_info_vram_total_show, NULL); 168 static DEVICE_ATTR(mem_info_vis_vram_total, S_IRUGO, 169 amdgpu_mem_info_vis_vram_total_show,NULL); 170 static DEVICE_ATTR(mem_info_vram_used, S_IRUGO, 171 amdgpu_mem_info_vram_used_show, NULL); 172 static DEVICE_ATTR(mem_info_vis_vram_used, S_IRUGO, 173 amdgpu_mem_info_vis_vram_used_show, NULL); 174 static DEVICE_ATTR(mem_info_vram_vendor, S_IRUGO, 175 amdgpu_mem_info_vram_vendor, NULL); 176 177 static struct attribute *amdgpu_vram_mgr_attributes[] = { 178 &dev_attr_mem_info_vram_total.attr, 179 &dev_attr_mem_info_vis_vram_total.attr, 180 &dev_attr_mem_info_vram_used.attr, 181 &dev_attr_mem_info_vis_vram_used.attr, 182 &dev_attr_mem_info_vram_vendor.attr, 183 NULL 184 }; 185 186 const struct attribute_group amdgpu_vram_mgr_attr_group = { 187 .attrs = amdgpu_vram_mgr_attributes 188 }; 189 190 /** 191 * amdgpu_vram_mgr_vis_size - Calculate visible node size 192 * 193 * @adev: amdgpu_device pointer 194 * @node: MM node structure 195 * 196 * Calculate how many bytes of the MM node are inside visible VRAM 197 */ 198 static u64 amdgpu_vram_mgr_vis_size(struct amdgpu_device *adev, 199 struct drm_mm_node *node) 200 { 201 uint64_t start = node->start << PAGE_SHIFT; 202 uint64_t end = (node->size + node->start) << PAGE_SHIFT; 203 204 if (start >= adev->gmc.visible_vram_size) 205 return 0; 206 207 return (end > adev->gmc.visible_vram_size ? 208 adev->gmc.visible_vram_size : end) - start; 209 } 210 211 /** 212 * amdgpu_vram_mgr_bo_visible_size - CPU visible BO size 213 * 214 * @bo: &amdgpu_bo buffer object (must be in VRAM) 215 * 216 * Returns: 217 * How much of the given &amdgpu_bo buffer object lies in CPU visible VRAM. 218 */ 219 u64 amdgpu_vram_mgr_bo_visible_size(struct amdgpu_bo *bo) 220 { 221 struct amdgpu_device *adev = amdgpu_ttm_adev(bo->tbo.bdev); 222 struct ttm_resource *res = bo->tbo.resource; 223 unsigned pages = res->num_pages; 224 struct drm_mm_node *mm; 225 u64 usage; 226 227 if (amdgpu_gmc_vram_full_visible(&adev->gmc)) 228 return amdgpu_bo_size(bo); 229 230 if (res->start >= adev->gmc.visible_vram_size >> PAGE_SHIFT) 231 return 0; 232 233 mm = &container_of(res, struct ttm_range_mgr_node, base)->mm_nodes[0]; 234 for (usage = 0; pages; pages -= mm->size, mm++) 235 usage += amdgpu_vram_mgr_vis_size(adev, mm); 236 237 return usage; 238 } 239 240 /* Commit the reservation of VRAM pages */ 241 static void amdgpu_vram_mgr_do_reserve(struct ttm_resource_manager *man) 242 { 243 struct amdgpu_vram_mgr *mgr = to_vram_mgr(man); 244 struct amdgpu_device *adev = to_amdgpu_device(mgr); 245 struct drm_mm *mm = &mgr->mm; 246 struct amdgpu_vram_reservation *rsv, *temp; 247 uint64_t vis_usage; 248 249 list_for_each_entry_safe(rsv, temp, &mgr->reservations_pending, node) { 250 if (drm_mm_reserve_node(mm, &rsv->mm_node)) 251 continue; 252 253 dev_dbg(adev->dev, "Reservation 0x%llx - %lld, Succeeded\n", 254 rsv->mm_node.start, rsv->mm_node.size); 255 256 vis_usage = amdgpu_vram_mgr_vis_size(adev, &rsv->mm_node); 257 atomic64_add(vis_usage, &mgr->vis_usage); 258 atomic64_add(rsv->mm_node.size << PAGE_SHIFT, &mgr->usage); 259 list_move(&rsv->node, &mgr->reserved_pages); 260 } 261 } 262 263 /** 264 * amdgpu_vram_mgr_reserve_range - Reserve a range from VRAM 265 * 266 * @man: TTM memory type manager 267 * @start: start address of the range in VRAM 268 * @size: size of the range 269 * 270 * Reserve memory from start addess with the specified size in VRAM 271 */ 272 int amdgpu_vram_mgr_reserve_range(struct ttm_resource_manager *man, 273 uint64_t start, uint64_t size) 274 { 275 struct amdgpu_vram_mgr *mgr = to_vram_mgr(man); 276 struct amdgpu_vram_reservation *rsv; 277 278 rsv = kzalloc(sizeof(*rsv), GFP_KERNEL); 279 if (!rsv) 280 return -ENOMEM; 281 282 INIT_LIST_HEAD(&rsv->node); 283 rsv->mm_node.start = start >> PAGE_SHIFT; 284 rsv->mm_node.size = size >> PAGE_SHIFT; 285 286 spin_lock(&mgr->lock); 287 list_add_tail(&mgr->reservations_pending, &rsv->node); 288 amdgpu_vram_mgr_do_reserve(man); 289 spin_unlock(&mgr->lock); 290 291 return 0; 292 } 293 294 /** 295 * amdgpu_vram_mgr_query_page_status - query the reservation status 296 * 297 * @man: TTM memory type manager 298 * @start: start address of a page in VRAM 299 * 300 * Returns: 301 * -EBUSY: the page is still hold and in pending list 302 * 0: the page has been reserved 303 * -ENOENT: the input page is not a reservation 304 */ 305 int amdgpu_vram_mgr_query_page_status(struct ttm_resource_manager *man, 306 uint64_t start) 307 { 308 struct amdgpu_vram_mgr *mgr = to_vram_mgr(man); 309 struct amdgpu_vram_reservation *rsv; 310 int ret; 311 312 spin_lock(&mgr->lock); 313 314 list_for_each_entry(rsv, &mgr->reservations_pending, node) { 315 if ((rsv->mm_node.start <= start) && 316 (start < (rsv->mm_node.start + rsv->mm_node.size))) { 317 ret = -EBUSY; 318 goto out; 319 } 320 } 321 322 list_for_each_entry(rsv, &mgr->reserved_pages, node) { 323 if ((rsv->mm_node.start <= start) && 324 (start < (rsv->mm_node.start + rsv->mm_node.size))) { 325 ret = 0; 326 goto out; 327 } 328 } 329 330 ret = -ENOENT; 331 out: 332 spin_unlock(&mgr->lock); 333 return ret; 334 } 335 336 /** 337 * amdgpu_vram_mgr_virt_start - update virtual start address 338 * 339 * @mem: ttm_resource to update 340 * @node: just allocated node 341 * 342 * Calculate a virtual BO start address to easily check if everything is CPU 343 * accessible. 344 */ 345 static void amdgpu_vram_mgr_virt_start(struct ttm_resource *mem, 346 struct drm_mm_node *node) 347 { 348 unsigned long start; 349 350 start = node->start + node->size; 351 if (start > mem->num_pages) 352 start -= mem->num_pages; 353 else 354 start = 0; 355 mem->start = max(mem->start, start); 356 } 357 358 /** 359 * amdgpu_vram_mgr_new - allocate new ranges 360 * 361 * @man: TTM memory type manager 362 * @tbo: TTM BO we need this range for 363 * @place: placement flags and restrictions 364 * @res: the resulting mem object 365 * 366 * Allocate VRAM for the given BO. 367 */ 368 static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man, 369 struct ttm_buffer_object *tbo, 370 const struct ttm_place *place, 371 struct ttm_resource **res) 372 { 373 unsigned long lpfn, num_nodes, pages_per_node, pages_left, pages; 374 struct amdgpu_vram_mgr *mgr = to_vram_mgr(man); 375 struct amdgpu_device *adev = to_amdgpu_device(mgr); 376 uint64_t vis_usage = 0, mem_bytes, max_bytes; 377 struct ttm_range_mgr_node *node; 378 struct drm_mm *mm = &mgr->mm; 379 enum drm_mm_insert_mode mode; 380 unsigned i; 381 int r; 382 383 lpfn = place->lpfn; 384 if (!lpfn) 385 lpfn = man->size; 386 387 max_bytes = adev->gmc.mc_vram_size; 388 if (tbo->type != ttm_bo_type_kernel) 389 max_bytes -= AMDGPU_VM_RESERVED_VRAM; 390 391 /* bail out quickly if there's likely not enough VRAM for this BO */ 392 mem_bytes = tbo->base.size; 393 if (atomic64_add_return(mem_bytes, &mgr->usage) > max_bytes) { 394 r = -ENOSPC; 395 goto error_sub; 396 } 397 398 if (place->flags & TTM_PL_FLAG_CONTIGUOUS) { 399 pages_per_node = ~0ul; 400 num_nodes = 1; 401 } else { 402 #ifdef CONFIG_TRANSPARENT_HUGEPAGE 403 pages_per_node = HPAGE_PMD_NR; 404 #else 405 /* default to 2MB */ 406 pages_per_node = 2UL << (20UL - PAGE_SHIFT); 407 #endif 408 pages_per_node = max_t(uint32_t, pages_per_node, 409 tbo->page_alignment); 410 num_nodes = DIV_ROUND_UP_ULL(PFN_UP(mem_bytes), pages_per_node); 411 } 412 413 node = kvmalloc(struct_size(node, mm_nodes, num_nodes), 414 GFP_KERNEL | __GFP_ZERO); 415 if (!node) { 416 r = -ENOMEM; 417 goto error_sub; 418 } 419 420 ttm_resource_init(tbo, place, &node->base); 421 422 mode = DRM_MM_INSERT_BEST; 423 if (place->flags & TTM_PL_FLAG_TOPDOWN) 424 mode = DRM_MM_INSERT_HIGH; 425 426 pages_left = node->base.num_pages; 427 428 /* Limit maximum size to 2GB due to SG table limitations */ 429 pages = min(pages_left, 2UL << (30 - PAGE_SHIFT)); 430 431 i = 0; 432 spin_lock(&mgr->lock); 433 while (pages_left) { 434 uint32_t alignment = tbo->page_alignment; 435 436 if (pages >= pages_per_node) 437 alignment = pages_per_node; 438 439 r = drm_mm_insert_node_in_range(mm, &node->mm_nodes[i], pages, 440 alignment, 0, place->fpfn, 441 lpfn, mode); 442 if (unlikely(r)) { 443 if (pages > pages_per_node) { 444 if (is_power_of_2(pages)) 445 pages = pages / 2; 446 else 447 pages = rounddown_pow_of_two(pages); 448 continue; 449 } 450 goto error_free; 451 } 452 453 vis_usage += amdgpu_vram_mgr_vis_size(adev, &node->mm_nodes[i]); 454 amdgpu_vram_mgr_virt_start(&node->base, &node->mm_nodes[i]); 455 pages_left -= pages; 456 ++i; 457 458 if (pages > pages_left) 459 pages = pages_left; 460 } 461 spin_unlock(&mgr->lock); 462 463 if (i == 1) 464 node->base.placement |= TTM_PL_FLAG_CONTIGUOUS; 465 466 if (adev->gmc.xgmi.connected_to_cpu) 467 node->base.bus.caching = ttm_cached; 468 else 469 node->base.bus.caching = ttm_write_combined; 470 471 atomic64_add(vis_usage, &mgr->vis_usage); 472 *res = &node->base; 473 return 0; 474 475 error_free: 476 while (i--) 477 drm_mm_remove_node(&node->mm_nodes[i]); 478 spin_unlock(&mgr->lock); 479 ttm_resource_fini(man, &node->base); 480 kvfree(node); 481 482 error_sub: 483 atomic64_sub(mem_bytes, &mgr->usage); 484 return r; 485 } 486 487 /** 488 * amdgpu_vram_mgr_del - free ranges 489 * 490 * @man: TTM memory type manager 491 * @res: TTM memory object 492 * 493 * Free the allocated VRAM again. 494 */ 495 static void amdgpu_vram_mgr_del(struct ttm_resource_manager *man, 496 struct ttm_resource *res) 497 { 498 struct ttm_range_mgr_node *node = to_ttm_range_mgr_node(res); 499 struct amdgpu_vram_mgr *mgr = to_vram_mgr(man); 500 struct amdgpu_device *adev = to_amdgpu_device(mgr); 501 uint64_t usage = 0, vis_usage = 0; 502 unsigned i, pages; 503 504 spin_lock(&mgr->lock); 505 for (i = 0, pages = res->num_pages; pages; 506 pages -= node->mm_nodes[i].size, ++i) { 507 struct drm_mm_node *mm = &node->mm_nodes[i]; 508 509 drm_mm_remove_node(mm); 510 usage += mm->size << PAGE_SHIFT; 511 vis_usage += amdgpu_vram_mgr_vis_size(adev, mm); 512 } 513 amdgpu_vram_mgr_do_reserve(man); 514 spin_unlock(&mgr->lock); 515 516 atomic64_sub(usage, &mgr->usage); 517 atomic64_sub(vis_usage, &mgr->vis_usage); 518 519 ttm_resource_fini(man, res); 520 kvfree(node); 521 } 522 523 /** 524 * amdgpu_vram_mgr_alloc_sgt - allocate and fill a sg table 525 * 526 * @adev: amdgpu device pointer 527 * @res: TTM memory object 528 * @offset: byte offset from the base of VRAM BO 529 * @length: number of bytes to export in sg_table 530 * @dev: the other device 531 * @dir: dma direction 532 * @sgt: resulting sg table 533 * 534 * Allocate and fill a sg table from a VRAM allocation. 535 */ 536 int amdgpu_vram_mgr_alloc_sgt(struct amdgpu_device *adev, 537 struct ttm_resource *res, 538 u64 offset, u64 length, 539 struct device *dev, 540 enum dma_data_direction dir, 541 struct sg_table **sgt) 542 { 543 struct amdgpu_res_cursor cursor; 544 struct scatterlist *sg; 545 int num_entries = 0; 546 int i, r; 547 548 *sgt = kmalloc(sizeof(**sgt), GFP_KERNEL); 549 if (!*sgt) 550 return -ENOMEM; 551 552 /* Determine the number of DRM_MM nodes to export */ 553 amdgpu_res_first(res, offset, length, &cursor); 554 while (cursor.remaining) { 555 num_entries++; 556 amdgpu_res_next(&cursor, cursor.size); 557 } 558 559 r = sg_alloc_table(*sgt, num_entries, GFP_KERNEL); 560 if (r) 561 goto error_free; 562 563 /* Initialize scatterlist nodes of sg_table */ 564 for_each_sgtable_sg((*sgt), sg, i) 565 sg->length = 0; 566 567 /* 568 * Walk down DRM_MM nodes to populate scatterlist nodes 569 * @note: Use iterator api to get first the DRM_MM node 570 * and the number of bytes from it. Access the following 571 * DRM_MM node(s) if more buffer needs to exported 572 */ 573 amdgpu_res_first(res, offset, length, &cursor); 574 for_each_sgtable_sg((*sgt), sg, i) { 575 phys_addr_t phys = cursor.start + adev->gmc.aper_base; 576 size_t size = cursor.size; 577 dma_addr_t addr; 578 579 addr = dma_map_resource(dev, phys, size, dir, 580 DMA_ATTR_SKIP_CPU_SYNC); 581 r = dma_mapping_error(dev, addr); 582 if (r) 583 goto error_unmap; 584 585 sg_set_page(sg, NULL, size, 0); 586 sg_dma_address(sg) = addr; 587 sg_dma_len(sg) = size; 588 589 amdgpu_res_next(&cursor, cursor.size); 590 } 591 592 return 0; 593 594 error_unmap: 595 for_each_sgtable_sg((*sgt), sg, i) { 596 if (!sg->length) 597 continue; 598 599 dma_unmap_resource(dev, sg->dma_address, 600 sg->length, dir, 601 DMA_ATTR_SKIP_CPU_SYNC); 602 } 603 sg_free_table(*sgt); 604 605 error_free: 606 kfree(*sgt); 607 return r; 608 } 609 610 /** 611 * amdgpu_vram_mgr_free_sgt - allocate and fill a sg table 612 * 613 * @dev: device pointer 614 * @dir: data direction of resource to unmap 615 * @sgt: sg table to free 616 * 617 * Free a previously allocate sg table. 618 */ 619 void amdgpu_vram_mgr_free_sgt(struct device *dev, 620 enum dma_data_direction dir, 621 struct sg_table *sgt) 622 { 623 struct scatterlist *sg; 624 int i; 625 626 for_each_sgtable_sg(sgt, sg, i) 627 dma_unmap_resource(dev, sg->dma_address, 628 sg->length, dir, 629 DMA_ATTR_SKIP_CPU_SYNC); 630 sg_free_table(sgt); 631 kfree(sgt); 632 } 633 634 /** 635 * amdgpu_vram_mgr_usage - how many bytes are used in this domain 636 * 637 * @man: TTM memory type manager 638 * 639 * Returns how many bytes are used in this domain. 640 */ 641 uint64_t amdgpu_vram_mgr_usage(struct ttm_resource_manager *man) 642 { 643 struct amdgpu_vram_mgr *mgr = to_vram_mgr(man); 644 645 return atomic64_read(&mgr->usage); 646 } 647 648 /** 649 * amdgpu_vram_mgr_vis_usage - how many bytes are used in the visible part 650 * 651 * @man: TTM memory type manager 652 * 653 * Returns how many bytes are used in the visible part of VRAM 654 */ 655 uint64_t amdgpu_vram_mgr_vis_usage(struct ttm_resource_manager *man) 656 { 657 struct amdgpu_vram_mgr *mgr = to_vram_mgr(man); 658 659 return atomic64_read(&mgr->vis_usage); 660 } 661 662 /** 663 * amdgpu_vram_mgr_debug - dump VRAM table 664 * 665 * @man: TTM memory type manager 666 * @printer: DRM printer to use 667 * 668 * Dump the table content using printk. 669 */ 670 static void amdgpu_vram_mgr_debug(struct ttm_resource_manager *man, 671 struct drm_printer *printer) 672 { 673 struct amdgpu_vram_mgr *mgr = to_vram_mgr(man); 674 675 spin_lock(&mgr->lock); 676 drm_mm_print(&mgr->mm, printer); 677 spin_unlock(&mgr->lock); 678 679 drm_printf(printer, "man size:%llu pages, ram usage:%lluMB, vis usage:%lluMB\n", 680 man->size, amdgpu_vram_mgr_usage(man) >> 20, 681 amdgpu_vram_mgr_vis_usage(man) >> 20); 682 } 683 684 static const struct ttm_resource_manager_func amdgpu_vram_mgr_func = { 685 .alloc = amdgpu_vram_mgr_new, 686 .free = amdgpu_vram_mgr_del, 687 .debug = amdgpu_vram_mgr_debug 688 }; 689 690 /** 691 * amdgpu_vram_mgr_init - init VRAM manager and DRM MM 692 * 693 * @adev: amdgpu_device pointer 694 * 695 * Allocate and initialize the VRAM manager. 696 */ 697 int amdgpu_vram_mgr_init(struct amdgpu_device *adev) 698 { 699 struct amdgpu_vram_mgr *mgr = &adev->mman.vram_mgr; 700 struct ttm_resource_manager *man = &mgr->manager; 701 702 ttm_resource_manager_init(man, &adev->mman.bdev, 703 adev->gmc.real_vram_size >> PAGE_SHIFT); 704 705 man->func = &amdgpu_vram_mgr_func; 706 707 drm_mm_init(&mgr->mm, 0, man->size); 708 spin_lock_init(&mgr->lock); 709 INIT_LIST_HEAD(&mgr->reservations_pending); 710 INIT_LIST_HEAD(&mgr->reserved_pages); 711 712 ttm_set_driver_manager(&adev->mman.bdev, TTM_PL_VRAM, &mgr->manager); 713 ttm_resource_manager_set_used(man, true); 714 return 0; 715 } 716 717 /** 718 * amdgpu_vram_mgr_fini - free and destroy VRAM manager 719 * 720 * @adev: amdgpu_device pointer 721 * 722 * Destroy and free the VRAM manager, returns -EBUSY if ranges are still 723 * allocated inside it. 724 */ 725 void amdgpu_vram_mgr_fini(struct amdgpu_device *adev) 726 { 727 struct amdgpu_vram_mgr *mgr = &adev->mman.vram_mgr; 728 struct ttm_resource_manager *man = &mgr->manager; 729 int ret; 730 struct amdgpu_vram_reservation *rsv, *temp; 731 732 ttm_resource_manager_set_used(man, false); 733 734 ret = ttm_resource_manager_evict_all(&adev->mman.bdev, man); 735 if (ret) 736 return; 737 738 spin_lock(&mgr->lock); 739 list_for_each_entry_safe(rsv, temp, &mgr->reservations_pending, node) 740 kfree(rsv); 741 742 list_for_each_entry_safe(rsv, temp, &mgr->reserved_pages, node) { 743 drm_mm_remove_node(&rsv->mm_node); 744 kfree(rsv); 745 } 746 drm_mm_takedown(&mgr->mm); 747 spin_unlock(&mgr->lock); 748 749 ttm_resource_manager_cleanup(man); 750 ttm_set_driver_manager(&adev->mman.bdev, TTM_PL_VRAM, NULL); 751 } 752