X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fvulkan%2Fanv_device.c;h=aca082ac1b51b26e90896afdcdd91242c065c052;hb=3db43e8f3e60f8dc746eb4ab2e86f6b1b32d248a;hp=5302ee5cd7316a5d1b670265ac6599d508b372fa;hpb=f0f4dfa9cc1473c5e12eeeb9403f721d5611e905;p=mesa.git diff --git a/src/vulkan/anv_device.c b/src/vulkan/anv_device.c index 5302ee5cd73..aca082ac1b5 100644 --- a/src/vulkan/anv_device.c +++ b/src/vulkan/anv_device.c @@ -31,8 +31,26 @@ #include "mesa/main/git_sha1.h" #include "util/strtod.h" +#include "gen7_pack.h" + struct anv_dispatch_table dtable; +static void +compiler_debug_log(void *data, const char *fmt, ...) +{ } + +static void +compiler_perf_log(void *data, const char *fmt, ...) +{ + va_list args; + va_start(args, fmt); + + if (unlikely(INTEL_DEBUG & DEBUG_PERF)) + vfprintf(stderr, fmt, args); + + va_end(args); +} + static VkResult anv_physical_device_init(struct anv_physical_device *device, struct anv_instance *instance, @@ -43,54 +61,93 @@ anv_physical_device_init(struct anv_physical_device *device, fd = open(path, O_RDWR | O_CLOEXEC); if (fd < 0) - return vk_errorf(VK_ERROR_UNAVAILABLE, "failed to open %s: %m", path); + return vk_errorf(VK_ERROR_INITIALIZATION_FAILED, + "failed to open %s: %m", path); device->_loader_data.loaderMagic = ICD_LOADER_MAGIC; device->instance = instance; device->path = path; - + device->chipset_id = anv_gem_get_param(fd, I915_PARAM_CHIPSET_ID); if (!device->chipset_id) { - result = vk_errorf(VK_ERROR_UNAVAILABLE, "failed to get chipset id: %m"); + result = vk_errorf(VK_ERROR_INITIALIZATION_FAILED, + "failed to get chipset id: %m"); goto fail; } device->name = brw_get_device_name(device->chipset_id); - device->info = brw_get_device_info(device->chipset_id, -1); + device->info = brw_get_device_info(device->chipset_id); if (!device->info) { - result = vk_errorf(VK_ERROR_UNAVAILABLE, "failed to get device info"); + result = vk_errorf(VK_ERROR_INITIALIZATION_FAILED, + "failed to get device info"); + goto fail; + } + + if (device->info->is_haswell) { + fprintf(stderr, "WARNING: Haswell Vulkan support is incomplete\n"); + } else if (device->info->gen == 7 && !device->info->is_baytrail) { + fprintf(stderr, "WARNING: Ivy Bridge Vulkan support is incomplete\n"); + } else if (device->info->gen == 9) { + fprintf(stderr, "WARNING: Skylake Vulkan support is incomplete\n"); + } else if (device->info->gen == 8 && !device->info->is_cherryview) { + /* Broadwell is as fully supported as anything */ + } else { + result = vk_errorf(VK_UNSUPPORTED, + "Vulkan not yet supported on %s", device->name); goto fail; } - + if (anv_gem_get_aperture(fd, &device->aperture_size) == -1) { - result = vk_errorf(VK_ERROR_UNAVAILABLE, "failed to get aperture size: %m"); + result = vk_errorf(VK_ERROR_INITIALIZATION_FAILED, + "failed to get aperture size: %m"); goto fail; } if (!anv_gem_get_param(fd, I915_PARAM_HAS_WAIT_TIMEOUT)) { - result = vk_errorf(VK_ERROR_UNAVAILABLE, "kernel missing gem wait"); + result = vk_errorf(VK_ERROR_INITIALIZATION_FAILED, + "kernel missing gem wait"); goto fail; } if (!anv_gem_get_param(fd, I915_PARAM_HAS_EXECBUF2)) { - result = vk_errorf(VK_ERROR_UNAVAILABLE, "kernel missing execbuf2"); + result = vk_errorf(VK_ERROR_INITIALIZATION_FAILED, + "kernel missing execbuf2"); goto fail; } if (!anv_gem_get_param(fd, I915_PARAM_HAS_LLC)) { - result = vk_errorf(VK_ERROR_UNAVAILABLE, "non-llc gpu"); + result = vk_errorf(VK_ERROR_INITIALIZATION_FAILED, + "non-llc gpu"); goto fail; } - + close(fd); + brw_process_intel_debug_variable(); + + device->compiler = brw_compiler_create(NULL, device->info); + if (device->compiler == NULL) { + result = vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); + goto fail; + } + device->compiler->shader_debug_log = compiler_debug_log; + device->compiler->shader_perf_log = compiler_perf_log; + + isl_device_init(&device->isl_dev, device->info); + return VK_SUCCESS; - + fail: close(fd); return result; } +static void +anv_physical_device_finish(struct anv_physical_device *device) +{ + ralloc_free(device->compiler); +} + static void *default_alloc( void* pUserData, size_t size, @@ -115,19 +172,18 @@ static const VkAllocCallbacks default_alloc_callbacks = { static const VkExtensionProperties global_extensions[] = { { - .extName = "VK_WSI_swapchain", - .specVersion = 12 + .extName = VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME, + .specVersion = 17, }, }; static const VkExtensionProperties device_extensions[] = { { - .extName = "VK_WSI_device_swapchain", - .specVersion = 12 + .extName = VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME, + .specVersion = 53, }, }; - VkResult anv_CreateInstance( const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance) @@ -138,6 +194,9 @@ VkResult anv_CreateInstance( assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO); + if (pCreateInfo->pAppInfo->apiVersion != VK_MAKE_VERSION(0, 170, 2)) + return vk_error(VK_ERROR_INCOMPATIBLE_DRIVER); + for (uint32_t i = 0; i < pCreateInfo->extensionCount; i++) { bool found = false; for (uint32_t j = 0; j < ARRAY_SIZE(global_extensions); j++) { @@ -148,7 +207,7 @@ VkResult anv_CreateInstance( } } if (!found) - return vk_error(VK_ERROR_INVALID_EXTENSION); + return vk_error(VK_ERROR_EXTENSION_NOT_PRESENT); } if (pCreateInfo->pAllocCb) { @@ -165,7 +224,7 @@ VkResult anv_CreateInstance( instance->pfnAlloc = alloc_callbacks->pfnAlloc; instance->pfnFree = alloc_callbacks->pfnFree; instance->apiVersion = pCreateInfo->pAppInfo->apiVersion; - instance->physicalDeviceCount = 0; + instance->physicalDeviceCount = -1; _mesa_locale_init(); @@ -178,11 +237,17 @@ VkResult anv_CreateInstance( return VK_SUCCESS; } -VkResult anv_DestroyInstance( +void anv_DestroyInstance( VkInstance _instance) { ANV_FROM_HANDLE(anv_instance, instance, _instance); + if (instance->physicalDeviceCount > 0) { + /* We support at most one physical device. */ + assert(instance->physicalDeviceCount == 1); + anv_physical_device_finish(&instance->physicalDevice); + } + anv_finish_wsi(instance); VG(VALGRIND_DESTROY_MEMPOOL(instance)); @@ -190,8 +255,6 @@ VkResult anv_DestroyInstance( _mesa_locale_fini(); instance->pfnFree(instance->pAllocUserData, instance); - - return VK_SUCCESS; } void * @@ -226,13 +289,16 @@ VkResult anv_EnumeratePhysicalDevices( ANV_FROM_HANDLE(anv_instance, instance, _instance); VkResult result; - if (instance->physicalDeviceCount == 0) { + if (instance->physicalDeviceCount < 0) { result = anv_physical_device_init(&instance->physicalDevice, instance, "/dev/dri/renderD128"); - if (result != VK_SUCCESS) + if (result == VK_UNSUPPORTED) { + instance->physicalDeviceCount = 0; + } else if (result == VK_SUCCESS) { + instance->physicalDeviceCount = 1; + } else { return result; - - instance->physicalDeviceCount = 1; + } } /* pPhysicalDeviceCount is an out parameter if pPhysicalDevices is NULL; @@ -280,7 +346,7 @@ VkResult anv_GetPhysicalDeviceFeatures( .sampleRateShading = false, .dualSourceBlend = true, .logicOp = true, - .instancedDrawIndirect = true, + .multiDrawIndirect = true, .depthClip = false, .depthBiasClamp = false, .fillModeNonSolid = true, @@ -290,6 +356,7 @@ VkResult anv_GetPhysicalDeviceFeatures( .textureCompressionETC2 = true, .textureCompressionASTC_LDR = true, .textureCompressionBC = true, + .occlusionQueryNonConservative = false, /* FINISHME */ .pipelineStatisticsQuery = true, .vertexSideEffects = false, .tessellationSideEffects = false, @@ -297,11 +364,9 @@ VkResult anv_GetPhysicalDeviceFeatures( .fragmentSideEffects = false, .shaderTessellationPointSize = false, .shaderGeometryPointSize = true, - .shaderTextureGatherExtended = true, + .shaderImageGatherExtended = true, .shaderStorageImageExtendedFormats = false, .shaderStorageImageMultisample = false, - .shaderStorageBufferArrayConstantIndexing = false, - .shaderStorageImageArrayConstantIndexing = false, .shaderUniformBufferArrayDynamicIndexing = true, .shaderSampledImageArrayDynamicIndexing = false, .shaderStorageBufferArrayDynamicIndexing = false, @@ -310,34 +375,39 @@ VkResult anv_GetPhysicalDeviceFeatures( .shaderCullDistance = false, .shaderFloat64 = false, .shaderInt64 = false, - .shaderFloat16 = false, .shaderInt16 = false, + .alphaToOne = true, }; return VK_SUCCESS; } -VkResult anv_GetPhysicalDeviceLimits( +VkResult anv_GetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, - VkPhysicalDeviceLimits* pLimits) + VkPhysicalDeviceProperties* pProperties) { - ANV_FROM_HANDLE(anv_physical_device, physical_device, physicalDevice); - const struct brw_device_info *devinfo = physical_device->info; + ANV_FROM_HANDLE(anv_physical_device, pdevice, physicalDevice); + const struct brw_device_info *devinfo = pdevice->info; - anv_finishme("Get correct values for PhysicalDeviceLimits"); + anv_finishme("Get correct values for VkPhysicalDeviceLimits"); - *pLimits = (VkPhysicalDeviceLimits) { + VkPhysicalDeviceLimits limits = { .maxImageDimension1D = (1 << 14), .maxImageDimension2D = (1 << 14), .maxImageDimension3D = (1 << 10), .maxImageDimensionCube = (1 << 14), .maxImageArrayLayers = (1 << 10), + + /* Broadwell supports 1, 2, 4, and 8 samples. */ + .sampleCounts = 4, + .maxTexelBufferSize = (1 << 14), .maxUniformBufferSize = UINT32_MAX, .maxStorageBufferSize = UINT32_MAX, .maxPushConstantsSize = MAX_PUSH_CONSTANTS_SIZE, .maxMemoryAllocationCount = UINT32_MAX, .bufferImageGranularity = 64, /* A cache line */ + .sparseAddressSpaceSize = 0, .maxBoundDescriptorSets = MAX_SETS, .maxDescriptorSets = UINT32_MAX, .maxPerStageDescriptorSamplers = 64, @@ -347,10 +417,13 @@ VkResult anv_GetPhysicalDeviceLimits( .maxPerStageDescriptorStorageImages = 64, .maxDescriptorSetSamplers = 256, .maxDescriptorSetUniformBuffers = 256, + .maxDescriptorSetUniformBuffersDynamic = 256, .maxDescriptorSetStorageBuffers = 256, + .maxDescriptorSetStorageBuffersDynamic = 256, .maxDescriptorSetSampledImages = 256, .maxDescriptorSetStorageImages = 256, .maxVertexInputAttributes = 32, + .maxVertexInputBindings = 32, .maxVertexInputAttributeOffset = 256, .maxVertexInputBindingStride = 256, .maxVertexOutputComponents = 32, @@ -391,8 +464,7 @@ VkResult anv_GetPhysicalDeviceLimits( .primitiveRestartForPatches = UINT32_MAX, .maxSamplerLodBias = 16, .maxSamplerAnisotropy = 16, - .maxViewports = 16, - .maxDynamicViewportStates = UINT32_MAX, + .maxViewports = MAX_VIEWPORTS, .maxViewportDimensions = { (1 << 14), (1 << 14) }, .viewportBoundsRange = { -1.0, 1.0 }, /* FIXME */ .viewportSubPixelBits = 13, /* We take a float? */ @@ -429,21 +501,14 @@ VkResult anv_GetPhysicalDeviceLimits( .lineWidthGranularity = (1.0 / 128.0), }; - return VK_SUCCESS; -} - -VkResult anv_GetPhysicalDeviceProperties( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties* pProperties) -{ - ANV_FROM_HANDLE(anv_physical_device, pdevice, physicalDevice); - *pProperties = (VkPhysicalDeviceProperties) { - .apiVersion = VK_MAKE_VERSION(0, 138, 1), + .apiVersion = VK_MAKE_VERSION(0, 170, 2), .driverVersion = 1, .vendorId = 0x8086, .deviceId = pdevice->chipset_id, .deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU, + .limits = limits, + .sparseProperties = {0}, /* Broadwell doesn't do sparse. */ }; strcpy(pProperties->deviceName, pdevice->name); @@ -453,23 +518,19 @@ VkResult anv_GetPhysicalDeviceProperties( return VK_SUCCESS; } -VkResult anv_GetPhysicalDeviceQueueCount( +VkResult anv_GetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice physicalDevice, - uint32_t* pCount) + uint32_t* pCount, + VkQueueFamilyProperties* pQueueFamilyProperties) { - *pCount = 1; - - return VK_SUCCESS; -} + if (pQueueFamilyProperties == NULL) { + *pCount = 1; + return VK_SUCCESS; + } -VkResult anv_GetPhysicalDeviceQueueProperties( - VkPhysicalDevice physicalDevice, - uint32_t count, - VkPhysicalDeviceQueueProperties* pQueueProperties) -{ - assert(count == 1); + assert(*pCount >= 1); - *pQueueProperties = (VkPhysicalDeviceQueueProperties) { + *pQueueFamilyProperties = (VkQueueFamilyProperties) { .queueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_DMA_BIT, @@ -502,7 +563,7 @@ VkResult anv_GetPhysicalDeviceMemoryProperties( pMemoryProperties->memoryHeapCount = 1; pMemoryProperties->memoryHeaps[0] = (VkMemoryHeap) { .size = heap_size, - .flags = VK_MEMORY_HEAP_HOST_LOCAL, + .flags = VK_MEMORY_HEAP_HOST_LOCAL_BIT, }; return VK_SUCCESS; @@ -529,37 +590,24 @@ anv_queue_init(struct anv_device *device, struct anv_queue *queue) queue->device = device; queue->pool = &device->surface_state_pool; - queue->completed_serial = anv_state_pool_alloc(queue->pool, 4, 4); - if (queue->completed_serial.map == NULL) - return vk_error(VK_ERROR_OUT_OF_DEVICE_MEMORY); - - *(uint32_t *)queue->completed_serial.map = 0; - queue->next_serial = 1; - return VK_SUCCESS; } static void anv_queue_finish(struct anv_queue *queue) { -#ifdef HAVE_VALGRIND - /* This gets torn down with the device so we only need to do this if - * valgrind is present. - */ - anv_state_pool_free(queue->pool, queue->completed_serial); -#endif } static void anv_device_init_border_colors(struct anv_device *device) { static const VkClearColorValue border_colors[] = { - [VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK] = { .f32 = { 0.0, 0.0, 0.0, 0.0 } }, - [VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK] = { .f32 = { 0.0, 0.0, 0.0, 1.0 } }, - [VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE] = { .f32 = { 1.0, 1.0, 1.0, 1.0 } }, - [VK_BORDER_COLOR_INT_TRANSPARENT_BLACK] = { .u32 = { 0, 0, 0, 0 } }, - [VK_BORDER_COLOR_INT_OPAQUE_BLACK] = { .u32 = { 0, 0, 0, 1 } }, - [VK_BORDER_COLOR_INT_OPAQUE_WHITE] = { .u32 = { 1, 1, 1, 1 } }, + [VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK] = { .float32 = { 0.0, 0.0, 0.0, 0.0 } }, + [VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK] = { .float32 = { 0.0, 0.0, 0.0, 1.0 } }, + [VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE] = { .float32 = { 1.0, 1.0, 1.0, 1.0 } }, + [VK_BORDER_COLOR_INT_TRANSPARENT_BLACK] = { .uint32 = { 0, 0, 0, 0 } }, + [VK_BORDER_COLOR_INT_OPAQUE_BLACK] = { .uint32 = { 0, 0, 0, 1 } }, + [VK_BORDER_COLOR_INT_OPAQUE_WHITE] = { .uint32 = { 1, 1, 1, 1 } }, }; device->border_colors = @@ -589,10 +637,10 @@ VkResult anv_CreateDevice( } } if (!found) - return vk_error(VK_ERROR_INVALID_EXTENSION); + return vk_error(VK_ERROR_EXTENSION_NOT_PRESENT); } - anv_set_dispatch_gen(physical_device->info->gen); + anv_set_dispatch_devinfo(physical_device->info); device = anv_instance_alloc(instance, sizeof(*device), 8, VK_SYSTEM_ALLOC_TYPE_API_OBJECT); @@ -606,7 +654,7 @@ VkResult anv_CreateDevice( device->fd = open(physical_device->path, O_RDWR | O_CLOEXEC); if (device->fd == -1) goto fail_device; - + device->context_id = anv_gem_create_context(device); if (device->context_id == -1) goto fail_fd; @@ -620,17 +668,18 @@ VkResult anv_CreateDevice( anv_state_pool_init(&device->dynamic_state_pool, &device->dynamic_state_block_pool); - anv_block_pool_init(&device->instruction_block_pool, device, 2048); + anv_block_pool_init(&device->instruction_block_pool, device, 4096); anv_block_pool_init(&device->surface_state_block_pool, device, 4096); anv_state_pool_init(&device->surface_state_pool, &device->surface_state_block_pool); + anv_bo_init_new(&device->workaround_bo, device, 1024); + anv_block_pool_init(&device->scratch_block_pool, device, 0x10000); device->info = *physical_device->info; - - device->compiler = anv_compiler_create(device); + device->isl_dev = physical_device->isl_dev; anv_queue_init(device, &device->queue); @@ -647,16 +696,14 @@ VkResult anv_CreateDevice( fail_device: anv_device_free(device, device); - return vk_error(VK_ERROR_UNAVAILABLE); + return vk_error(VK_ERROR_INITIALIZATION_FAILED); } -VkResult anv_DestroyDevice( +void anv_DestroyDevice( VkDevice _device) { ANV_FROM_HANDLE(anv_device, device, _device); - anv_compiler_destroy(device->compiler); - anv_queue_finish(&device->queue); anv_device_finish_meta(device); @@ -668,6 +715,9 @@ VkResult anv_DestroyDevice( anv_state_pool_free(&device->dynamic_state_pool, device->border_colors); #endif + anv_gem_munmap(device->workaround_bo.map, device->workaround_bo.size); + anv_gem_close(device, device->workaround_bo.gem_handle); + anv_bo_pool_finish(&device->batch_bo_pool); anv_state_pool_finish(&device->dynamic_state_pool); anv_block_pool_finish(&device->dynamic_state_block_pool); @@ -679,11 +729,9 @@ VkResult anv_DestroyDevice( close(device->fd); anv_instance_free(device->instance, device); - - return VK_SUCCESS; } -VkResult anv_GetGlobalExtensionProperties( +VkResult anv_EnumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties) @@ -701,7 +749,7 @@ VkResult anv_GetGlobalExtensionProperties( return VK_SUCCESS; } -VkResult anv_GetPhysicalDeviceExtensionProperties( +VkResult anv_EnumerateDeviceExtensionProperties( VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, @@ -720,7 +768,7 @@ VkResult anv_GetPhysicalDeviceExtensionProperties( return VK_SUCCESS; } -VkResult anv_GetGlobalLayerProperties( +VkResult anv_EnumerateInstanceLayerProperties( uint32_t* pCount, VkLayerProperties* pProperties) { @@ -730,10 +778,10 @@ VkResult anv_GetGlobalLayerProperties( } /* None supported at this time */ - return vk_error(VK_ERROR_INVALID_LAYER); + return vk_error(VK_ERROR_LAYER_NOT_PRESENT); } -VkResult anv_GetPhysicalDeviceLayerProperties( +VkResult anv_EnumerateDeviceLayerProperties( VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties) @@ -744,7 +792,7 @@ VkResult anv_GetPhysicalDeviceLayerProperties( } /* None supported at this time */ - return vk_error(VK_ERROR_INVALID_LAYER); + return vk_error(VK_ERROR_LAYER_NOT_PRESENT); } VkResult anv_GetDeviceQueue( @@ -779,13 +827,19 @@ VkResult anv_QueueSubmit( assert(cmd_buffer->level == VK_CMD_BUFFER_LEVEL_PRIMARY); ret = anv_gem_execbuffer(device, &cmd_buffer->execbuf2.execbuf); - if (ret != 0) - return vk_errorf(VK_ERROR_UNKNOWN, "execbuf2 failed: %m"); + if (ret != 0) { + /* We don't know the real error. */ + return vk_errorf(VK_ERROR_OUT_OF_DEVICE_MEMORY, + "execbuf2 failed: %m"); + } if (fence) { ret = anv_gem_execbuffer(device, &fence->execbuf); - if (ret != 0) - return vk_errorf(VK_ERROR_UNKNOWN, "execbuf2 failed: %m"); + if (ret != 0) { + /* We don't know the real error. */ + return vk_errorf(VK_ERROR_OUT_OF_DEVICE_MEMORY, + "execbuf2 failed: %m"); + } } for (uint32_t i = 0; i < cmd_buffer->execbuf2.bo_count; i++) @@ -848,14 +902,16 @@ VkResult anv_DeviceWaitIdle( ret = anv_gem_execbuffer(device, &execbuf); if (ret != 0) { - result = vk_errorf(VK_ERROR_UNKNOWN, "execbuf2 failed: %m"); + /* We don't know the real error. */ + result = vk_errorf(VK_ERROR_OUT_OF_DEVICE_MEMORY, "execbuf2 failed: %m"); goto fail; } timeout = INT64_MAX; ret = anv_gem_wait(device, bo->gem_handle, &timeout); if (ret != 0) { - result = vk_errorf(VK_ERROR_UNKNOWN, "execbuf2 failed: %m"); + /* We don't know the real error. */ + result = vk_errorf(VK_ERROR_OUT_OF_DEVICE_MEMORY, "execbuf2 failed: %m"); goto fail; } @@ -911,10 +967,8 @@ VkResult anv_AllocMemory( assert(pAllocInfo->sType == VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO); - if (pAllocInfo->memoryTypeIndex != 0) { - /* We support exactly one memory heap. */ - return vk_error(VK_ERROR_INVALID_VALUE); - } + /* We support exactly one memory heap. */ + assert(pAllocInfo->memoryTypeIndex == 0); /* FINISHME: Fail if allocation request exceeds heap size. */ @@ -937,7 +991,7 @@ VkResult anv_AllocMemory( return result; } -VkResult anv_FreeMemory( +void anv_FreeMemory( VkDevice _device, VkDeviceMemory _mem) { @@ -951,8 +1005,6 @@ VkResult anv_FreeMemory( anv_gem_close(device, mem->bo.gem_handle); anv_device_free(device, mem); - - return VK_SUCCESS; } VkResult anv_MapMemory( @@ -976,19 +1028,17 @@ VkResult anv_MapMemory( mem->map_size = size; *ppData = mem->map; - + return VK_SUCCESS; } -VkResult anv_UnmapMemory( +void anv_UnmapMemory( VkDevice _device, VkDeviceMemory _mem) { ANV_FROM_HANDLE(anv_device_memory, mem, _mem); anv_gem_munmap(mem->map, mem->map_size); - - return VK_SUCCESS; } VkResult anv_FlushMappedMemoryRanges( @@ -1195,7 +1245,7 @@ VkResult anv_CreateFence( return result; } -VkResult anv_DestroyFence( +void anv_DestroyFence( VkDevice _device, VkFence _fence) { @@ -1205,8 +1255,6 @@ VkResult anv_DestroyFence( anv_gem_munmap(fence->bo.map, fence->bo.size); anv_gem_close(device, fence->bo.gem_handle); anv_device_free(device, fence); - - return VK_SUCCESS; } VkResult anv_ResetFences( @@ -1251,18 +1299,31 @@ VkResult anv_WaitForFences( uint64_t timeout) { ANV_FROM_HANDLE(anv_device, device, _device); + + /* DRM_IOCTL_I915_GEM_WAIT uses a signed 64 bit timeout and is supposed + * to block indefinitely timeouts <= 0. Unfortunately, this was broken + * for a couple of kernel releases. Since there's no way to know + * whether or not the kernel we're using is one of the broken ones, the + * best we can do is to clamp the timeout to INT64_MAX. This limits the + * maximum timeout from 584 years to 292 years - likely not a big deal. + */ + if (timeout > INT64_MAX) + timeout = INT64_MAX; + int64_t t = timeout; - int ret; /* FIXME: handle !waitAll */ for (uint32_t i = 0; i < fenceCount; i++) { ANV_FROM_HANDLE(anv_fence, fence, pFences[i]); - ret = anv_gem_wait(device, fence->bo.gem_handle, &t); - if (ret == -1 && errno == ETIME) + int ret = anv_gem_wait(device, fence->bo.gem_handle, &t); + if (ret == -1 && errno == ETIME) { return VK_TIMEOUT; - else if (ret == -1) - return vk_errorf(VK_ERROR_UNKNOWN, "gem wait failed: %m"); + } else if (ret == -1) { + /* We don't know the real error. */ + return vk_errorf(VK_ERROR_OUT_OF_DEVICE_MEMORY, + "gem wait failed: %m"); + } } return VK_SUCCESS; @@ -1275,14 +1336,15 @@ VkResult anv_CreateSemaphore( const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore) { - stub_return(VK_UNSUPPORTED); + *pSemaphore = (VkSemaphore)1; + stub_return(VK_SUCCESS); } -VkResult anv_DestroySemaphore( +void anv_DestroySemaphore( VkDevice device, VkSemaphore semaphore) { - stub_return(VK_UNSUPPORTED); + stub(); } VkResult anv_QueueSignalSemaphore( @@ -1309,11 +1371,11 @@ VkResult anv_CreateEvent( stub_return(VK_UNSUPPORTED); } -VkResult anv_DestroyEvent( +void anv_DestroyEvent( VkDevice device, VkEvent event) { - stub_return(VK_UNSUPPORTED); + stub(); } VkResult anv_GetEventStatus( @@ -1363,7 +1425,7 @@ VkResult anv_CreateBuffer( return VK_SUCCESS; } -VkResult anv_DestroyBuffer( +void anv_DestroyBuffer( VkDevice _device, VkBuffer _buffer) { @@ -1371,70 +1433,47 @@ VkResult anv_DestroyBuffer( ANV_FROM_HANDLE(anv_buffer, buffer, _buffer); anv_device_free(device, buffer); - - return VK_SUCCESS; } void anv_fill_buffer_surface_state(struct anv_device *device, void *state, const struct anv_format *format, - uint32_t offset, uint32_t range) + uint32_t offset, uint32_t range, uint32_t stride) { switch (device->info.gen) { case 7: - gen7_fill_buffer_surface_state(state, format, offset, range); + if (device->info.is_haswell) + gen75_fill_buffer_surface_state(state, format, offset, range, stride); + else + gen7_fill_buffer_surface_state(state, format, offset, range, stride); break; case 8: - gen8_fill_buffer_surface_state(state, format, offset, range); + gen8_fill_buffer_surface_state(state, format, offset, range, stride); + break; + case 9: + gen9_fill_buffer_surface_state(state, format, offset, range, stride); break; default: unreachable("unsupported gen\n"); } } -VkResult -anv_buffer_view_create( - struct anv_device * device, - const VkBufferViewCreateInfo* pCreateInfo, - struct anv_buffer_view ** bview_out) +VkResult anv_CreateBufferView( + VkDevice _device, + const VkBufferViewCreateInfo* pCreateInfo, + VkBufferView* pView) { - ANV_FROM_HANDLE(anv_buffer, buffer, pCreateInfo->buffer); - struct anv_buffer_view *bview; - - assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO); - - bview = anv_device_alloc(device, sizeof(*bview), 8, - VK_SYSTEM_ALLOC_TYPE_API_OBJECT); - if (bview == NULL) - return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); - - *bview = (struct anv_buffer_view) { - .bo = buffer->bo, - .offset = buffer->offset + pCreateInfo->offset, - .surface_state = anv_state_pool_alloc(&device->surface_state_pool, 64, 64), - .format = anv_format_for_vk_format(pCreateInfo->format), - .range = pCreateInfo->range, - }; - - *bview_out = bview; - - return VK_SUCCESS; + stub_return(VK_UNSUPPORTED); } -VkResult anv_DestroyBufferView( +void anv_DestroyBufferView( VkDevice _device, VkBufferView _bview) { - ANV_FROM_HANDLE(anv_device, device, _device); - ANV_FROM_HANDLE(anv_buffer_view, bview, _bview); - - anv_state_pool_free(&device->surface_state_pool, bview->surface_state); - anv_device_free(device, bview); - - return VK_SUCCESS; + stub(); } -VkResult anv_DestroySampler( +void anv_DestroySampler( VkDevice _device, VkSampler _sampler) { @@ -1442,544 +1481,6 @@ VkResult anv_DestroySampler( ANV_FROM_HANDLE(anv_sampler, sampler, _sampler); anv_device_free(device, sampler); - - return VK_SUCCESS; -} - -// Descriptor set functions - -VkResult anv_CreateDescriptorSetLayout( - VkDevice _device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - VkDescriptorSetLayout* pSetLayout) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - struct anv_descriptor_set_layout *set_layout; - - assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO); - - uint32_t sampler_count[VK_SHADER_STAGE_NUM] = { 0, }; - uint32_t surface_count[VK_SHADER_STAGE_NUM] = { 0, }; - uint32_t num_dynamic_buffers = 0; - uint32_t count = 0; - VkShaderStageFlags stages = 0; - uint32_t s; - - for (uint32_t i = 0; i < pCreateInfo->count; i++) { - switch (pCreateInfo->pBinding[i].descriptorType) { - case VK_DESCRIPTOR_TYPE_SAMPLER: - case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: - for_each_bit(s, pCreateInfo->pBinding[i].stageFlags) - sampler_count[s] += pCreateInfo->pBinding[i].arraySize; - break; - default: - break; - } - - switch (pCreateInfo->pBinding[i].descriptorType) { - case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: - case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: - case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: - case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: - case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: - case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: - case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: - case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: - case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: - case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: - for_each_bit(s, pCreateInfo->pBinding[i].stageFlags) - surface_count[s] += pCreateInfo->pBinding[i].arraySize; - break; - default: - break; - } - - switch (pCreateInfo->pBinding[i].descriptorType) { - case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: - case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: - num_dynamic_buffers += pCreateInfo->pBinding[i].arraySize; - break; - default: - break; - } - - stages |= pCreateInfo->pBinding[i].stageFlags; - count += pCreateInfo->pBinding[i].arraySize; - } - - uint32_t sampler_total = 0; - uint32_t surface_total = 0; - for (uint32_t s = 0; s < VK_SHADER_STAGE_NUM; s++) { - sampler_total += sampler_count[s]; - surface_total += surface_count[s]; - } - - size_t size = sizeof(*set_layout) + - (sampler_total + surface_total) * sizeof(set_layout->entries[0]); - set_layout = anv_device_alloc(device, size, 8, - VK_SYSTEM_ALLOC_TYPE_API_OBJECT); - if (!set_layout) - return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); - - set_layout->num_dynamic_buffers = num_dynamic_buffers; - set_layout->count = count; - set_layout->shader_stages = stages; - - struct anv_descriptor_slot *p = set_layout->entries; - struct anv_descriptor_slot *sampler[VK_SHADER_STAGE_NUM]; - struct anv_descriptor_slot *surface[VK_SHADER_STAGE_NUM]; - for (uint32_t s = 0; s < VK_SHADER_STAGE_NUM; s++) { - set_layout->stage[s].surface_count = surface_count[s]; - set_layout->stage[s].surface_start = surface[s] = p; - p += surface_count[s]; - set_layout->stage[s].sampler_count = sampler_count[s]; - set_layout->stage[s].sampler_start = sampler[s] = p; - p += sampler_count[s]; - } - - uint32_t descriptor = 0; - int8_t dynamic_slot = 0; - bool is_dynamic; - for (uint32_t i = 0; i < pCreateInfo->count; i++) { - switch (pCreateInfo->pBinding[i].descriptorType) { - case VK_DESCRIPTOR_TYPE_SAMPLER: - case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: - for_each_bit(s, pCreateInfo->pBinding[i].stageFlags) - for (uint32_t j = 0; j < pCreateInfo->pBinding[i].arraySize; j++) { - sampler[s]->index = descriptor + j; - sampler[s]->dynamic_slot = -1; - sampler[s]++; - } - break; - default: - break; - } - - switch (pCreateInfo->pBinding[i].descriptorType) { - case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: - case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: - is_dynamic = true; - break; - default: - is_dynamic = false; - break; - } - - switch (pCreateInfo->pBinding[i].descriptorType) { - case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: - case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: - case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: - case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: - case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: - case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: - case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: - case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: - case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: - case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: - for_each_bit(s, pCreateInfo->pBinding[i].stageFlags) - for (uint32_t j = 0; j < pCreateInfo->pBinding[i].arraySize; j++) { - surface[s]->index = descriptor + j; - if (is_dynamic) - surface[s]->dynamic_slot = dynamic_slot + j; - else - surface[s]->dynamic_slot = -1; - surface[s]++; - } - break; - default: - break; - } - - if (is_dynamic) - dynamic_slot += pCreateInfo->pBinding[i].arraySize; - - descriptor += pCreateInfo->pBinding[i].arraySize; - } - - *pSetLayout = anv_descriptor_set_layout_to_handle(set_layout); - - return VK_SUCCESS; -} - -VkResult anv_DestroyDescriptorSetLayout( - VkDevice _device, - VkDescriptorSetLayout _set_layout) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - ANV_FROM_HANDLE(anv_descriptor_set_layout, set_layout, _set_layout); - - anv_device_free(device, set_layout); - - return VK_SUCCESS; -} - -VkResult anv_CreateDescriptorPool( - VkDevice device, - VkDescriptorPoolUsage poolUsage, - uint32_t maxSets, - const VkDescriptorPoolCreateInfo* pCreateInfo, - VkDescriptorPool* pDescriptorPool) -{ - anv_finishme("VkDescriptorPool is a stub"); - pDescriptorPool->handle = 1; - return VK_SUCCESS; -} - -VkResult anv_DestroyDescriptorPool( - VkDevice _device, - VkDescriptorPool _pool) -{ - anv_finishme("VkDescriptorPool is a stub: free the pool's descriptor sets"); - return VK_SUCCESS; -} - -VkResult anv_ResetDescriptorPool( - VkDevice device, - VkDescriptorPool descriptorPool) -{ - anv_finishme("VkDescriptorPool is a stub: free the pool's descriptor sets"); - return VK_SUCCESS; -} - -VkResult -anv_descriptor_set_create(struct anv_device *device, - const struct anv_descriptor_set_layout *layout, - struct anv_descriptor_set **out_set) -{ - struct anv_descriptor_set *set; - size_t size = sizeof(*set) + layout->count * sizeof(set->descriptors[0]); - - set = anv_device_alloc(device, size, 8, VK_SYSTEM_ALLOC_TYPE_API_OBJECT); - if (!set) - return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); - - /* A descriptor set may not be 100% filled. Clear the set so we can can - * later detect holes in it. - */ - memset(set, 0, size); - - *out_set = set; - - return VK_SUCCESS; -} - -void -anv_descriptor_set_destroy(struct anv_device *device, - struct anv_descriptor_set *set) -{ - anv_device_free(device, set); -} - -VkResult anv_AllocDescriptorSets( - VkDevice _device, - VkDescriptorPool descriptorPool, - VkDescriptorSetUsage setUsage, - uint32_t count, - const VkDescriptorSetLayout* pSetLayouts, - VkDescriptorSet* pDescriptorSets, - uint32_t* pCount) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - - VkResult result; - struct anv_descriptor_set *set; - - for (uint32_t i = 0; i < count; i++) { - ANV_FROM_HANDLE(anv_descriptor_set_layout, layout, pSetLayouts[i]); - - result = anv_descriptor_set_create(device, layout, &set); - if (result != VK_SUCCESS) { - *pCount = i; - return result; - } - - pDescriptorSets[i] = anv_descriptor_set_to_handle(set); - } - - *pCount = count; - - return VK_SUCCESS; -} - -VkResult anv_FreeDescriptorSets( - VkDevice _device, - VkDescriptorPool descriptorPool, - uint32_t count, - const VkDescriptorSet* pDescriptorSets) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - - for (uint32_t i = 0; i < count; i++) { - ANV_FROM_HANDLE(anv_descriptor_set, set, pDescriptorSets[i]); - - anv_descriptor_set_destroy(device, set); - } - - return VK_SUCCESS; -} - -VkResult anv_UpdateDescriptorSets( - VkDevice device, - uint32_t writeCount, - const VkWriteDescriptorSet* pDescriptorWrites, - uint32_t copyCount, - const VkCopyDescriptorSet* pDescriptorCopies) -{ - for (uint32_t i = 0; i < writeCount; i++) { - const VkWriteDescriptorSet *write = &pDescriptorWrites[i]; - ANV_FROM_HANDLE(anv_descriptor_set, set, write->destSet); - - switch (write->descriptorType) { - case VK_DESCRIPTOR_TYPE_SAMPLER: - case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: - for (uint32_t j = 0; j < write->count; j++) { - ANV_FROM_HANDLE(anv_sampler, sampler, - write->pDescriptors[j].sampler); - - set->descriptors[write->destBinding + j] = (struct anv_descriptor) { - .type = ANV_DESCRIPTOR_TYPE_SAMPLER, - .sampler = sampler, - }; - } - - if (write->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER) - break; - - /* fallthrough */ - - case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: - case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: - for (uint32_t j = 0; j < write->count; j++) { - ANV_FROM_HANDLE(anv_image_view, iview, - write->pDescriptors[j].imageView); - - set->descriptors[write->destBinding + j] = (struct anv_descriptor) { - .type = ANV_DESCRIPTOR_TYPE_IMAGE_VIEW, - .image_view = iview, - }; - } - break; - - case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: - case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: - anv_finishme("texel buffers not implemented"); - break; - - case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: - anv_finishme("input attachments not implemented"); - break; - - case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: - case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: - case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: - case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: - for (uint32_t j = 0; j < write->count; j++) { - ANV_FROM_HANDLE(anv_buffer_view, bview, - write->pDescriptors[j].bufferView); - - set->descriptors[write->destBinding + j] = (struct anv_descriptor) { - .type = ANV_DESCRIPTOR_TYPE_BUFFER_VIEW, - .buffer_view = bview, - }; - } - - default: - break; - } - } - - for (uint32_t i = 0; i < copyCount; i++) { - const VkCopyDescriptorSet *copy = &pDescriptorCopies[i]; - ANV_FROM_HANDLE(anv_descriptor_set, src, copy->destSet); - ANV_FROM_HANDLE(anv_descriptor_set, dest, copy->destSet); - for (uint32_t j = 0; j < copy->count; j++) { - dest->descriptors[copy->destBinding + j] = - src->descriptors[copy->srcBinding + j]; - } - } - - return VK_SUCCESS; -} - -// State object functions - -static inline int64_t -clamp_int64(int64_t x, int64_t min, int64_t max) -{ - if (x < min) - return min; - else if (x < max) - return x; - else - return max; -} - -VkResult anv_CreateDynamicViewportState( - VkDevice _device, - const VkDynamicViewportStateCreateInfo* pCreateInfo, - VkDynamicViewportState* pState) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - struct anv_dynamic_vp_state *state; - - assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO); - - state = anv_device_alloc(device, sizeof(*state), 8, - VK_SYSTEM_ALLOC_TYPE_API_OBJECT); - if (state == NULL) - return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); - - unsigned count = pCreateInfo->viewportAndScissorCount; - state->sf_clip_vp = anv_state_pool_alloc(&device->dynamic_state_pool, - count * 64, 64); - state->cc_vp = anv_state_pool_alloc(&device->dynamic_state_pool, - count * 8, 32); - state->scissor = anv_state_pool_alloc(&device->dynamic_state_pool, - count * 32, 32); - - for (uint32_t i = 0; i < pCreateInfo->viewportAndScissorCount; i++) { - const VkViewport *vp = &pCreateInfo->pViewports[i]; - const VkRect2D *s = &pCreateInfo->pScissors[i]; - - /* The gen7 state struct has just the matrix and guardband fields, the - * gen8 struct adds the min/max viewport fields. */ - struct GEN8_SF_CLIP_VIEWPORT sf_clip_viewport = { - .ViewportMatrixElementm00 = vp->width / 2, - .ViewportMatrixElementm11 = vp->height / 2, - .ViewportMatrixElementm22 = (vp->maxDepth - vp->minDepth) / 2, - .ViewportMatrixElementm30 = vp->originX + vp->width / 2, - .ViewportMatrixElementm31 = vp->originY + vp->height / 2, - .ViewportMatrixElementm32 = (vp->maxDepth + vp->minDepth) / 2, - .XMinClipGuardband = -1.0f, - .XMaxClipGuardband = 1.0f, - .YMinClipGuardband = -1.0f, - .YMaxClipGuardband = 1.0f, - .XMinViewPort = vp->originX, - .XMaxViewPort = vp->originX + vp->width - 1, - .YMinViewPort = vp->originY, - .YMaxViewPort = vp->originY + vp->height - 1, - }; - - struct GEN7_CC_VIEWPORT cc_viewport = { - .MinimumDepth = vp->minDepth, - .MaximumDepth = vp->maxDepth - }; - - /* Since xmax and ymax are inclusive, we have to have xmax < xmin or - * ymax < ymin for empty clips. In case clip x, y, width height are all - * 0, the clamps below produce 0 for xmin, ymin, xmax, ymax, which isn't - * what we want. Just special case empty clips and produce a canonical - * empty clip. */ - static const struct GEN7_SCISSOR_RECT empty_scissor = { - .ScissorRectangleYMin = 1, - .ScissorRectangleXMin = 1, - .ScissorRectangleYMax = 0, - .ScissorRectangleXMax = 0 - }; - - const int max = 0xffff; - struct GEN7_SCISSOR_RECT scissor = { - /* Do this math using int64_t so overflow gets clamped correctly. */ - .ScissorRectangleYMin = clamp_int64(s->offset.y, 0, max), - .ScissorRectangleXMin = clamp_int64(s->offset.x, 0, max), - .ScissorRectangleYMax = clamp_int64((uint64_t) s->offset.y + s->extent.height - 1, 0, max), - .ScissorRectangleXMax = clamp_int64((uint64_t) s->offset.x + s->extent.width - 1, 0, max) - }; - - GEN8_SF_CLIP_VIEWPORT_pack(NULL, state->sf_clip_vp.map + i * 64, &sf_clip_viewport); - GEN7_CC_VIEWPORT_pack(NULL, state->cc_vp.map + i * 32, &cc_viewport); - - if (s->extent.width <= 0 || s->extent.height <= 0) { - GEN7_SCISSOR_RECT_pack(NULL, state->scissor.map + i * 32, &empty_scissor); - } else { - GEN7_SCISSOR_RECT_pack(NULL, state->scissor.map + i * 32, &scissor); - } - } - - *pState = anv_dynamic_vp_state_to_handle(state); - - return VK_SUCCESS; -} - -VkResult anv_DestroyDynamicViewportState( - VkDevice _device, - VkDynamicViewportState _vp_state) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - ANV_FROM_HANDLE(anv_dynamic_vp_state, vp_state, _vp_state); - - anv_state_pool_free(&device->dynamic_state_pool, vp_state->sf_clip_vp); - anv_state_pool_free(&device->dynamic_state_pool, vp_state->cc_vp); - anv_state_pool_free(&device->dynamic_state_pool, vp_state->scissor); - - anv_device_free(device, vp_state); - - return VK_SUCCESS; -} - -VkResult anv_DestroyDynamicRasterState( - VkDevice _device, - VkDynamicRasterState _rs_state) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - ANV_FROM_HANDLE(anv_dynamic_rs_state, rs_state, _rs_state); - - anv_device_free(device, rs_state); - - return VK_SUCCESS; -} - -VkResult anv_CreateDynamicColorBlendState( - VkDevice _device, - const VkDynamicColorBlendStateCreateInfo* pCreateInfo, - VkDynamicColorBlendState* pState) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - struct anv_dynamic_cb_state *state; - - assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DYNAMIC_COLOR_BLEND_STATE_CREATE_INFO); - - state = anv_device_alloc(device, sizeof(*state), 8, - VK_SYSTEM_ALLOC_TYPE_API_OBJECT); - if (state == NULL) - return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); - - struct GEN7_COLOR_CALC_STATE color_calc_state = { - .BlendConstantColorRed = pCreateInfo->blendConst[0], - .BlendConstantColorGreen = pCreateInfo->blendConst[1], - .BlendConstantColorBlue = pCreateInfo->blendConst[2], - .BlendConstantColorAlpha = pCreateInfo->blendConst[3] - }; - - GEN7_COLOR_CALC_STATE_pack(NULL, state->color_calc_state, &color_calc_state); - - *pState = anv_dynamic_cb_state_to_handle(state); - - return VK_SUCCESS; -} - -VkResult anv_DestroyDynamicColorBlendState( - VkDevice _device, - VkDynamicColorBlendState _cb_state) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - ANV_FROM_HANDLE(anv_dynamic_cb_state, cb_state, _cb_state); - - anv_device_free(device, cb_state); - - return VK_SUCCESS; -} - -VkResult anv_DestroyDynamicDepthStencilState( - VkDevice _device, - VkDynamicDepthStencilState _ds_state) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - ANV_FROM_HANDLE(anv_dynamic_ds_state, ds_state, _ds_state); - - anv_device_free(device, ds_state); - - return VK_SUCCESS; } VkResult anv_CreateFramebuffer( @@ -1993,7 +1494,7 @@ VkResult anv_CreateFramebuffer( assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO); size_t size = sizeof(*framebuffer) + - sizeof(struct anv_attachment_view *) * pCreateInfo->attachmentCount; + sizeof(struct anv_image_view *) * pCreateInfo->attachmentCount; framebuffer = anv_device_alloc(device, size, 8, VK_SYSTEM_ALLOC_TYPE_API_OBJECT); if (framebuffer == NULL) @@ -2001,187 +1502,27 @@ VkResult anv_CreateFramebuffer( framebuffer->attachment_count = pCreateInfo->attachmentCount; for (uint32_t i = 0; i < pCreateInfo->attachmentCount; i++) { - ANV_FROM_HANDLE(anv_attachment_view, aview, - pCreateInfo->pAttachments[i].view); - - framebuffer->attachments[i] = aview; + VkImageView _iview = pCreateInfo->pAttachments[i]; + framebuffer->attachments[i] = anv_image_view_from_handle(_iview); } framebuffer->width = pCreateInfo->width; framebuffer->height = pCreateInfo->height; framebuffer->layers = pCreateInfo->layers; - anv_CreateDynamicViewportState(anv_device_to_handle(device), - &(VkDynamicViewportStateCreateInfo) { - .sType = VK_STRUCTURE_TYPE_DYNAMIC_VIEWPORT_STATE_CREATE_INFO, - .viewportAndScissorCount = 1, - .pViewports = (VkViewport[]) { - { - .originX = 0, - .originY = 0, - .width = pCreateInfo->width, - .height = pCreateInfo->height, - .minDepth = 0, - .maxDepth = 1 - }, - }, - .pScissors = (VkRect2D[]) { - { { 0, 0 }, - { pCreateInfo->width, pCreateInfo->height } }, - } - }, - &framebuffer->vp_state); - *pFramebuffer = anv_framebuffer_to_handle(framebuffer); return VK_SUCCESS; } -VkResult anv_DestroyFramebuffer( +void anv_DestroyFramebuffer( VkDevice _device, VkFramebuffer _fb) { ANV_FROM_HANDLE(anv_device, device, _device); ANV_FROM_HANDLE(anv_framebuffer, fb, _fb); - anv_DestroyDynamicViewportState(anv_device_to_handle(device), - fb->vp_state); anv_device_free(device, fb); - - return VK_SUCCESS; -} - -VkResult anv_CreateRenderPass( - VkDevice _device, - const VkRenderPassCreateInfo* pCreateInfo, - VkRenderPass* pRenderPass) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - struct anv_render_pass *pass; - size_t size; - size_t attachments_offset; - - assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO); - - size = sizeof(*pass); - size += pCreateInfo->subpassCount * sizeof(pass->subpasses[0]); - attachments_offset = size; - size += pCreateInfo->attachmentCount * sizeof(pass->attachments[0]); - - pass = anv_device_alloc(device, size, 8, - VK_SYSTEM_ALLOC_TYPE_API_OBJECT); - if (pass == NULL) - return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); - - /* Clear the subpasses along with the parent pass. This required because - * each array member of anv_subpass must be a valid pointer if not NULL. - */ - memset(pass, 0, size); - pass->attachment_count = pCreateInfo->attachmentCount; - pass->subpass_count = pCreateInfo->subpassCount; - pass->attachments = (void *) pass + attachments_offset; - - for (uint32_t i = 0; i < pCreateInfo->attachmentCount; i++) { - struct anv_render_pass_attachment *att = &pass->attachments[i]; - - att->format = anv_format_for_vk_format(pCreateInfo->pAttachments[i].format); - att->samples = pCreateInfo->pAttachments[i].samples; - att->load_op = pCreateInfo->pAttachments[i].loadOp; - att->stencil_load_op = pCreateInfo->pAttachments[i].stencilLoadOp; - // att->store_op = pCreateInfo->pAttachments[i].storeOp; - // att->stencil_store_op = pCreateInfo->pAttachments[i].stencilStoreOp; - - if (att->load_op == VK_ATTACHMENT_LOAD_OP_CLEAR) { - if (anv_format_is_color(att->format)) { - ++pass->num_color_clear_attachments; - } else if (att->format->depth_format) { - pass->has_depth_clear_attachment = true; - } - } else if (att->stencil_load_op == VK_ATTACHMENT_LOAD_OP_CLEAR) { - assert(att->format->has_stencil); - pass->has_stencil_clear_attachment = true; - } - } - - for (uint32_t i = 0; i < pCreateInfo->subpassCount; i++) { - const VkSubpassDescription *desc = &pCreateInfo->pSubpasses[i]; - struct anv_subpass *subpass = &pass->subpasses[i]; - - subpass->input_count = desc->inputCount; - subpass->color_count = desc->colorCount; - - if (desc->inputCount > 0) { - subpass->input_attachments = - anv_device_alloc(device, desc->inputCount * sizeof(uint32_t), - 8, VK_SYSTEM_ALLOC_TYPE_API_OBJECT); - - for (uint32_t j = 0; j < desc->inputCount; j++) { - subpass->input_attachments[j] - = desc->inputAttachments[j].attachment; - } - } - - if (desc->colorCount > 0) { - subpass->color_attachments = - anv_device_alloc(device, desc->colorCount * sizeof(uint32_t), - 8, VK_SYSTEM_ALLOC_TYPE_API_OBJECT); - - for (uint32_t j = 0; j < desc->colorCount; j++) { - subpass->color_attachments[j] - = desc->colorAttachments[j].attachment; - } - } - - if (desc->resolveAttachments) { - subpass->resolve_attachments = - anv_device_alloc(device, desc->colorCount * sizeof(uint32_t), - 8, VK_SYSTEM_ALLOC_TYPE_API_OBJECT); - - for (uint32_t j = 0; j < desc->colorCount; j++) { - subpass->resolve_attachments[j] - = desc->resolveAttachments[j].attachment; - } - } - - subpass->depth_stencil_attachment = desc->depthStencilAttachment.attachment; - } - - *pRenderPass = anv_render_pass_to_handle(pass); - - return VK_SUCCESS; -} - -VkResult anv_DestroyRenderPass( - VkDevice _device, - VkRenderPass _pass) -{ - ANV_FROM_HANDLE(anv_device, device, _device); - ANV_FROM_HANDLE(anv_render_pass, pass, _pass); - - for (uint32_t i = 0; i < pass->subpass_count; i++) { - /* In VkSubpassCreateInfo, each of the attachment arrays may be null. - * Don't free the null arrays. - */ - struct anv_subpass *subpass = &pass->subpasses[i]; - - anv_device_free(device, subpass->input_attachments); - anv_device_free(device, subpass->color_attachments); - anv_device_free(device, subpass->resolve_attachments); - } - - anv_device_free(device, pass); - - return VK_SUCCESS; -} - -VkResult anv_GetRenderAreaGranularity( - VkDevice device, - VkRenderPass renderPass, - VkExtent2D* pGranularity) -{ - *pGranularity = (VkExtent2D) { 1, 1 }; - - return VK_SUCCESS; } void vkCmdDbgMarkerBegin(