From 93362f801acd830a5d6f5ec2d9d824f13112dda8 Mon Sep 17 00:00:00 2001 From: Faith Ekstrand Date: Sun, 6 Aug 2023 11:55:43 -0500 Subject: nvk: Use more consistent device variable names Part-of: --- src/nouveau/vulkan/nvk_cmd_buffer.c | 4 +- src/nouveau/vulkan/nvk_compute_pipeline.c | 33 ++++++++-------- src/nouveau/vulkan/nvk_descriptor_set.c | 60 +++++++++++++++--------------- src/nouveau/vulkan/nvk_descriptor_table.c | 11 +++--- src/nouveau/vulkan/nvk_descriptor_table.h | 4 +- src/nouveau/vulkan/nvk_device.h | 4 +- src/nouveau/vulkan/nvk_device_memory.h | 4 +- src/nouveau/vulkan/nvk_graphics_pipeline.c | 30 +++++++-------- src/nouveau/vulkan/nvk_heap.c | 2 +- src/nouveau/vulkan/nvk_image_view.c | 40 ++++++++++---------- src/nouveau/vulkan/nvk_image_view.h | 4 +- src/nouveau/vulkan/nvk_physical_device.c | 4 +- src/nouveau/vulkan/nvk_physical_device.h | 4 +- src/nouveau/vulkan/nvk_pipeline.c | 22 +++++------ src/nouveau/vulkan/nvk_pipeline.h | 8 ++-- src/nouveau/vulkan/nvk_shader.h | 8 ++-- 16 files changed, 119 insertions(+), 123 deletions(-) diff --git a/src/nouveau/vulkan/nvk_cmd_buffer.c b/src/nouveau/vulkan/nvk_cmd_buffer.c index 6710e426f6e..efe9d38f51e 100644 --- a/src/nouveau/vulkan/nvk_cmd_buffer.c +++ b/src/nouveau/vulkan/nvk_cmd_buffer.c @@ -38,14 +38,14 @@ nvk_create_cmd_buffer(struct vk_command_pool *vk_pool, struct vk_command_buffer **cmd_buffer_out) { struct nvk_cmd_pool *pool = container_of(vk_pool, struct nvk_cmd_pool, vk); - struct nvk_device *device = nvk_cmd_pool_device(pool); + struct nvk_device *dev = nvk_cmd_pool_device(pool); struct nvk_cmd_buffer *cmd; VkResult result; cmd = vk_zalloc(&pool->vk.alloc, sizeof(*cmd), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (cmd == NULL) - return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(dev, VK_ERROR_OUT_OF_HOST_MEMORY); result = vk_command_buffer_init(&pool->vk, &cmd->vk, &nvk_cmd_buffer_ops, 0); diff --git a/src/nouveau/vulkan/nvk_compute_pipeline.c b/src/nouveau/vulkan/nvk_compute_pipeline.c index d73eec7a409..cd0382f9f6f 100644 --- a/src/nouveau/vulkan/nvk_compute_pipeline.c +++ b/src/nouveau/vulkan/nvk_compute_pipeline.c @@ -152,63 +152,62 @@ nvc6c0_compute_setup_launch_desc_template(uint32_t *qmd, } VkResult -nvk_compute_pipeline_create(struct nvk_device *device, +nvk_compute_pipeline_create(struct nvk_device *dev, struct vk_pipeline_cache *cache, const VkComputePipelineCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipeline) { VK_FROM_HANDLE(vk_pipeline_layout, pipeline_layout, pCreateInfo->layout); - struct nvk_physical_device *pdevice = nvk_device_physical(device); + struct nvk_physical_device *pdev = nvk_device_physical(dev); struct nvk_compute_pipeline *pipeline; VkResult result; - pipeline = (void *)nvk_pipeline_zalloc(device, NVK_PIPELINE_COMPUTE, + pipeline = (void *)nvk_pipeline_zalloc(dev, NVK_PIPELINE_COMPUTE, sizeof(*pipeline), pAllocator); if (pipeline == NULL) - return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(dev, VK_ERROR_OUT_OF_HOST_MEMORY); assert(pCreateInfo->stage.stage == VK_SHADER_STAGE_COMPUTE_BIT); struct vk_pipeline_robustness_state robustness; - vk_pipeline_robustness_state_fill(&device->vk, &robustness, + vk_pipeline_robustness_state_fill(&dev->vk, &robustness, pCreateInfo->pNext, pCreateInfo->stage.pNext); const nir_shader_compiler_options *nir_options = - nvk_physical_device_nir_options(pdevice, MESA_SHADER_COMPUTE); + nvk_physical_device_nir_options(pdev, MESA_SHADER_COMPUTE); const struct spirv_to_nir_options spirv_options = - nvk_physical_device_spirv_options(pdevice, &robustness); + nvk_physical_device_spirv_options(pdev, &robustness); nir_shader *nir; - result = vk_pipeline_shader_stage_to_nir(&device->vk, - &pCreateInfo->stage, + result = vk_pipeline_shader_stage_to_nir(&dev->vk, &pCreateInfo->stage, &spirv_options, nir_options, NULL, &nir); if (result != VK_SUCCESS) goto fail; - nvk_lower_nir(device, nir, &robustness, false, pipeline_layout); + nvk_lower_nir(dev, nir, &robustness, false, pipeline_layout); - result = nvk_compile_nir(pdevice, nir, NULL, + result = nvk_compile_nir(pdev, nir, NULL, &pipeline->base.shaders[MESA_SHADER_COMPUTE]); ralloc_free(nir); if (result != VK_SUCCESS) goto fail; - result = nvk_shader_upload(device, + result = nvk_shader_upload(dev, &pipeline->base.shaders[MESA_SHADER_COMPUTE]); if (result != VK_SUCCESS) goto fail; struct nvk_shader *shader = &pipeline->base.shaders[MESA_SHADER_COMPUTE]; - if (device->pdev->info.cls_compute >= AMPERE_COMPUTE_A) + if (pdev->info.cls_compute >= AMPERE_COMPUTE_A) nvc6c0_compute_setup_launch_desc_template(pipeline->qmd_template, shader); - else if (device->pdev->info.cls_compute >= VOLTA_COMPUTE_A) + else if (pdev->info.cls_compute >= VOLTA_COMPUTE_A) nvc3c0_compute_setup_launch_desc_template(pipeline->qmd_template, shader); - else if (device->pdev->info.cls_compute >= PASCAL_COMPUTE_A) + else if (pdev->info.cls_compute >= PASCAL_COMPUTE_A) nvc0c0_compute_setup_launch_desc_template(pipeline->qmd_template, shader); - else if (device->pdev->info.cls_compute >= KEPLER_COMPUTE_A) + else if (pdev->info.cls_compute >= KEPLER_COMPUTE_A) nva0c0_compute_setup_launch_desc_template(pipeline->qmd_template, shader); else unreachable("Fermi and older not supported!"); @@ -217,6 +216,6 @@ nvk_compute_pipeline_create(struct nvk_device *device, return VK_SUCCESS; fail: - nvk_pipeline_free(device, &pipeline->base, pAllocator); + nvk_pipeline_free(dev, &pipeline->base, pAllocator); return result; } diff --git a/src/nouveau/vulkan/nvk_descriptor_set.c b/src/nouveau/vulkan/nvk_descriptor_set.c index 27a7920c4a7..d8b300d9a15 100644 --- a/src/nouveau/vulkan/nvk_descriptor_set.c +++ b/src/nouveau/vulkan/nvk_descriptor_set.c @@ -332,7 +332,7 @@ nvk_push_descriptor_set_update(struct nvk_push_descriptor_set *push_set, } static void -nvk_descriptor_set_destroy(struct nvk_device *device, +nvk_descriptor_set_destroy(struct nvk_device *dev, struct nvk_descriptor_pool *pool, struct nvk_descriptor_set *set, bool free_bo) { @@ -347,18 +347,18 @@ nvk_descriptor_set_destroy(struct nvk_device *device, } } - vk_descriptor_set_layout_unref(&device->vk, &set->layout->vk); + vk_descriptor_set_layout_unref(&dev->vk, &set->layout->vk); - vk_object_free(&device->vk, NULL, set); + vk_object_free(&dev->vk, NULL, set); } static void -nvk_destroy_descriptor_pool(struct nvk_device *device, +nvk_destroy_descriptor_pool(struct nvk_device *dev, const VkAllocationCallbacks *pAllocator, struct nvk_descriptor_pool *pool) { for (int i = 0; i < pool->entry_count; ++i) { - nvk_descriptor_set_destroy(device, pool, pool->entries[i].set, false); + nvk_descriptor_set_destroy(dev, pool, pool->entries[i].set, false); } if (pool->bo) { @@ -366,7 +366,7 @@ nvk_destroy_descriptor_pool(struct nvk_device *device, nouveau_ws_bo_destroy(pool->bo); } - vk_object_free(&device->vk, pAllocator, pool); + vk_object_free(&dev->vk, pAllocator, pool); } VKAPI_ATTR VkResult VKAPI_CALL @@ -375,7 +375,7 @@ nvk_CreateDescriptorPool(VkDevice _device, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool) { - VK_FROM_HANDLE(nvk_device, device, _device); + VK_FROM_HANDLE(nvk_device, dev, _device); struct nvk_descriptor_pool *pool; uint64_t size = sizeof(struct nvk_descriptor_pool); uint64_t bo_size = 0; @@ -424,22 +424,22 @@ nvk_CreateDescriptorPool(VkDevice _device, pCreateInfo->maxSets; size += entries_size; - pool = vk_object_zalloc(&device->vk, pAllocator, size, + pool = vk_object_zalloc(&dev->vk, pAllocator, size, VK_OBJECT_TYPE_DESCRIPTOR_POOL); if (!pool) - return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(dev, VK_ERROR_OUT_OF_HOST_MEMORY); if (bo_size) { uint32_t flags = NOUVEAU_WS_BO_GART | NOUVEAU_WS_BO_MAP | NOUVEAU_WS_BO_NO_SHARE; - pool->bo = nouveau_ws_bo_new(device->ws_dev, bo_size, 0, flags); + pool->bo = nouveau_ws_bo_new(dev->ws_dev, bo_size, 0, flags); if (!pool->bo) { - nvk_destroy_descriptor_pool(device, pAllocator, pool); - return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY); + nvk_destroy_descriptor_pool(dev, pAllocator, pool); + return vk_error(dev, VK_ERROR_OUT_OF_DEVICE_MEMORY); } pool->mapped_ptr = nouveau_ws_bo_map(pool->bo, NOUVEAU_WS_BO_WR); if (!pool->mapped_ptr) { - nvk_destroy_descriptor_pool(device, pAllocator, pool); - return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY); + nvk_destroy_descriptor_pool(dev, pAllocator, pool); + return vk_error(dev, VK_ERROR_OUT_OF_DEVICE_MEMORY); } } @@ -451,7 +451,7 @@ nvk_CreateDescriptorPool(VkDevice _device, } static VkResult -nvk_descriptor_set_create(struct nvk_device *device, +nvk_descriptor_set_create(struct nvk_device *dev, struct nvk_descriptor_pool *pool, struct nvk_descriptor_set_layout *layout, uint32_t variable_count, @@ -462,10 +462,10 @@ nvk_descriptor_set_create(struct nvk_device *device, uint32_t mem_size = sizeof(struct nvk_descriptor_set) + layout->dynamic_buffer_count * sizeof(struct nvk_buffer_address); - set = vk_object_zalloc(&device->vk, NULL, mem_size, + set = vk_object_zalloc(&dev->vk, NULL, mem_size, VK_OBJECT_TYPE_DESCRIPTOR_SET); if (!set) - return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(dev, VK_ERROR_OUT_OF_HOST_MEMORY); if (pool->entry_count == pool->max_entry_count) return VK_ERROR_OUT_OF_POOL_MEMORY; @@ -520,11 +520,11 @@ nvk_descriptor_set_create(struct nvk_device *device, } VKAPI_ATTR VkResult VKAPI_CALL -nvk_AllocateDescriptorSets(VkDevice _device, +nvk_AllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets) { - VK_FROM_HANDLE(nvk_device, device, _device); + VK_FROM_HANDLE(nvk_device, dev, device); VK_FROM_HANDLE(nvk_descriptor_pool, pool, pAllocateInfo->descriptorPool); VkResult result = VK_SUCCESS; @@ -547,7 +547,7 @@ nvk_AllocateDescriptorSets(VkDevice _device, var_desc_count && var_desc_count->descriptorSetCount > 0 ? var_desc_count->pDescriptorCounts[i] : 0; - result = nvk_descriptor_set_create(device, pool, layout, + result = nvk_descriptor_set_create(dev, pool, layout, variable_count, &set); if (result != VK_SUCCESS) break; @@ -556,7 +556,7 @@ nvk_AllocateDescriptorSets(VkDevice _device, } if (result != VK_SUCCESS) { - nvk_FreeDescriptorSets(_device, pAllocateInfo->descriptorPool, i, pDescriptorSets); + nvk_FreeDescriptorSets(device, pAllocateInfo->descriptorPool, i, pDescriptorSets); for (i = 0; i < pAllocateInfo->descriptorSetCount; i++) { pDescriptorSets[i] = VK_NULL_HANDLE; } @@ -565,47 +565,47 @@ nvk_AllocateDescriptorSets(VkDevice _device, } VKAPI_ATTR VkResult VKAPI_CALL -nvk_FreeDescriptorSets(VkDevice _device, +nvk_FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets) { - VK_FROM_HANDLE(nvk_device, device, _device); + VK_FROM_HANDLE(nvk_device, dev, device); VK_FROM_HANDLE(nvk_descriptor_pool, pool, descriptorPool); for (uint32_t i = 0; i < descriptorSetCount; i++) { VK_FROM_HANDLE(nvk_descriptor_set, set, pDescriptorSets[i]); if (set) - nvk_descriptor_set_destroy(device, pool, set, true); + nvk_descriptor_set_destroy(dev, pool, set, true); } return VK_SUCCESS; } VKAPI_ATTR void VKAPI_CALL -nvk_DestroyDescriptorPool(VkDevice _device, +nvk_DestroyDescriptorPool(VkDevice device, VkDescriptorPool _pool, const VkAllocationCallbacks *pAllocator) { - VK_FROM_HANDLE(nvk_device, device, _device); + VK_FROM_HANDLE(nvk_device, dev, device); VK_FROM_HANDLE(nvk_descriptor_pool, pool, _pool); if (!_pool) return; - nvk_destroy_descriptor_pool(device, pAllocator, pool); + nvk_destroy_descriptor_pool(dev, pAllocator, pool); } VKAPI_ATTR VkResult VKAPI_CALL -nvk_ResetDescriptorPool(VkDevice _device, +nvk_ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) { - VK_FROM_HANDLE(nvk_device, device, _device); + VK_FROM_HANDLE(nvk_device, dev, device); VK_FROM_HANDLE(nvk_descriptor_pool, pool, descriptorPool); for (int i = 0; i < pool->entry_count; ++i) { - nvk_descriptor_set_destroy(device, pool, pool->entries[i].set, false); + nvk_descriptor_set_destroy(dev, pool, pool->entries[i].set, false); } pool->entry_count = 0; pool->current_offset = 0; diff --git a/src/nouveau/vulkan/nvk_descriptor_table.c b/src/nouveau/vulkan/nvk_descriptor_table.c index 9bce15b8566..6307f5705ba 100644 --- a/src/nouveau/vulkan/nvk_descriptor_table.c +++ b/src/nouveau/vulkan/nvk_descriptor_table.c @@ -59,7 +59,7 @@ nvk_descriptor_table_grow_locked(struct nvk_device *dev, } VkResult -nvk_descriptor_table_init(struct nvk_device *device, +nvk_descriptor_table_init(struct nvk_device *dev, struct nvk_descriptor_table *table, uint32_t descriptor_size, uint32_t min_descriptor_count, @@ -79,10 +79,9 @@ nvk_descriptor_table_init(struct nvk_device *device, table->next_desc = 0; table->free_count = 0; - result = nvk_descriptor_table_grow_locked(device, table, - min_descriptor_count); + result = nvk_descriptor_table_grow_locked(dev, table, min_descriptor_count); if (result != VK_SUCCESS) { - nvk_descriptor_table_finish(device, table); + nvk_descriptor_table_finish(dev, table); return result; } @@ -90,14 +89,14 @@ nvk_descriptor_table_init(struct nvk_device *device, } void -nvk_descriptor_table_finish(struct nvk_device *device, +nvk_descriptor_table_finish(struct nvk_device *dev, struct nvk_descriptor_table *table) { if (table->bo != NULL) { nouveau_ws_bo_unmap(table->bo, table->map); nouveau_ws_bo_destroy(table->bo); } - vk_free(&device->vk.alloc, table->free_table); + vk_free(&dev->vk.alloc, table->free_table); simple_mtx_destroy(&table->mutex); } diff --git a/src/nouveau/vulkan/nvk_descriptor_table.h b/src/nouveau/vulkan/nvk_descriptor_table.h index 75a064ce484..3cd2d356b0e 100644 --- a/src/nouveau/vulkan/nvk_descriptor_table.h +++ b/src/nouveau/vulkan/nvk_descriptor_table.h @@ -24,13 +24,13 @@ struct nvk_descriptor_table { uint32_t *free_table; }; -VkResult nvk_descriptor_table_init(struct nvk_device *device, +VkResult nvk_descriptor_table_init(struct nvk_device *dev, struct nvk_descriptor_table *table, uint32_t descriptor_size, uint32_t min_descriptor_count, uint32_t max_descriptor_count); -void nvk_descriptor_table_finish(struct nvk_device *device, +void nvk_descriptor_table_finish(struct nvk_device *dev, struct nvk_descriptor_table *table); VkResult nvk_descriptor_table_add(struct nvk_device *dev, diff --git a/src/nouveau/vulkan/nvk_device.h b/src/nouveau/vulkan/nvk_device.h index 8032fad133b..9180454a03a 100644 --- a/src/nouveau/vulkan/nvk_device.h +++ b/src/nouveau/vulkan/nvk_device.h @@ -57,9 +57,9 @@ VkResult nvk_device_ensure_slm(struct nvk_device *dev, uint32_t bytes_per_thread); static inline struct nvk_physical_device * -nvk_device_physical(struct nvk_device *device) +nvk_device_physical(struct nvk_device *dev) { - return (struct nvk_physical_device *)device->vk.physical; + return (struct nvk_physical_device *)dev->vk.physical; } VkResult nvk_device_init_meta(struct nvk_device *dev); diff --git a/src/nouveau/vulkan/nvk_device_memory.h b/src/nouveau/vulkan/nvk_device_memory.h index e29807f5f54..354bd6c9fbf 100644 --- a/src/nouveau/vulkan/nvk_device_memory.h +++ b/src/nouveau/vulkan/nvk_device_memory.h @@ -31,13 +31,13 @@ struct nvk_memory_tiling_info { uint8_t pte_kind; }; -VkResult nvk_allocate_memory(struct nvk_device *device, +VkResult nvk_allocate_memory(struct nvk_device *dev, const VkMemoryAllocateInfo *pAllocateInfo, const struct nvk_memory_tiling_info *tile_info, const VkAllocationCallbacks *pAllocator, struct nvk_device_memory **mem_out); -void nvk_free_memory(struct nvk_device *device, +void nvk_free_memory(struct nvk_device *dev, struct nvk_device_memory *mem, const VkAllocationCallbacks *pAllocator); diff --git a/src/nouveau/vulkan/nvk_graphics_pipeline.c b/src/nouveau/vulkan/nvk_graphics_pipeline.c index 1216534ef1a..e8724a6a463 100644 --- a/src/nouveau/vulkan/nvk_graphics_pipeline.c +++ b/src/nouveau/vulkan/nvk_graphics_pipeline.c @@ -279,27 +279,27 @@ merge_tess_info(struct shader_info *tes_info, struct shader_info *tcs_info) } VkResult -nvk_graphics_pipeline_create(struct nvk_device *device, +nvk_graphics_pipeline_create(struct nvk_device *dev, struct vk_pipeline_cache *cache, const VkGraphicsPipelineCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipeline) { VK_FROM_HANDLE(vk_pipeline_layout, pipeline_layout, pCreateInfo->layout); - struct nvk_physical_device *pdevice = nvk_device_physical(device); + struct nvk_physical_device *pdev = nvk_device_physical(dev); struct nvk_graphics_pipeline *pipeline; VkResult result = VK_SUCCESS; - pipeline = vk_object_zalloc(&device->vk, pAllocator, sizeof(*pipeline), + pipeline = vk_object_zalloc(&dev->vk, pAllocator, sizeof(*pipeline), VK_OBJECT_TYPE_PIPELINE); if (pipeline == NULL) - return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(dev, VK_ERROR_OUT_OF_HOST_MEMORY); pipeline->base.type = NVK_PIPELINE_GRAPHICS; struct vk_graphics_pipeline_all_state all; struct vk_graphics_pipeline_state state = {}; - result = vk_graphics_pipeline_state_fill(&device->vk, &state, pCreateInfo, + result = vk_graphics_pipeline_state_fill(&dev->vk, &state, pCreateInfo, NULL, &all, NULL, 0, NULL); assert(result == VK_SUCCESS); @@ -310,15 +310,15 @@ nvk_graphics_pipeline_create(struct nvk_device *device, const VkPipelineShaderStageCreateInfo *sinfo = &pCreateInfo->pStages[i]; gl_shader_stage stage = vk_to_mesa_shader_stage(sinfo->stage); - vk_pipeline_robustness_state_fill(&device->vk, &robustness[stage], + vk_pipeline_robustness_state_fill(&dev->vk, &robustness[stage], pCreateInfo->pNext, sinfo->pNext); const nir_shader_compiler_options *nir_options = - nvk_physical_device_nir_options(pdevice, stage); + nvk_physical_device_nir_options(pdev, stage); const struct spirv_to_nir_options spirv_options = - nvk_physical_device_spirv_options(pdevice, &robustness[stage]); + nvk_physical_device_spirv_options(pdev, &robustness[stage]); - result = vk_pipeline_shader_stage_to_nir(&device->vk, sinfo, + result = vk_pipeline_shader_stage_to_nir(&dev->vk, sinfo, &spirv_options, nir_options, NULL, &nir[stage]); if (result != VK_SUCCESS) @@ -333,7 +333,7 @@ nvk_graphics_pipeline_create(struct nvk_device *device, for (uint32_t i = 0; i < pCreateInfo->stageCount; i++) { const VkPipelineShaderStageCreateInfo *sinfo = &pCreateInfo->pStages[i]; gl_shader_stage stage = vk_to_mesa_shader_stage(sinfo->stage); - nvk_lower_nir(device, nir[stage], &robustness[stage], + nvk_lower_nir(dev, nir[stage], &robustness[stage], state.rp->view_mask != 0, pipeline_layout); } @@ -347,13 +347,13 @@ nvk_graphics_pipeline_create(struct nvk_device *device, fs_key = &fs_key_tmp; } - result = nvk_compile_nir(pdevice, nir[stage], fs_key, + result = nvk_compile_nir(pdev, nir[stage], fs_key, &pipeline->base.shaders[stage]); ralloc_free(nir[stage]); if (result != VK_SUCCESS) goto fail; - result = nvk_shader_upload(device, &pipeline->base.shaders[stage]); + result = nvk_shader_upload(dev, &pipeline->base.shaders[stage]); if (result != VK_SUCCESS) goto fail; } @@ -381,7 +381,7 @@ nvk_graphics_pipeline_create(struct nvk_device *device, last_geom = shader; uint64_t addr = nvk_shader_address(shader); - if (device->pdev->info.cls_eng3d >= VOLTA_A) { + if (dev->pdev->info.cls_eng3d >= VOLTA_A) { P_MTHD(p, NVC397, SET_PIPELINE_PROGRAM_ADDRESS_A(idx)); P_NVC397_SET_PIPELINE_PROGRAM_ADDRESS_A(p, idx, addr >> 32); P_NVC397_SET_PIPELINE_PROGRAM_ADDRESS_B(p, idx, addr); @@ -408,7 +408,7 @@ nvk_graphics_pipeline_create(struct nvk_device *device, P_IMMD(p, NV9097, SET_API_MANDATED_EARLY_Z, shader->fs.early_z); - if (device->pdev->info.cls_eng3d >= MAXWELL_B) { + if (dev->pdev->info.cls_eng3d >= MAXWELL_B) { P_IMMD(p, NVB197, SET_POST_Z_PS_IMASK, shader->fs.post_depth_coverage); } else { @@ -493,6 +493,6 @@ nvk_graphics_pipeline_create(struct nvk_device *device, return VK_SUCCESS; fail: - vk_object_free(&device->vk, pAllocator, pipeline); + vk_object_free(&dev->vk, pAllocator, pipeline); return result; } diff --git a/src/nouveau/vulkan/nvk_heap.c b/src/nouveau/vulkan/nvk_heap.c index 79c586e36a8..607852d5770 100644 --- a/src/nouveau/vulkan/nvk_heap.c +++ b/src/nouveau/vulkan/nvk_heap.c @@ -10,7 +10,7 @@ #include "nvk_cl90b5.h" VkResult -nvk_heap_init(struct nvk_device *device, struct nvk_heap *heap, +nvk_heap_init(struct nvk_device *dev, struct nvk_heap *heap, enum nouveau_ws_bo_flags bo_flags, enum nouveau_ws_bo_map_flags map_flags, uint32_t overalloc, bool contiguous) diff --git a/src/nouveau/vulkan/nvk_image_view.c b/src/nouveau/vulkan/nvk_image_view.c index 6e423a27aa8..6e3f849c181 100644 --- a/src/nouveau/vulkan/nvk_image_view.c +++ b/src/nouveau/vulkan/nvk_image_view.c @@ -78,7 +78,7 @@ get_stencil_format(enum pipe_format format) } VkResult -nvk_image_view_init(struct nvk_device *device, +nvk_image_view_init(struct nvk_device *dev, struct nvk_image_view *view, bool driver_internal, const VkImageViewCreateInfo *pCreateInfo) @@ -88,7 +88,7 @@ nvk_image_view_init(struct nvk_device *device, memset(view, 0, sizeof(*view)); - vk_image_view_init(&device->vk, &view->vk, driver_internal, pCreateInfo); + vk_image_view_init(&dev->vk, &view->vk, driver_internal, pCreateInfo); /* First, figure out which image planes we need. * For depth/stencil, we only have plane so simply assert @@ -156,14 +156,13 @@ nvk_image_view_init(struct nvk_device *device, if (view->vk.usage & (VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT)) { uint32_t tic[8]; - nil_image_fill_tic(&nvk_device_physical(device)->info, + nil_image_fill_tic(&nvk_device_physical(dev)->info, &nil_image, &nil_view, base_addr, tic); - result = nvk_descriptor_table_add(device, &device->images, - tic, sizeof(tic), + result = nvk_descriptor_table_add(dev, &dev->images, tic, sizeof(tic), &view->planes[view_plane].sampled_desc_index); if (result != VK_SUCCESS) { - nvk_image_view_finish(device, view); + nvk_image_view_finish(dev, view); return result; } } @@ -188,14 +187,13 @@ nvk_image_view_init(struct nvk_device *device, } uint32_t tic[8]; - nil_image_fill_tic(&nvk_device_physical(device)->info, + nil_image_fill_tic(&nvk_device_physical(dev)->info, &nil_image, &nil_view, base_addr, tic); - result = nvk_descriptor_table_add(device, &device->images, - tic, sizeof(tic), + result = nvk_descriptor_table_add(dev, &dev->images, tic, sizeof(tic), &view->planes[view_plane].storage_desc_index); if (result != VK_SUCCESS) { - nvk_image_view_finish(device, view); + nvk_image_view_finish(dev, view); return result; } } @@ -205,17 +203,17 @@ nvk_image_view_init(struct nvk_device *device, } void -nvk_image_view_finish(struct nvk_device *device, +nvk_image_view_finish(struct nvk_device *dev, struct nvk_image_view *view) { for (uint8_t plane = 0; plane < view->plane_count; plane++) { if (view->planes[plane].sampled_desc_index) { - nvk_descriptor_table_remove(device, &device->images, + nvk_descriptor_table_remove(dev, &dev->images, view->planes[plane].sampled_desc_index); } if (view->planes[plane].storage_desc_index) { - nvk_descriptor_table_remove(device, &device->images, + nvk_descriptor_table_remove(dev, &dev->images, view->planes[plane].storage_desc_index); } } @@ -229,18 +227,18 @@ nvk_CreateImageView(VkDevice _device, const VkAllocationCallbacks *pAllocator, VkImageView *pView) { - VK_FROM_HANDLE(nvk_device, device, _device); + VK_FROM_HANDLE(nvk_device, dev, _device); struct nvk_image_view *view; VkResult result; - view = vk_alloc2(&device->vk.alloc, pAllocator, sizeof(*view), 8, + view = vk_alloc2(&dev->vk.alloc, pAllocator, sizeof(*view), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (!view) - return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); + return vk_error(dev, VK_ERROR_OUT_OF_HOST_MEMORY); - result = nvk_image_view_init(device, view, false, pCreateInfo); + result = nvk_image_view_init(dev, view, false, pCreateInfo); if (result != VK_SUCCESS) { - vk_free2(&device->vk.alloc, pAllocator, view); + vk_free2(&dev->vk.alloc, pAllocator, view); return result; } @@ -254,12 +252,12 @@ nvk_DestroyImageView(VkDevice _device, VkImageView imageView, const VkAllocationCallbacks *pAllocator) { - VK_FROM_HANDLE(nvk_device, device, _device); + VK_FROM_HANDLE(nvk_device, dev, _device); VK_FROM_HANDLE(nvk_image_view, view, imageView); if (!view) return; - nvk_image_view_finish(device, view); - vk_free2(&device->vk.alloc, pAllocator, view); + nvk_image_view_finish(dev, view); + vk_free2(&dev->vk.alloc, pAllocator, view); } diff --git a/src/nouveau/vulkan/nvk_image_view.h b/src/nouveau/vulkan/nvk_image_view.h index 269ba91b6ea..05b7db6c2d6 100644 --- a/src/nouveau/vulkan/nvk_image_view.h +++ b/src/nouveau/vulkan/nvk_image_view.h @@ -25,12 +25,12 @@ struct nvk_image_view { VK_DEFINE_NONDISP_HANDLE_CASTS(nvk_image_view, vk.base, VkImageView, VK_OBJECT_TYPE_IMAGE_VIEW) -VkResult nvk_image_view_init(struct nvk_device *device, +VkResult nvk_image_view_init(struct nvk_device *dev, struct nvk_image_view *view, bool driver_internal, const VkImageViewCreateInfo *pCreateInfo); -void nvk_image_view_finish(struct nvk_device *device, +void nvk_image_view_finish(struct nvk_device *dev, struct nvk_image_view *view); #endif diff --git a/src/nouveau/vulkan/nvk_physical_device.c b/src/nouveau/vulkan/nvk_physical_device.c index 9afdf660b17..9df81622f80 100644 --- a/src/nouveau/vulkan/nvk_physical_device.c +++ b/src/nouveau/vulkan/nvk_physical_device.c @@ -642,7 +642,7 @@ nvk_get_device_features(const struct nv_device_info *info, VkResult nvk_create_drm_physical_device(struct vk_instance *_instance, drmDevicePtr drm_device, - struct vk_physical_device **device_out) + struct vk_physical_device **pdev_out) { struct nvk_instance *instance = (struct nvk_instance *)_instance; VkResult result; @@ -811,7 +811,7 @@ nvk_create_drm_physical_device(struct vk_instance *_instance, if (result != VK_SUCCESS) goto fail_init; - *device_out = &pdev->vk; + *pdev_out = &pdev->vk; return VK_SUCCESS; diff --git a/src/nouveau/vulkan/nvk_physical_device.h b/src/nouveau/vulkan/nvk_physical_device.h index b48d15acbe3..d86c048d085 100644 --- a/src/nouveau/vulkan/nvk_physical_device.h +++ b/src/nouveau/vulkan/nvk_physical_device.h @@ -46,8 +46,8 @@ nvk_physical_device_instance(struct nvk_physical_device *pdev) } VkResult nvk_create_drm_physical_device(struct vk_instance *vk_instance, - struct _drmDevice *device, - struct vk_physical_device **out); + struct _drmDevice *drm_device, + struct vk_physical_device **pdev_out); void nvk_physical_device_destroy(struct vk_physical_device *vk_device); diff --git a/src/nouveau/vulkan/nvk_pipeline.c b/src/nouveau/vulkan/nvk_pipeline.c index 08bba2d2287..c8f06f7d70a 100644 --- a/src/nouveau/vulkan/nvk_pipeline.c +++ b/src/nouveau/vulkan/nvk_pipeline.c @@ -6,14 +6,14 @@ #include "vk_pipeline_cache.h" struct nvk_pipeline * -nvk_pipeline_zalloc(struct nvk_device *device, +nvk_pipeline_zalloc(struct nvk_device *dev, enum nvk_pipeline_type type, size_t size, const VkAllocationCallbacks *pAllocator) { struct nvk_pipeline *pipeline; assert(size >= sizeof(*pipeline)); - pipeline = vk_object_zalloc(&device->vk, pAllocator, size, + pipeline = vk_object_zalloc(&dev->vk, pAllocator, size, VK_OBJECT_TYPE_PIPELINE); if (pipeline == NULL) return NULL; @@ -24,20 +24,20 @@ nvk_pipeline_zalloc(struct nvk_device *device, } void -nvk_pipeline_free(struct nvk_device *device, +nvk_pipeline_free(struct nvk_device *dev, struct nvk_pipeline *pipeline, const VkAllocationCallbacks *pAllocator) { for (uint32_t s = 0; s < ARRAY_SIZE(pipeline->shaders); s++) { if (pipeline->shaders[s].upload_size > 0) { - nvk_heap_free(device, &device->shader_heap, + nvk_heap_free(dev, &dev->shader_heap, pipeline->shaders[s].upload_addr, pipeline->shaders[s].upload_size); } free(pipeline->shaders[s].xfb); } - vk_object_free(&device->vk, pAllocator, pipeline); + vk_object_free(&dev->vk, pAllocator, pipeline); } VKAPI_ATTR VkResult VKAPI_CALL @@ -48,13 +48,13 @@ nvk_CreateGraphicsPipelines(VkDevice _device, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) { - VK_FROM_HANDLE(nvk_device, device, _device); + VK_FROM_HANDLE(nvk_device, dev, _device); VK_FROM_HANDLE(vk_pipeline_cache, cache, pipelineCache); VkResult result = VK_SUCCESS; unsigned i = 0; for (; i < createInfoCount; i++) { - VkResult r = nvk_graphics_pipeline_create(device, cache, &pCreateInfos[i], + VkResult r = nvk_graphics_pipeline_create(dev, cache, &pCreateInfos[i], pAllocator, &pPipelines[i]); if (r == VK_SUCCESS) continue; @@ -79,13 +79,13 @@ nvk_CreateComputePipelines(VkDevice _device, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) { - VK_FROM_HANDLE(nvk_device, device, _device); + VK_FROM_HANDLE(nvk_device, dev, _device); VK_FROM_HANDLE(vk_pipeline_cache, cache, pipelineCache); VkResult result = VK_SUCCESS; unsigned i = 0; for (; i < createInfoCount; i++) { - VkResult r = nvk_compute_pipeline_create(device, cache, &pCreateInfos[i], + VkResult r = nvk_compute_pipeline_create(dev, cache, &pCreateInfos[i], pAllocator, &pPipelines[i]); if (r == VK_SUCCESS) continue; @@ -106,11 +106,11 @@ VKAPI_ATTR void VKAPI_CALL nvk_DestroyPipeline(VkDevice _device, VkPipeline _pipeline, const VkAllocationCallbacks *pAllocator) { - VK_FROM_HANDLE(nvk_device, device, _device); + VK_FROM_HANDLE(nvk_device, dev, _device); VK_FROM_HANDLE(nvk_pipeline, pipeline, _pipeline); if (!pipeline) return; - nvk_pipeline_free(device, pipeline, pAllocator); + nvk_pipeline_free(dev, pipeline, pAllocator); } diff --git a/src/nouveau/vulkan/nvk_pipeline.h b/src/nouveau/vulkan/nvk_pipeline.h index 3313e0a3df0..c77343453cb 100644 --- a/src/nouveau/vulkan/nvk_pipeline.h +++ b/src/nouveau/vulkan/nvk_pipeline.h @@ -26,11 +26,11 @@ VK_DEFINE_NONDISP_HANDLE_CASTS(nvk_pipeline, base, VkPipeline, VK_OBJECT_TYPE_PIPELINE) void -nvk_pipeline_free(struct nvk_device *device, +nvk_pipeline_free(struct nvk_device *dev, struct nvk_pipeline *pipeline, const VkAllocationCallbacks *pAllocator); struct nvk_pipeline * -nvk_pipeline_zalloc(struct nvk_device *device, +nvk_pipeline_zalloc(struct nvk_device *dev, enum nvk_pipeline_type type, size_t size, const VkAllocationCallbacks *pAllocator); @@ -41,7 +41,7 @@ struct nvk_compute_pipeline { }; VkResult -nvk_compute_pipeline_create(struct nvk_device *device, +nvk_compute_pipeline_create(struct nvk_device *dev, struct vk_pipeline_cache *cache, const VkComputePipelineCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, @@ -59,7 +59,7 @@ struct nvk_graphics_pipeline { }; VkResult -nvk_graphics_pipeline_create(struct nvk_device *device, +nvk_graphics_pipeline_create(struct nvk_device *dev, struct vk_pipeline_cache *cache, const VkGraphicsPipelineCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, diff --git a/src/nouveau/vulkan/nvk_shader.h b/src/nouveau/vulkan/nvk_shader.h index 1a066af615c..1314abf6c02 100644 --- a/src/nouveau/vulkan/nvk_shader.h +++ b/src/nouveau/vulkan/nvk_shader.h @@ -91,7 +91,7 @@ nvk_shader_address(const struct nvk_shader *shader) } const nir_shader_compiler_options * -nvk_physical_device_nir_options(const struct nvk_physical_device *pdevice, +nvk_physical_device_nir_options(const struct nvk_physical_device *pdev, gl_shader_stage stage); static inline nir_address_format @@ -109,7 +109,7 @@ nvk_buffer_addr_format(VkPipelineRobustnessBufferBehaviorEXT robustness) } struct spirv_to_nir_options -nvk_physical_device_spirv_options(const struct nvk_physical_device *pdevice, +nvk_physical_device_spirv_options(const struct nvk_physical_device *pdev, const struct vk_pipeline_robustness_state *rs); bool @@ -118,13 +118,13 @@ nvk_nir_lower_descriptors(nir_shader *nir, const struct vk_pipeline_layout *layout); void -nvk_lower_nir(struct nvk_device *device, nir_shader *nir, +nvk_lower_nir(struct nvk_device *dev, nir_shader *nir, const struct vk_pipeline_robustness_state *rs, bool is_multiview, const struct vk_pipeline_layout *layout); VkResult -nvk_compile_nir(struct nvk_physical_device *device, nir_shader *nir, +nvk_compile_nir(struct nvk_physical_device *dev, nir_shader *nir, const struct nvk_fs_key *fs_key, struct nvk_shader *shader); -- cgit v1.2.3