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