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