fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-01-16 22:20:29 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

radv/winsys: Use radv_buffer_map wrapper.

Browse source 
So we can have 1 function ptr and then have a version with default
args.

Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/27689>
This commit is contained in:
Bas Nieuwenhuizen 2024-02-19 00:53:01 +01:00 • committed by Marge Bot
parent f7e8fdf35d
commit cccbe1527c
16 changed files with 28 additions and 22 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/amd/vulkan/radv_cmd_buffer.c
View file

@ -522,7 +522,7 @@ radv_cmd_buffer_resize_upload_buf(struct radv_cmd_buffer *cmd_buffer, uint64_t m
cmd_buffer->upload.upload_bo = bo;
cmd_buffer->upload.size = new_size;
cmd_buffer->upload.offset = 0;
cmd_buffer->upload.map = device->ws->buffer_map(device->ws, cmd_buffer->upload.upload_bo);
cmd_buffer->upload.map = radv_buffer_map(device->ws, cmd_buffer->upload.upload_bo);
if (!cmd_buffer->upload.map) {
vk_command_buffer_set_error(&cmd_buffer->vk, VK_ERROR_OUT_OF_DEVICE_MEMORY);

2
src/amd/vulkan/radv_cp_reg_shadowing.c
View file

@ -76,7 +76,7 @@ radv_create_shadow_regs_preamble(const struct radv_device *device, struct radv_q
/* copy the cs to queue_state->shadow_regs_ib. This will be the first preamble ib
* added in radv_update_preamble_cs.
*/
void *map = ws->buffer_map(ws, queue_state->shadow_regs_ib);
void *map = radv_buffer_map(ws, queue_state->shadow_regs_ib);
if (!map) {
result = VK_ERROR_MEMORY_MAP_FAILED;
goto fail_map;

4
src/amd/vulkan/radv_debug.c
View file

@ -80,7 +80,7 @@ radv_init_trace(struct radv_device *device)
if (result != VK_SUCCESS)
return false;
device->trace_id_ptr = ws->buffer_map(ws, device->trace_bo);
device->trace_id_ptr = radv_buffer_map(ws, device->trace_bo);
if (!device->trace_id_ptr)
return false;
@ -920,7 +920,7 @@ radv_trap_handler_init(struct radv_device *device)
if (result != VK_SUCCESS)
return false;
device->tma_ptr = ws->buffer_map(ws, device->tma_bo);
device->tma_ptr = radv_buffer_map(ws, device->tma_bo);
if (!device->tma_ptr)
return false;

2
src/amd/vulkan/radv_descriptor_set.c
View file

@ -922,7 +922,7 @@ radv_create_descriptor_pool(struct radv_device *device, const VkDescriptorPoolCr
radv_destroy_descriptor_pool(device, pAllocator, pool);
return vk_error(device, result);
}
pool->mapped_ptr = (uint8_t *)device->ws->buffer_map(device->ws, pool->bo);
pool->mapped_ptr = (uint8_t *)radv_buffer_map(device->ws, pool->bo);
if (!pool->mapped_ptr) {
radv_destroy_descriptor_pool(device, pAllocator, pool);
return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);

2
src/amd/vulkan/radv_device.c
View file

@ -141,7 +141,7 @@ radv_device_init_border_color(struct radv_device *device)
if (result != VK_SUCCESS)
return vk_error(device, result);
device->border_color_data.colors_gpu_ptr = device->ws->buffer_map(device->ws, device->border_color_data.bo);
device->border_color_data.colors_gpu_ptr = radv_buffer_map(device->ws, device->border_color_data.bo);
if (!device->border_color_data.colors_gpu_ptr)
return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
mtx_init(&device->border_color_data.mutex, mtx_plain);

2
src/amd/vulkan/radv_device_memory.c
View file

@ -300,7 +300,7 @@ radv_MapMemory2KHR(VkDevice _device, const VkMemoryMapInfoKHR *pMemoryMapInfo, v
if (mem->user_ptr)
*ppData = mem->user_ptr;
else
*ppData = device->ws->buffer_map(device->ws, mem->bo);
*ppData = radv_buffer_map(device->ws, mem->bo);
if (*ppData) {
vk_rmv_log_cpu_map(&device->vk, mem->bo->va, false);

2
src/amd/vulkan/radv_event.c
View file

@ -69,7 +69,7 @@ radv_create_event(struct radv_device *device, const VkEventCreateInfo *pCreateIn
}
if (!(pCreateInfo->flags & VK_EVENT_CREATE_DEVICE_ONLY_BIT)) {
event->map = (uint64_t *)device->ws->buffer_map(device->ws, event->bo);
event->map = (uint64_t *)radv_buffer_map(device->ws, event->bo);
if (!event->map) {
radv_destroy_event(device, pAllocator, event);
return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);

2
src/amd/vulkan/radv_query.c
View file

@ -1309,7 +1309,7 @@ radv_create_query_pool(struct radv_device *device, const VkQueryPoolCreateInfo *
return vk_error(device, result);
}
pool->ptr = device->ws->buffer_map(device->ws, pool->bo);
pool->ptr = radv_buffer_map(device->ws, pool->bo);
if (!pool->ptr) {
radv_destroy_query_pool(device, pAllocator, pool);
return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);

4
src/amd/vulkan/radv_queue.c
View file

@ -577,7 +577,7 @@ radv_emit_tess_factor_ring(struct radv_device *device, struct radeon_cmdbuf *cs,
static VkResult
radv_initialise_task_control_buffer(struct radv_device *device, struct radeon_winsys_bo *task_rings_bo)
{
uint32_t *ptr = (uint32_t *)device->ws->buffer_map(device->ws, task_rings_bo);
uint32_t *ptr = (uint32_t *)radv_buffer_map(device->ws, task_rings_bo);
if (!ptr)
return VK_ERROR_OUT_OF_DEVICE_MEMORY;
@ -982,7 +982,7 @@ radv_update_preamble_cs(struct radv_queue_state *queue, struct radv_device *devi
}
if (descriptor_bo != queue->descriptor_bo) {
uint32_t *map = (uint32_t *)ws->buffer_map(ws, descriptor_bo);
uint32_t *map = (uint32_t *)radv_buffer_map(ws, descriptor_bo);
if (!map) {
result = VK_ERROR_OUT_OF_DEVICE_MEMORY;
goto fail;

6
src/amd/vulkan/radv_radeon_winsys.h
View file

@ -360,4 +360,10 @@ radv_cs_add_buffer(struct radeon_winsys *ws, struct radeon_cmdbuf *cs, struct ra
ws->cs_add_buffer(cs, bo);
}
static inline void *
radv_buffer_map(struct radeon_winsys *ws, struct radeon_winsys_bo *bo)
{
return ws->buffer_map(ws, bo);
}
#endif /* RADV_RADEON_WINSYS_H */

4
src/amd/vulkan/radv_shader.c
View file

@ -981,7 +981,7 @@ radv_create_shader_arena(struct radv_device *device, struct radv_shader_free_lis
add_hole(free_list, alloc);
if (!(flags & RADEON_FLAG_NO_CPU_ACCESS)) {
arena->ptr = (char *)device->ws->buffer_map(device->ws, arena->bo);
arena->ptr = (char *)radv_buffer_map(device->ws, arena->bo);
if (!arena->ptr)
goto fail;
}
@ -1916,7 +1916,7 @@ radv_shader_dma_resize_upload_buf(struct radv_shader_dma_submission *submission,
if (result != VK_SUCCESS)
return result;
submission->ptr = ws->buffer_map(ws, submission->bo);
submission->ptr = radv_buffer_map(ws, submission->bo);
submission->bo_size = size;
return VK_SUCCESS;

2
src/amd/vulkan/radv_spm.c
View file

@ -52,7 +52,7 @@ radv_spm_init_bo(struct radv_device *device)
if (result != VK_SUCCESS)
return false;
device->spm.ptr = ws->buffer_map(ws, device->spm.bo);
device->spm.ptr = radv_buffer_map(ws, device->spm.bo);
if (!device->spm.ptr)
return false;

4
src/amd/vulkan/radv_sqtt.c
View file

@ -512,7 +512,7 @@ radv_sqtt_acquire_gpu_timestamp(struct radv_device *device, struct radeon_winsys
return result;
}
map = device->ws->buffer_map(device->ws, bo);
map = radv_buffer_map(device->ws, bo);
if (!map) {
ws->buffer_destroy(ws, bo);
simple_mtx_unlock(&device->sqtt_timestamp_mtx);
@ -652,7 +652,7 @@ radv_sqtt_init_bo(struct radv_device *device)
if (result != VK_SUCCESS)
return false;
device->sqtt.ptr = ws->buffer_map(ws, device->sqtt.bo);
device->sqtt.ptr = radv_buffer_map(ws, device->sqtt.bo);
if (!device->sqtt.ptr)
return false;

2
src/amd/vulkan/radv_video.c
View file

@ -2727,7 +2727,7 @@ radv_vcn_cmd_reset(struct radv_cmd_buffer *cmd_buffer)
? align(sizeof(rvcn_av1_frame_context_t), 2048)
: align(sizeof(rvcn_av1_vcn4_frame_context_t), 2048);
uint8_t *ctxptr = cmd_buffer->device->ws->buffer_map(cmd_buffer->device->ws, vid->ctx.mem->bo);
uint8_t *ctxptr = radv_buffer_map(cmd_buffer->device->ws, vid->ctx.mem->bo);
ctxptr += vid->ctx.offset;
if (pdev->av1_version == RDECODE_AV1_VER_0) {
for (unsigned i = 0; i < 4; ++i) {

2
src/amd/vulkan/si_cmd_buffer.c
View file

@ -645,7 +645,7 @@ radv_create_gfx_config(struct radv_device *device)
if (result != VK_SUCCESS)
goto fail;
void *map = device->ws->buffer_map(device->ws, device->gfx_init);
void *map = radv_buffer_map(device->ws, device->gfx_init);
if (!map) {
device->ws->buffer_destroy(device->ws, device->gfx_init);
device->gfx_init = NULL;

8
src/amd/vulkan/winsys/amdgpu/radv_amdgpu_cs.c
View file

@ -272,7 +272,7 @@ radv_amdgpu_cs_get_new_ib(struct radeon_cmdbuf *_cs, uint32_t ib_size)
if (result != VK_SUCCESS)
return result;
cs->ib_mapped = cs->ws->base.buffer_map(&cs->ws->base, cs->ib_buffer);
cs->ib_mapped = radv_buffer_map(&cs->ws->base, cs->ib_buffer);
if (!cs->ib_mapped) {
cs->ws->base.buffer_destroy(&cs->ws->base, cs->ib_buffer);
return VK_ERROR_OUT_OF_DEVICE_MEMORY;
@ -404,7 +404,7 @@ radv_amdgpu_cs_grow(struct radeon_cmdbuf *_cs, size_t min_size)
radv_amdgpu_restore_last_ib(cs);
}
cs->ib_mapped = cs->ws->base.buffer_map(&cs->ws->base, cs->ib_buffer);
cs->ib_mapped = radv_buffer_map(&cs->ws->base, cs->ib_buffer);
if (!cs->ib_mapped) {
cs->ws->base.buffer_destroy(&cs->ws->base, cs->ib_buffer);
cs->base.cdw = 0;
@ -748,7 +748,7 @@ radv_amdgpu_cs_execute_secondary(struct radeon_cmdbuf *_parent, struct radeon_cm
parent->base.reserved_dw = MAX2(parent->base.reserved_dw, parent->base.cdw + cdw);
mapped = ws->base.buffer_map(&ws->base, ib->bo);
mapped = radv_buffer_map(&ws->base, ib->bo);
if (!mapped) {
parent->status = VK_ERROR_OUT_OF_DEVICE_MEMORY;
return;
@ -1423,7 +1423,7 @@ radv_amdgpu_winsys_cs_dump(struct radeon_cmdbuf *_cs, FILE *file, const int *tra
char name[64];
void *mapped;
mapped = ws->base.buffer_map(&ws->base, ib->bo);
mapped = radv_buffer_map(&ws->base, ib->bo);
if (!mapped)
continue;