[prev in list] [next in list] [prev in thread] [next in thread]
List: dri-patches
Subject: drm: Branch 'main' - 4 commits
From: GitLab Mirror <gitlab-mirror () kemper ! freedesktop ! org>
Date: 2024-03-25 9:35:39
Message-ID: 20240325093539.B7C9A7618D () kemper ! freedesktop ! org
[Download RAW message or body]
amdgpu/amdgpu-symbols.txt | 5 ++
amdgpu/amdgpu.h | 51 ++++++++++++++++++++++++++
amdgpu/amdgpu_device.c | 87 ++++++++++++++++++++++++----------------------
amdgpu/amdgpu_internal.h | 21 ++++++-----
amdgpu/amdgpu_vamgr.c | 71 +++++++++++++++++++++++++++++++++----
5 files changed, 179 insertions(+), 56 deletions(-)
New commits:
commit 7275ef8eba7248fbad7fee079d25eff8716124ee
Author: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
Date: Fri Feb 17 14:41:48 2023 +0100
amdgpu: add amdgpu_device_initialize2
Allows to opt-out from the device deduplication logic. This is not the
recommended way of using dev handles, but it's necessary for native context:
in this situation one process (eg: Qemu) will init many devices and we
want independent devices to make sure guest applications are isolated from
each other.
Reviewed-by: Marek Olšák <marek.olsak@amd.com>
diff --git a/amdgpu/amdgpu-symbols.txt b/amdgpu/amdgpu-symbols.txt
index 9999cbed..594480e3 100644
--- a/amdgpu/amdgpu-symbols.txt
+++ b/amdgpu/amdgpu-symbols.txt
@@ -56,6 +56,7 @@ amdgpu_cs_wait_semaphore
amdgpu_device_deinitialize
amdgpu_device_get_fd
amdgpu_device_initialize
+amdgpu_device_initialize2
amdgpu_find_bo_by_cpu_mapping
amdgpu_get_marketing_name
amdgpu_query_buffer_size_alignment
diff --git a/amdgpu/amdgpu.h b/amdgpu/amdgpu.h
index e81accf0..c9c1f12e 100644
--- a/amdgpu/amdgpu.h
+++ b/amdgpu/amdgpu.h
@@ -533,6 +533,20 @@ int amdgpu_device_initialize(int fd,
uint32_t *minor_version,
amdgpu_device_handle *device_handle);
+/**
+ * Same as amdgpu_device_initialize() except when deduplicate_device
+ * is false *and* fd points to a device that was already initialized.
+ * In this case, amdgpu_device_initialize would return the same
+ * amdgpu_device_handle while here amdgpu_device_initialize2 would
+ * return a new handle.
+ * amdgpu_device_initialize() should be preferred in most situations;
+ * the only use-case where not-deduplicating devices make sense is
+ * when one wants to have isolated device handles in the same process.
+ */
+int amdgpu_device_initialize2(int fd, bool deduplicate_device,
+ uint32_t *major_version,
+ uint32_t *minor_version,
+ amdgpu_device_handle *device_handle);
/**
*
* When access to such library does not needed any more the special
diff --git a/amdgpu/amdgpu_device.c b/amdgpu/amdgpu_device.c
index e51c07f5..97dbfb44 100644
--- a/amdgpu/amdgpu_device.c
+++ b/amdgpu/amdgpu_device.c
@@ -97,9 +97,9 @@ static void amdgpu_device_free_internal(amdgpu_device_handle dev)
{
amdgpu_device_handle *node = &dev_list;
- while (*node != dev && (*node)->next)
+ /* Remove dev from dev_list, if it was added there. */
+ while (*node != dev && *node && (*node)->next)
node = &(*node)->next;
- *node = (*node)->next;
close(dev->fd);
if ((dev->flink_fd >= 0) && (dev->fd != dev->flink_fd))
@@ -138,12 +138,13 @@ static void amdgpu_device_reference(struct amdgpu_device **dst,
*dst = src;
}
-drm_public int amdgpu_device_initialize(int fd,
- uint32_t *major_version,
- uint32_t *minor_version,
- amdgpu_device_handle *device_handle)
+static int _amdgpu_device_initialize(int fd,
+ uint32_t *major_version,
+ uint32_t *minor_version,
+ amdgpu_device_handle *device_handle,
+ bool deduplicate_device)
{
- struct amdgpu_device *dev;
+ struct amdgpu_device *dev = NULL;
drmVersionPtr version;
int r;
int flag_auth = 0;
@@ -153,6 +154,7 @@ drm_public int amdgpu_device_initialize(int fd,
*device_handle = NULL;
pthread_mutex_lock(&dev_mutex);
+
r = amdgpu_get_auth(fd, &flag_auth);
if (r) {
fprintf(stderr, "%s: amdgpu_get_auth (1) failed (%i)\n",
@@ -161,9 +163,10 @@ drm_public int amdgpu_device_initialize(int fd,
return r;
}
- for (dev = dev_list; dev; dev = dev->next)
- if (fd_compare(dev->fd, fd) == 0)
- break;
+ if (deduplicate_device)
+ for (dev = dev_list; dev; dev = dev->next)
+ if (fd_compare(dev->fd, fd) == 0)
+ break;
if (dev) {
r = amdgpu_get_auth(dev->fd, &flag_authexist);
@@ -247,8 +250,10 @@ drm_public int amdgpu_device_initialize(int fd,
*major_version = dev->major_version;
*minor_version = dev->minor_version;
*device_handle = dev;
- dev->next = dev_list;
- dev_list = dev;
+ if (deduplicate_device) {
+ dev->next = dev_list;
+ dev_list = dev;
+ }
pthread_mutex_unlock(&dev_mutex);
return 0;
@@ -261,6 +266,22 @@ cleanup:
return r;
}
+drm_public int amdgpu_device_initialize(int fd,
+ uint32_t *major_version,
+ uint32_t *minor_version,
+ amdgpu_device_handle *device_handle)
+{
+ return _amdgpu_device_initialize(fd, major_version, minor_version, device_handle, true);
+}
+
+drm_public int amdgpu_device_initialize2(int fd, bool deduplicate_device,
+ uint32_t *major_version,
+ uint32_t *minor_version,
+ amdgpu_device_handle *device_handle)
+{
+ return _amdgpu_device_initialize(fd, major_version, minor_version, device_handle, deduplicate_device);
+}
+
drm_public int amdgpu_device_deinitialize(amdgpu_device_handle dev)
{
pthread_mutex_lock(&dev_mutex);
commit 6978f999eaf8409d405f054f1cf9fff88f47b811
Author: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
Date: Mon Dec 18 15:27:00 2023 +0100
amdgpu: add amdgpu_va_range_alloc2
This is the same functionnality that amdgpu_va_range_alloc offers,
except it's now usable without a device handle.
Reviewed-by: Marek Olšák <marek.olsak@amd.com>
diff --git a/amdgpu/amdgpu-symbols.txt b/amdgpu/amdgpu-symbols.txt
index 527ba93c..9999cbed 100644
--- a/amdgpu/amdgpu-symbols.txt
+++ b/amdgpu/amdgpu-symbols.txt
@@ -75,6 +75,7 @@ amdgpu_va_manager_alloc
amdgpu_va_manager_init
amdgpu_va_manager_deinit
amdgpu_va_range_alloc
+amdgpu_va_range_alloc2
amdgpu_va_range_free
amdgpu_va_get_start_addr
amdgpu_va_range_query
diff --git a/amdgpu/amdgpu.h b/amdgpu/amdgpu.h
index 9f84b707..e81accf0 100644
--- a/amdgpu/amdgpu.h
+++ b/amdgpu/amdgpu.h
@@ -1432,6 +1432,20 @@ void amdgpu_va_manager_init(amdgpu_va_manager_handle va_mgr,
void amdgpu_va_manager_deinit(amdgpu_va_manager_handle va_mgr);
+/**
+ * Similar to #amdgpu_va_range_alloc() but allocates VA
+ * directly from an amdgpu_va_manager_handle instead of using
+ * the manager from an amdgpu_device.
+ */
+
+int amdgpu_va_range_alloc2(amdgpu_va_manager_handle va_mgr,
+ enum amdgpu_gpu_va_range va_range_type,
+ uint64_t size,
+ uint64_t va_base_alignment,
+ uint64_t va_base_required,
+ uint64_t *va_base_allocated,
+ amdgpu_va_handle *va_range_handle,
+ uint64_t flags);
/**
* VA mapping/unmapping for the buffer object
diff --git a/amdgpu/amdgpu_vamgr.c b/amdgpu/amdgpu_vamgr.c
index 5d511ced..29944ec8 100644
--- a/amdgpu/amdgpu_vamgr.c
+++ b/amdgpu/amdgpu_vamgr.c
@@ -228,25 +228,40 @@ drm_public int amdgpu_va_range_alloc(amdgpu_device_handle dev,
uint64_t *va_base_allocated,
amdgpu_va_handle *va_range_handle,
uint64_t flags)
+{
+ return amdgpu_va_range_alloc2(&dev->va_mgr, va_range_type, size,
+ va_base_alignment, va_base_required,
+ va_base_allocated, va_range_handle,
+ flags);
+}
+
+drm_public int amdgpu_va_range_alloc2(amdgpu_va_manager_handle va_mgr,
+ enum amdgpu_gpu_va_range va_range_type,
+ uint64_t size,
+ uint64_t va_base_alignment,
+ uint64_t va_base_required,
+ uint64_t *va_base_allocated,
+ amdgpu_va_handle *va_range_handle,
+ uint64_t flags)
{
struct amdgpu_bo_va_mgr *vamgr;
bool search_from_top = !!(flags & AMDGPU_VA_RANGE_REPLAYABLE);
int ret;
/* Clear the flag when the high VA manager is not initialized */
- if (flags & AMDGPU_VA_RANGE_HIGH && !dev->va_mgr.vamgr_high_32.va_max)
+ if (flags & AMDGPU_VA_RANGE_HIGH && !va_mgr->vamgr_high_32.va_max)
flags &= ~AMDGPU_VA_RANGE_HIGH;
if (flags & AMDGPU_VA_RANGE_HIGH) {
if (flags & AMDGPU_VA_RANGE_32_BIT)
- vamgr = &dev->va_mgr.vamgr_high_32;
+ vamgr = &va_mgr->vamgr_high_32;
else
- vamgr = &dev->va_mgr.vamgr_high;
+ vamgr = &va_mgr->vamgr_high;
} else {
if (flags & AMDGPU_VA_RANGE_32_BIT)
- vamgr = &dev->va_mgr.vamgr_32;
+ vamgr = &va_mgr->vamgr_32;
else
- vamgr = &dev->va_mgr.vamgr_low;
+ vamgr = &va_mgr->vamgr_low;
}
va_base_alignment = MAX2(va_base_alignment, vamgr->va_alignment);
@@ -259,9 +274,9 @@ drm_public int amdgpu_va_range_alloc(amdgpu_device_handle dev,
if (!(flags & AMDGPU_VA_RANGE_32_BIT) && ret) {
/* fallback to 32bit address */
if (flags & AMDGPU_VA_RANGE_HIGH)
- vamgr = &dev->va_mgr.vamgr_high_32;
+ vamgr = &va_mgr->vamgr_high_32;
else
- vamgr = &dev->va_mgr.vamgr_32;
+ vamgr = &va_mgr->vamgr_32;
ret = amdgpu_vamgr_find_va(vamgr, size,
va_base_alignment, va_base_required,
search_from_top, va_base_allocated);
commit 96fe43a0292b5ccacf13697009547c0141e871e6
Author: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
Date: Mon Dec 18 15:02:30 2023 +0100
amdgpu: expose amdgpu_va_manager publicly
This will allow applications to use this feature without a device.
The first use case will be native context: we want VA address to
be managed by the guest (to avoid a round-trip to the host to only
generate a VA) but the amdgpu_device only exist on the host.
Reviewed-by: Marek Olšák <marek.olsak@amd.com>
diff --git a/amdgpu/amdgpu-symbols.txt b/amdgpu/amdgpu-symbols.txt
index 530b343b..527ba93c 100644
--- a/amdgpu/amdgpu-symbols.txt
+++ b/amdgpu/amdgpu-symbols.txt
@@ -71,6 +71,9 @@ amdgpu_query_info
amdgpu_query_sensor_info
amdgpu_query_video_caps_info
amdgpu_read_mm_registers
+amdgpu_va_manager_alloc
+amdgpu_va_manager_init
+amdgpu_va_manager_deinit
amdgpu_va_range_alloc
amdgpu_va_range_free
amdgpu_va_get_start_addr
diff --git a/amdgpu/amdgpu.h b/amdgpu/amdgpu.h
index 9bdbf366..9f84b707 100644
--- a/amdgpu/amdgpu.h
+++ b/amdgpu/amdgpu.h
@@ -138,6 +138,12 @@ typedef struct amdgpu_bo_list *amdgpu_bo_list_handle;
*/
typedef struct amdgpu_va *amdgpu_va_handle;
+/**
+ * Define handle dealing with VA allocation. An amdgpu_device
+ * owns one of these, but they can also be used without a device.
+ */
+typedef struct amdgpu_va_manager *amdgpu_va_manager_handle;
+
/**
* Define handle for semaphore
*/
@@ -1410,6 +1416,23 @@ int amdgpu_va_range_query(amdgpu_device_handle dev,
uint64_t *start,
uint64_t *end);
+/**
+ * Allocate a amdgpu_va_manager object.
+ * The returned object has be initialized with the amdgpu_va_manager_init
+ * before use.
+ * On release, amdgpu_va_manager_deinit needs to be called, then the memory
+ * can be released using free().
+ */
+amdgpu_va_manager_handle amdgpu_va_manager_alloc(void);
+
+void amdgpu_va_manager_init(amdgpu_va_manager_handle va_mgr,
+ uint64_t low_va_offset, uint64_t low_va_max,
+ uint64_t high_va_offset, uint64_t high_va_max,
+ uint32_t virtual_address_alignment);
+
+void amdgpu_va_manager_deinit(amdgpu_va_manager_handle va_mgr);
+
+
/**
* VA mapping/unmapping for the buffer object
*
diff --git a/amdgpu/amdgpu_device.c b/amdgpu/amdgpu_device.c
index 79abd97c..e51c07f5 100644
--- a/amdgpu/amdgpu_device.c
+++ b/amdgpu/amdgpu_device.c
@@ -149,7 +149,6 @@ drm_public int amdgpu_device_initialize(int fd,
int flag_auth = 0;
int flag_authexist=0;
uint32_t accel_working = 0;
- uint64_t start, max;
*device_handle = NULL;
@@ -236,27 +235,12 @@ drm_public int amdgpu_device_initialize(int fd,
goto cleanup;
}
- start = dev->dev_info.virtual_address_offset;
- max = MIN2(dev->dev_info.virtual_address_max, 0x100000000ULL);
- amdgpu_vamgr_init(&dev->va_mgr.vamgr_32, start, max,
- dev->dev_info.virtual_address_alignment);
-
- start = max;
- max = MAX2(dev->dev_info.virtual_address_max, 0x100000000ULL);
- amdgpu_vamgr_init(&dev->va_mgr.vamgr_low, start, max,
- dev->dev_info.virtual_address_alignment);
-
- start = dev->dev_info.high_va_offset;
- max = MIN2(dev->dev_info.high_va_max, (start & ~0xffffffffULL) +
- 0x100000000ULL);
- amdgpu_vamgr_init(&dev->va_mgr.vamgr_high_32, start, max,
- dev->dev_info.virtual_address_alignment);
-
- start = max;
- max = MAX2(dev->dev_info.high_va_max, (start & ~0xffffffffULL) +
- 0x100000000ULL);
- amdgpu_vamgr_init(&dev->va_mgr.vamgr_high, start, max,
- dev->dev_info.virtual_address_alignment);
+ amdgpu_va_manager_init(&dev->va_mgr,
+ dev->dev_info.virtual_address_offset,
+ dev->dev_info.virtual_address_max,
+ dev->dev_info.high_va_offset,
+ dev->dev_info.high_va_max,
+ dev->dev_info.virtual_address_alignment);
amdgpu_parse_asic_ids(dev);
diff --git a/amdgpu/amdgpu_vamgr.c b/amdgpu/amdgpu_vamgr.c
index aa657db7..5d511ced 100644
--- a/amdgpu/amdgpu_vamgr.c
+++ b/amdgpu/amdgpu_vamgr.c
@@ -300,3 +300,45 @@ drm_public uint64_t amdgpu_va_get_start_addr(amdgpu_va_handle va_handle)
{
return va_handle->address;
}
+
+drm_public amdgpu_va_manager_handle amdgpu_va_manager_alloc(void)
+{
+ amdgpu_va_manager_handle r = calloc(1, sizeof(struct amdgpu_va_manager));
+ return r;
+}
+
+drm_public void amdgpu_va_manager_init(struct amdgpu_va_manager *va_mgr,
+ uint64_t low_va_offset, uint64_t low_va_max,
+ uint64_t high_va_offset, uint64_t high_va_max,
+ uint32_t virtual_address_alignment)
+{
+ uint64_t start, max;
+
+ start = low_va_offset;
+ max = MIN2(low_va_max, 0x100000000ULL);
+ amdgpu_vamgr_init(&va_mgr->vamgr_32, start, max,
+ virtual_address_alignment);
+
+ start = max;
+ max = MAX2(low_va_max, 0x100000000ULL);
+ amdgpu_vamgr_init(&va_mgr->vamgr_low, start, max,
+ virtual_address_alignment);
+
+ start = high_va_offset;
+ max = MIN2(high_va_max, (start & ~0xffffffffULL) + 0x100000000ULL);
+ amdgpu_vamgr_init(&va_mgr->vamgr_high_32, start, max,
+ virtual_address_alignment);
+
+ start = max;
+ max = MAX2(high_va_max, (start & ~0xffffffffULL) + 0x100000000ULL);
+ amdgpu_vamgr_init(&va_mgr->vamgr_high, start, max,
+ virtual_address_alignment);
+}
+
+drm_public void amdgpu_va_manager_deinit(struct amdgpu_va_manager *va_mgr)
+{
+ amdgpu_vamgr_deinit(&va_mgr->vamgr_32);
+ amdgpu_vamgr_deinit(&va_mgr->vamgr_low);
+ amdgpu_vamgr_deinit(&va_mgr->vamgr_high_32);
+ amdgpu_vamgr_deinit(&va_mgr->vamgr_high);
+}
commit 43768487204f5d53d5ffcd76a717e2293e1684cb
Author: Pierre-Eric Pelloux-Prayer <pierre-eric.pelloux-prayer@amd.com>
Date: Mon Dec 18 14:53:10 2023 +0100
amdgpu: add amdgpu_va_manager
Until now VA management was tied to a device handle, but there's no
reason for this.
As a first step to export VA management outside of amdgpu_device,
this commit adds a new structure type holding the 4 va_mgr.
Reviewed-by: Marek Olšák <marek.olsak@amd.com>
diff --git a/amdgpu/amdgpu_device.c b/amdgpu/amdgpu_device.c
index 7d9c5dd9..79abd97c 100644
--- a/amdgpu/amdgpu_device.c
+++ b/amdgpu/amdgpu_device.c
@@ -105,10 +105,10 @@ static void amdgpu_device_free_internal(amdgpu_device_handle dev)
if ((dev->flink_fd >= 0) && (dev->fd != dev->flink_fd))
close(dev->flink_fd);
- amdgpu_vamgr_deinit(&dev->vamgr_32);
- amdgpu_vamgr_deinit(&dev->vamgr);
- amdgpu_vamgr_deinit(&dev->vamgr_high_32);
- amdgpu_vamgr_deinit(&dev->vamgr_high);
+ amdgpu_vamgr_deinit(&dev->va_mgr.vamgr_32);
+ amdgpu_vamgr_deinit(&dev->va_mgr.vamgr_low);
+ amdgpu_vamgr_deinit(&dev->va_mgr.vamgr_high_32);
+ amdgpu_vamgr_deinit(&dev->va_mgr.vamgr_high);
handle_table_fini(&dev->bo_handles);
handle_table_fini(&dev->bo_flink_names);
pthread_mutex_destroy(&dev->bo_table_mutex);
@@ -238,24 +238,24 @@ drm_public int amdgpu_device_initialize(int fd,
start = dev->dev_info.virtual_address_offset;
max = MIN2(dev->dev_info.virtual_address_max, 0x100000000ULL);
- amdgpu_vamgr_init(&dev->vamgr_32, start, max,
+ amdgpu_vamgr_init(&dev->va_mgr.vamgr_32, start, max,
dev->dev_info.virtual_address_alignment);
start = max;
max = MAX2(dev->dev_info.virtual_address_max, 0x100000000ULL);
- amdgpu_vamgr_init(&dev->vamgr, start, max,
+ amdgpu_vamgr_init(&dev->va_mgr.vamgr_low, start, max,
dev->dev_info.virtual_address_alignment);
start = dev->dev_info.high_va_offset;
max = MIN2(dev->dev_info.high_va_max, (start & ~0xffffffffULL) +
0x100000000ULL);
- amdgpu_vamgr_init(&dev->vamgr_high_32, start, max,
+ amdgpu_vamgr_init(&dev->va_mgr.vamgr_high_32, start, max,
dev->dev_info.virtual_address_alignment);
start = max;
max = MAX2(dev->dev_info.high_va_max, (start & ~0xffffffffULL) +
0x100000000ULL);
- amdgpu_vamgr_init(&dev->vamgr_high, start, max,
+ amdgpu_vamgr_init(&dev->va_mgr.vamgr_high, start, max,
dev->dev_info.virtual_address_alignment);
amdgpu_parse_asic_ids(dev);
@@ -306,10 +306,10 @@ drm_public int amdgpu_query_sw_info(amdgpu_device_handle dev,
switch (info) {
case amdgpu_sw_info_address32_hi:
- if (dev->vamgr_high_32.va_max)
- *val32 = (dev->vamgr_high_32.va_max - 1) >> 32;
+ if (dev->va_mgr.vamgr_high_32.va_max)
+ *val32 = (dev->va_mgr.vamgr_high_32.va_max - 1) >> 32;
else
- *val32 = (dev->vamgr_32.va_max - 1) >> 32;
+ *val32 = (dev->va_mgr.vamgr_32.va_max - 1) >> 32;
return 0;
}
return -EINVAL;
diff --git a/amdgpu/amdgpu_internal.h b/amdgpu/amdgpu_internal.h
index 2834c9c6..af85b849 100644
--- a/amdgpu/amdgpu_internal.h
+++ b/amdgpu/amdgpu_internal.h
@@ -63,6 +63,17 @@ struct amdgpu_va {
struct amdgpu_bo_va_mgr *vamgr;
};
+struct amdgpu_va_manager {
+ /** The VA manager for the lower virtual address space */
+ struct amdgpu_bo_va_mgr vamgr_low;
+ /** The VA manager for the 32bit address space */
+ struct amdgpu_bo_va_mgr vamgr_32;
+ /** The VA manager for the high virtual address space */
+ struct amdgpu_bo_va_mgr vamgr_high;
+ /** The VA manager for the 32bit high address space */
+ struct amdgpu_bo_va_mgr vamgr_high_32;
+};
+
struct amdgpu_device {
atomic_t refcount;
struct amdgpu_device *next;
@@ -80,14 +91,8 @@ struct amdgpu_device {
pthread_mutex_t bo_table_mutex;
struct drm_amdgpu_info_device dev_info;
struct amdgpu_gpu_info info;
- /** The VA manager for the lower virtual address space */
- struct amdgpu_bo_va_mgr vamgr;
- /** The VA manager for the 32bit address space */
- struct amdgpu_bo_va_mgr vamgr_32;
- /** The VA manager for the high virtual address space */
- struct amdgpu_bo_va_mgr vamgr_high;
- /** The VA manager for the 32bit high address space */
- struct amdgpu_bo_va_mgr vamgr_high_32;
+
+ struct amdgpu_va_manager va_mgr;
};
struct amdgpu_bo {
diff --git a/amdgpu/amdgpu_vamgr.c b/amdgpu/amdgpu_vamgr.c
index 2c4c9dba..aa657db7 100644
--- a/amdgpu/amdgpu_vamgr.c
+++ b/amdgpu/amdgpu_vamgr.c
@@ -234,19 +234,19 @@ drm_public int amdgpu_va_range_alloc(amdgpu_device_handle dev,
int ret;
/* Clear the flag when the high VA manager is not initialized */
- if (flags & AMDGPU_VA_RANGE_HIGH && !dev->vamgr_high_32.va_max)
+ if (flags & AMDGPU_VA_RANGE_HIGH && !dev->va_mgr.vamgr_high_32.va_max)
flags &= ~AMDGPU_VA_RANGE_HIGH;
if (flags & AMDGPU_VA_RANGE_HIGH) {
if (flags & AMDGPU_VA_RANGE_32_BIT)
- vamgr = &dev->vamgr_high_32;
+ vamgr = &dev->va_mgr.vamgr_high_32;
else
- vamgr = &dev->vamgr_high;
+ vamgr = &dev->va_mgr.vamgr_high;
} else {
if (flags & AMDGPU_VA_RANGE_32_BIT)
- vamgr = &dev->vamgr_32;
+ vamgr = &dev->va_mgr.vamgr_32;
else
- vamgr = &dev->vamgr;
+ vamgr = &dev->va_mgr.vamgr_low;
}
va_base_alignment = MAX2(va_base_alignment, vamgr->va_alignment);
@@ -259,9 +259,9 @@ drm_public int amdgpu_va_range_alloc(amdgpu_device_handle dev,
if (!(flags & AMDGPU_VA_RANGE_32_BIT) && ret) {
/* fallback to 32bit address */
if (flags & AMDGPU_VA_RANGE_HIGH)
- vamgr = &dev->vamgr_high_32;
+ vamgr = &dev->va_mgr.vamgr_high_32;
else
- vamgr = &dev->vamgr_32;
+ vamgr = &dev->va_mgr.vamgr_32;
ret = amdgpu_vamgr_find_va(vamgr, size,
va_base_alignment, va_base_required,
search_from_top, va_base_allocated);
--
_______________________________________________
Dri-patches mailing list
Dri-patches@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/dri-patches
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic