tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

drm/amdgpu: add AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS flag v3

Add a flag noting that a BO must be created using linear VRAM
and set this flag on all in kernel users where appropriate.

Hopefully I haven't missed anything.

v2: add it in a few more places, fix CPU mapping.
v3: rename to VRAM_CONTIGUOUS, fix typo in CS code.

Signed-off-by: Christian König <christian.koenig@amd.com>
Reviewed-by: Edward O'Callaghan <funfunctor@folklore1984.net>
Tested-by: Mike Lothian <mike@fireburn.co.uk>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>

authored by

Christian König and committed by
Alex Deucher 03f48dd5 cfa32556

+53 -18
+4 -2
drivers/gpu/drm/amd/amdgpu/amdgpu_cgs.c
··· 146 146 switch(type) { 147 147 case CGS_GPU_MEM_TYPE__VISIBLE_CONTIG_FB: 148 148 case CGS_GPU_MEM_TYPE__VISIBLE_FB: 149 - flags = AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED; 149 + flags = AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED | 150 + AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS; 150 151 domain = AMDGPU_GEM_DOMAIN_VRAM; 151 152 if (max_offset > adev->mc.real_vram_size) 152 153 return -EINVAL; ··· 158 157 break; 159 158 case CGS_GPU_MEM_TYPE__INVISIBLE_CONTIG_FB: 160 159 case CGS_GPU_MEM_TYPE__INVISIBLE_FB: 161 - flags = AMDGPU_GEM_CREATE_NO_CPU_ACCESS; 160 + flags = AMDGPU_GEM_CREATE_NO_CPU_ACCESS | 161 + AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS; 162 162 domain = AMDGPU_GEM_DOMAIN_VRAM; 163 163 if (adev->mc.visible_vram_size < adev->mc.real_vram_size) { 164 164 place.fpfn =
+9
drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c
··· 1195 1195 r = amdgpu_ttm_bind(&bo->tbo, &bo->tbo.mem); 1196 1196 if (unlikely(r)) 1197 1197 return r; 1198 + 1199 + if (bo->flags & AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS) 1200 + continue; 1201 + 1202 + bo->flags |= AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS; 1203 + amdgpu_ttm_placement_from_domain(bo, bo->allowed_domains); 1204 + r = ttm_bo_validate(&bo->tbo, &bo->placement, false, false); 1205 + if (unlikely(r)) 1206 + return r; 1198 1207 } 1199 1208 1200 1209 return 0;
+2 -1
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
··· 264 264 if (adev->vram_scratch.robj == NULL) { 265 265 r = amdgpu_bo_create(adev, AMDGPU_GPU_PAGE_SIZE, 266 266 PAGE_SIZE, true, AMDGPU_GEM_DOMAIN_VRAM, 267 - AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED, 267 + AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED | 268 + AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS, 268 269 NULL, NULL, &adev->vram_scratch.robj); 269 270 if (r) { 270 271 return r;
+2 -1
drivers/gpu/drm/amd/amdgpu/amdgpu_fb.c
··· 152 152 aligned_size = ALIGN(size, PAGE_SIZE); 153 153 ret = amdgpu_gem_object_create(adev, aligned_size, 0, 154 154 AMDGPU_GEM_DOMAIN_VRAM, 155 - AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED, 155 + AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED | 156 + AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS, 156 157 true, &gobj); 157 158 if (ret) { 158 159 printk(KERN_ERR "failed to allocate framebuffer (%d)\n",
+2 -1
drivers/gpu/drm/amd/amdgpu/amdgpu_gart.c
··· 126 126 if (adev->gart.robj == NULL) { 127 127 r = amdgpu_bo_create(adev, adev->gart.table_size, 128 128 PAGE_SIZE, true, AMDGPU_GEM_DOMAIN_VRAM, 129 - AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED, 129 + AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED | 130 + AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS, 130 131 NULL, NULL, &adev->gart.robj); 131 132 if (r) { 132 133 return r;
+10 -2
drivers/gpu/drm/amd/amdgpu/amdgpu_object.c
··· 245 245 int r; 246 246 247 247 r = amdgpu_bo_create(adev, size, align, true, domain, 248 - AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED, 248 + AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED | 249 + AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS, 249 250 NULL, NULL, bo_ptr); 250 251 if (r) { 251 252 dev_err(adev->dev, "(%d) failed to allocate kernel bo\n", r); ··· 644 643 645 644 return 0; 646 645 } 646 + 647 + bo->flags |= AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS; 647 648 amdgpu_ttm_placement_from_domain(bo, domain); 648 649 for (i = 0; i < bo->placement.num_placement; i++) { 649 650 /* force to pin into visible video ram */ ··· 888 885 889 886 size = bo->mem.num_pages << PAGE_SHIFT; 890 887 offset = bo->mem.start << PAGE_SHIFT; 891 - if ((offset + size) <= adev->mc.visible_vram_size) 888 + /* TODO: figure out how to map scattered VRAM to the CPU */ 889 + if ((offset + size) <= adev->mc.visible_vram_size && 890 + (abo->flags & AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS)) 892 891 return 0; 893 892 894 893 /* Can't move a pinned BO to visible VRAM */ ··· 898 893 return -EINVAL; 899 894 900 895 /* hurrah the memory is not visible ! */ 896 + abo->flags |= AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS; 901 897 amdgpu_ttm_placement_from_domain(abo, AMDGPU_GEM_DOMAIN_VRAM); 902 898 lpfn = adev->mc.visible_vram_size >> PAGE_SHIFT; 903 899 for (i = 0; i < abo->placement.num_placement; i++) { ··· 960 954 WARN_ON_ONCE(!ww_mutex_is_locked(&bo->tbo.resv->lock) && 961 955 !bo->pin_count); 962 956 WARN_ON_ONCE(bo->tbo.mem.start == AMDGPU_BO_INVALID_OFFSET); 957 + WARN_ON_ONCE(bo->tbo.mem.mem_type == TTM_PL_VRAM && 958 + !(bo->flags & AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS)); 963 959 964 960 return bo->tbo.offset; 965 961 }
+2 -1
drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c
··· 1119 1119 1120 1120 r = amdgpu_bo_create(adev, 256 * 1024, PAGE_SIZE, true, 1121 1121 AMDGPU_GEM_DOMAIN_VRAM, 1122 - AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED, 1122 + AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED | 1123 + AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS, 1123 1124 NULL, NULL, &adev->stollen_vga_memory); 1124 1125 if (r) { 1125 1126 return r;
+4 -2
drivers/gpu/drm/amd/amdgpu/amdgpu_uvd.c
··· 1002 1002 1003 1003 r = amdgpu_bo_create(adev, 1024, PAGE_SIZE, true, 1004 1004 AMDGPU_GEM_DOMAIN_VRAM, 1005 - AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED, 1005 + AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED | 1006 + AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS, 1006 1007 NULL, NULL, &bo); 1007 1008 if (r) 1008 1009 return r; ··· 1052 1051 1053 1052 r = amdgpu_bo_create(adev, 1024, PAGE_SIZE, true, 1054 1053 AMDGPU_GEM_DOMAIN_VRAM, 1055 - AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED, 1054 + AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED | 1055 + AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS, 1056 1056 NULL, NULL, &bo); 1057 1057 if (r) 1058 1058 return r;
+2 -1
drivers/gpu/drm/amd/amdgpu/amdgpu_vce.c
··· 157 157 158 158 r = amdgpu_bo_create(adev, size, PAGE_SIZE, true, 159 159 AMDGPU_GEM_DOMAIN_VRAM, 160 - AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED, 160 + AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED | 161 + AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS, 161 162 NULL, NULL, &adev->vce.vcpu_bo); 162 163 if (r) { 163 164 dev_err(adev->dev, "(%d) failed to allocate VCE bo\n", r);
+4 -2
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c
··· 1416 1416 AMDGPU_GPU_PAGE_SIZE, true, 1417 1417 AMDGPU_GEM_DOMAIN_VRAM, 1418 1418 AMDGPU_GEM_CREATE_NO_CPU_ACCESS | 1419 - AMDGPU_GEM_CREATE_SHADOW, 1419 + AMDGPU_GEM_CREATE_SHADOW | 1420 + AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS, 1420 1421 NULL, resv, &pt); 1421 1422 if (r) 1422 1423 goto error_free; ··· 1627 1626 r = amdgpu_bo_create(adev, pd_size, align, true, 1628 1627 AMDGPU_GEM_DOMAIN_VRAM, 1629 1628 AMDGPU_GEM_CREATE_NO_CPU_ACCESS | 1630 - AMDGPU_GEM_CREATE_SHADOW, 1629 + AMDGPU_GEM_CREATE_SHADOW | 1630 + AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS, 1631 1631 NULL, NULL, &vm->page_directory); 1632 1632 if (r) 1633 1633 goto error_free_sched_entity;
+6 -3
drivers/gpu/drm/amd/amdgpu/gfx_v7_0.c
··· 3391 3391 if (adev->gfx.rlc.save_restore_obj == NULL) { 3392 3392 r = amdgpu_bo_create(adev, dws * 4, PAGE_SIZE, true, 3393 3393 AMDGPU_GEM_DOMAIN_VRAM, 3394 - AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED, 3394 + AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED | 3395 + AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS, 3395 3396 NULL, NULL, 3396 3397 &adev->gfx.rlc.save_restore_obj); 3397 3398 if (r) { ··· 3436 3435 if (adev->gfx.rlc.clear_state_obj == NULL) { 3437 3436 r = amdgpu_bo_create(adev, dws * 4, PAGE_SIZE, true, 3438 3437 AMDGPU_GEM_DOMAIN_VRAM, 3439 - AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED, 3438 + AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED | 3439 + AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS, 3440 3440 NULL, NULL, 3441 3441 &adev->gfx.rlc.clear_state_obj); 3442 3442 if (r) { ··· 3477 3475 if (adev->gfx.rlc.cp_table_obj == NULL) { 3478 3476 r = amdgpu_bo_create(adev, adev->gfx.rlc.cp_table_size, PAGE_SIZE, true, 3479 3477 AMDGPU_GEM_DOMAIN_VRAM, 3480 - AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED, 3478 + AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED | 3479 + AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS, 3481 3480 NULL, NULL, 3482 3481 &adev->gfx.rlc.cp_table_obj); 3483 3482 if (r) {
+4 -2
drivers/gpu/drm/amd/amdgpu/gfx_v8_0.c
··· 1273 1273 if (adev->gfx.rlc.clear_state_obj == NULL) { 1274 1274 r = amdgpu_bo_create(adev, dws * 4, PAGE_SIZE, true, 1275 1275 AMDGPU_GEM_DOMAIN_VRAM, 1276 - AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED, 1276 + AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED | 1277 + AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS, 1277 1278 NULL, NULL, 1278 1279 &adev->gfx.rlc.clear_state_obj); 1279 1280 if (r) { ··· 1316 1315 if (adev->gfx.rlc.cp_table_obj == NULL) { 1317 1316 r = amdgpu_bo_create(adev, adev->gfx.rlc.cp_table_size, PAGE_SIZE, true, 1318 1317 AMDGPU_GEM_DOMAIN_VRAM, 1319 - AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED, 1318 + AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED | 1319 + AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS, 1320 1320 NULL, NULL, 1321 1321 &adev->gfx.rlc.cp_table_obj); 1322 1322 if (r) {
+2
include/uapi/drm/amdgpu_drm.h
··· 81 81 #define AMDGPU_GEM_CREATE_VRAM_CLEARED (1 << 3) 82 82 /* Flag that create shadow bo(GTT) while allocating vram bo */ 83 83 #define AMDGPU_GEM_CREATE_SHADOW (1 << 4) 84 + /* Flag that allocating the BO should use linear VRAM */ 85 + #define AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS (1 << 5) 84 86 85 87 struct drm_amdgpu_gem_create_in { 86 88 /** the requested memory size */