#include "compiler/glsl_types.h"
#include "util/debug.h"
#include "util/disk_cache.h"
+#include "util/u_atomic.h"
#include "vk_format.h"
#include "vk_util.h"
#include "drm-uapi/msm_drm.h"
+/* for fd_get_driver/device_uuid() */
+#include "freedreno/common/freedreno_uuid.h"
+
+static void
+tu_semaphore_remove_temp(struct tu_device *device,
+ struct tu_semaphore *sem);
+
static int
tu_device_get_cache_uuid(uint16_t family, void *uuid)
{
return 0;
}
-static void
-tu_get_driver_uuid(void *uuid)
-{
- memset(uuid, 0, VK_UUID_SIZE);
- snprintf(uuid, VK_UUID_SIZE, "freedreno");
-}
-
-static void
-tu_get_device_uuid(void *uuid)
-{
- memset(uuid, 0, VK_UUID_SIZE);
-}
-
static VkResult
tu_bo_init(struct tu_device *dev,
struct tu_bo *bo,
return result;
}
+ device->msm_major_version = version->version_major;
+ device->msm_minor_version = version->version_minor;
+
drmFreeVersion(version);
if (instance->debug_flags & TU_DEBUG_STARTUP)
switch (device->gpu_id) {
case 618:
- device->magic.RB_UNKNOWN_8E04_blit = 0x00100000;
device->ccu_offset_gmem = 0x7c000; /* 0x7e000 in some cases? */
device->ccu_offset_bypass = 0x10000;
+ device->tile_align_w = 64;
device->magic.PC_UNKNOWN_9805 = 0x0;
device->magic.SP_UNKNOWN_A0F8 = 0x0;
break;
case 630:
case 640:
- device->magic.RB_UNKNOWN_8E04_blit = 0x01000000;
device->ccu_offset_gmem = 0xf8000;
device->ccu_offset_bypass = 0x20000;
+ device->tile_align_w = 64;
device->magic.PC_UNKNOWN_9805 = 0x1;
device->magic.SP_UNKNOWN_A0F8 = 0x1;
break;
+ case 650:
+ device->ccu_offset_gmem = 0x114000;
+ device->ccu_offset_bypass = 0x30000;
+ device->tile_align_w = 96;
+ device->magic.PC_UNKNOWN_9805 = 0x2;
+ device->magic.SP_UNKNOWN_A0F8 = 0x2;
+ break;
default:
result = vk_errorf(instance, VK_ERROR_INITIALIZATION_FAILED,
"device %s is unsupported", device->name);
fprintf(stderr, "WARNING: tu is not a conformant vulkan implementation, "
"testing use only.\n");
- tu_get_driver_uuid(&device->device_uuid);
- tu_get_device_uuid(&device->device_uuid);
+ fd_get_driver_uuid(device->driver_uuid);
+ fd_get_device_uuid(device->device_uuid, device->gpu_id);
- tu_fill_device_extension_table(device, &device->supported_extensions);
+ tu_physical_device_get_supported_extensions(device, &device->supported_extensions);
if (result != VK_SUCCESS) {
vk_error(instance, result);
{ "nobin", TU_DEBUG_NOBIN },
{ "sysmem", TU_DEBUG_SYSMEM },
{ "forcebin", TU_DEBUG_FORCEBIN },
+ { "noubwc", TU_DEBUG_NOUBWC },
{ NULL, 0 }
};
const char *ext_name = pCreateInfo->ppEnabledExtensionNames[i];
int index = tu_get_instance_extension_index(ext_name);
- if (index < 0 || !tu_supported_instance_extensions.extensions[index]) {
+ if (index < 0 || !tu_instance_extensions_supported.extensions[index]) {
vk_free2(&default_alloc, pAllocator, instance);
return vk_error(instance, VK_ERROR_EXTENSION_NOT_PRESENT);
}
max_devices = drmGetDevices2(0, devices, ARRAY_SIZE(devices));
- if (instance->debug_flags & TU_DEBUG_STARTUP)
- tu_logi("Found %d drm nodes", max_devices);
+ if (instance->debug_flags & TU_DEBUG_STARTUP) {
+ if (max_devices < 0)
+ tu_logi("drmGetDevices2 returned error: %s\n", strerror(max_devices));
+ else
+ tu_logi("Found %d drm nodes", max_devices);
+ }
if (max_devices < 1)
return vk_error(instance, VK_ERROR_INCOMPATIBLE_DRIVER);
memset(pFeatures, 0, sizeof(*pFeatures));
*pFeatures = (VkPhysicalDeviceFeatures) {
- .robustBufferAccess = false,
+ .robustBufferAccess = true,
.fullDrawIndexUint32 = true,
.imageCubeArray = true,
.independentBlend = true,
.geometryShader = true,
- .tessellationShader = false,
+ .tessellationShader = true,
.sampleRateShading = true,
.dualSrcBlend = true,
.logicOp = true,
- .multiDrawIndirect = false,
- .drawIndirectFirstInstance = false,
+ .multiDrawIndirect = true,
+ .drawIndirectFirstInstance = true,
.depthClamp = true,
- .depthBiasClamp = false,
- .fillModeNonSolid = false,
- .depthBounds = false,
+ .depthBiasClamp = true,
+ .fillModeNonSolid = true,
+ .depthBounds = true,
.wideLines = false,
- .largePoints = false,
- .alphaToOne = false,
+ .largePoints = true,
+ .alphaToOne = true,
.multiViewport = false,
.samplerAnisotropy = true,
.textureCompressionETC2 = true,
vk_foreach_struct(ext, pFeatures->pNext)
{
switch (ext->sType) {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: {
+ VkPhysicalDeviceVulkan11Features *features = (void *) ext;
+ features->storageBuffer16BitAccess = false;
+ features->uniformAndStorageBuffer16BitAccess = false;
+ features->storagePushConstant16 = false;
+ features->storageInputOutput16 = false;
+ features->multiview = false;
+ features->multiviewGeometryShader = false;
+ features->multiviewTessellationShader = false;
+ features->variablePointersStorageBuffer = false;
+ features->variablePointers = false;
+ features->protectedMemory = false;
+ features->samplerYcbcrConversion = true;
+ features->shaderDrawParameters = true;
+ break;
+ }
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: {
VkPhysicalDeviceVariablePointersFeatures *features = (void *) ext;
features->variablePointersStorageBuffer = false;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: {
VkPhysicalDeviceShaderDrawParametersFeatures *features =
(VkPhysicalDeviceShaderDrawParametersFeatures *) ext;
- features->shaderDrawParameters = false;
+ features->shaderDrawParameters = true;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: {
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
VkPhysicalDeviceSamplerYcbcrConversionFeatures *features =
(VkPhysicalDeviceSamplerYcbcrConversionFeatures *) ext;
- features->samplerYcbcrConversion = false;
+ features->samplerYcbcrConversion = true;
break;
}
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: {
features->geometryStreams = false;
break;
}
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: {
+ VkPhysicalDeviceIndexTypeUint8FeaturesEXT *features =
+ (VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)ext;
+ features->indexTypeUint8 = true;
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: {
+ VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *features =
+ (VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *)ext;
+ features->vertexAttributeInstanceRateDivisor = true;
+ features->vertexAttributeInstanceRateZeroDivisor = true;
+ break;
+ }
default:
break;
}
.maxComputeWorkGroupInvocations = 2048,
.maxComputeWorkGroupSize = { 2048, 2048, 2048 },
.subPixelPrecisionBits = 8,
- .subTexelPrecisionBits = 4 /* FIXME */,
- .mipmapPrecisionBits = 4 /* FIXME */,
+ .subTexelPrecisionBits = 8,
+ .mipmapPrecisionBits = 8,
.maxDrawIndexedIndexValue = UINT32_MAX,
.maxDrawIndirectCount = UINT32_MAX,
- .maxSamplerLodBias = 16,
+ .maxSamplerLodBias = 4095.0 / 256.0, /* [-16, 15.99609375] */
.maxSamplerAnisotropy = 16,
.maxViewports = MAX_VIEWPORTS,
.maxViewportDimensions = { (1 << 14), (1 << 14) },
.minTexelBufferOffsetAlignment = 64,
.minUniformBufferOffsetAlignment = 64,
.minStorageBufferOffsetAlignment = 64,
- .minTexelOffset = -32,
- .maxTexelOffset = 31,
+ .minTexelOffset = -16,
+ .maxTexelOffset = 15,
.minTexelGatherOffset = -32,
.maxTexelGatherOffset = 31,
- .minInterpolationOffset = -2,
- .maxInterpolationOffset = 2,
- .subPixelInterpolationOffsetBits = 8,
+ .minInterpolationOffset = -0.5,
+ .maxInterpolationOffset = 0.4375,
+ .subPixelInterpolationOffsetBits = 4,
.maxFramebufferWidth = (1 << 14),
.maxFramebufferHeight = (1 << 14),
.maxFramebufferLayers = (1 << 10),
.maxCullDistances = 8,
.maxCombinedClipAndCullDistances = 8,
.discreteQueuePriorities = 1,
- .pointSizeRange = { 0.125, 255.875 },
+ .pointSizeRange = { 1, 4092 },
.lineWidthRange = { 0.0, 7.9921875 },
- .pointSizeGranularity = (1.0 / 8.0),
+ .pointSizeGranularity = 0.0625,
.lineWidthGranularity = (1.0 / 128.0),
.strictLines = false, /* FINISHME */
.standardSampleLocations = true,
properties->maxTransformFeedbackStreamDataSize = 512;
properties->maxTransformFeedbackBufferDataSize = 512;
properties->maxTransformFeedbackBufferDataStride = 512;
- /* TODO: enable xfb query */
- properties->transformFeedbackQueries = false;
+ properties->transformFeedbackQueries = true;
properties->transformFeedbackStreamsLinesTriangles = false;
properties->transformFeedbackRasterizationStreamSelect = false;
properties->transformFeedbackDraw = true;
properties->filterMinmaxSingleComponentFormats = true;
break;
}
-
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: {
+ VkPhysicalDeviceSubgroupProperties *properties =
+ (VkPhysicalDeviceSubgroupProperties *)ext;
+ properties->subgroupSize = 64;
+ properties->supportedStages = VK_SHADER_STAGE_COMPUTE_BIT;
+ properties->supportedOperations = VK_SUBGROUP_FEATURE_BASIC_BIT |
+ VK_SUBGROUP_FEATURE_VOTE_BIT;
+ properties->quadOperationsInAllStages = false;
+ break;
+ }
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
+ VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *props =
+ (VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)ext;
+ props->maxVertexAttribDivisor = UINT32_MAX;
+ break;
+ }
default:
break;
}
device->_loader_data.loaderMagic = ICD_LOADER_MAGIC;
device->instance = physical_device->instance;
device->physical_device = physical_device;
+ device->_lost = false;
if (pAllocator)
device->alloc = *pAllocator;
if (!device->compiler)
goto fail_queues;
-#define VSC_DATA_SIZE(pitch) ((pitch) * 32 + 0x100) /* extra size to store VSC_SIZE */
-#define VSC_DATA2_SIZE(pitch) ((pitch) * 32)
+#define VSC_DRAW_STRM_SIZE(pitch) ((pitch) * 32 + 0x100) /* extra size to store VSC_SIZE */
+#define VSC_PRIM_STRM_SIZE(pitch) ((pitch) * 32)
- device->vsc_data_pitch = 0x440 * 4;
- device->vsc_data2_pitch = 0x1040 * 4;
+ device->vsc_draw_strm_pitch = 0x440 * 4;
+ device->vsc_prim_strm_pitch = 0x1040 * 4;
- result = tu_bo_init_new(device, &device->vsc_data, VSC_DATA_SIZE(device->vsc_data_pitch));
+ result = tu_bo_init_new(device, &device->vsc_draw_strm, VSC_DRAW_STRM_SIZE(device->vsc_draw_strm_pitch));
if (result != VK_SUCCESS)
goto fail_vsc_data;
- result = tu_bo_init_new(device, &device->vsc_data2, VSC_DATA2_SIZE(device->vsc_data2_pitch));
+ result = tu_bo_init_new(device, &device->vsc_prim_strm, VSC_PRIM_STRM_SIZE(device->vsc_prim_strm_pitch));
if (result != VK_SUCCESS)
goto fail_vsc_data2;
device->mem_cache = tu_pipeline_cache_from_handle(pc);
+ for (unsigned i = 0; i < ARRAY_SIZE(device->scratch_bos); i++)
+ mtx_init(&device->scratch_bos[i].construct_mtx, mtx_plain);
+
*pDevice = tu_device_to_handle(device);
return VK_SUCCESS;
tu_bo_finish(device, &device->border_color);
fail_border_color:
- tu_bo_finish(device, &device->vsc_data2);
+ tu_bo_finish(device, &device->vsc_prim_strm);
fail_vsc_data2:
- tu_bo_finish(device, &device->vsc_data);
+ tu_bo_finish(device, &device->vsc_draw_strm);
fail_vsc_data:
ralloc_free(device->compiler);
if (!device)
return;
- tu_bo_finish(device, &device->vsc_data);
- tu_bo_finish(device, &device->vsc_data2);
+ tu_bo_finish(device, &device->vsc_draw_strm);
+ tu_bo_finish(device, &device->vsc_prim_strm);
for (unsigned i = 0; i < TU_MAX_QUEUE_FAMILIES; i++) {
for (unsigned q = 0; q < device->queue_count[i]; q++)
vk_free(&device->alloc, device->queues[i]);
}
- /* the compiler does not use pAllocator */
- ralloc_free(device->compiler);
+ for (unsigned i = 0; i < ARRAY_SIZE(device->scratch_bos); i++) {
+ if (device->scratch_bos[i].initialized)
+ tu_bo_finish(device, &device->scratch_bos[i].bo);
+ }
+
+ ir3_compiler_destroy(device->compiler);
VkPipelineCache pc = tu_pipeline_cache_to_handle(device->mem_cache);
tu_DestroyPipelineCache(tu_device_to_handle(device), pc, NULL);
vk_free(&device->alloc, device);
}
+VkResult
+_tu_device_set_lost(struct tu_device *device,
+ const char *file, int line,
+ const char *msg, ...)
+{
+ /* Set the flag indicating that waits should return in finite time even
+ * after device loss.
+ */
+ p_atomic_inc(&device->_lost);
+
+ /* TODO: Report the log message through VkDebugReportCallbackEXT instead */
+ fprintf(stderr, "%s:%d: ", file, line);
+ va_list ap;
+ va_start(ap, msg);
+ vfprintf(stderr, msg, ap);
+ va_end(ap);
+
+ if (env_var_as_boolean("TU_ABORT_ON_DEVICE_LOSS", false))
+ abort();
+
+ return VK_ERROR_DEVICE_LOST;
+}
+
+VkResult
+tu_get_scratch_bo(struct tu_device *dev, uint64_t size, struct tu_bo **bo)
+{
+ unsigned size_log2 = MAX2(util_logbase2_ceil64(size), MIN_SCRATCH_BO_SIZE_LOG2);
+ unsigned index = size_log2 - MIN_SCRATCH_BO_SIZE_LOG2;
+ assert(index < ARRAY_SIZE(dev->scratch_bos));
+
+ for (unsigned i = index; i < ARRAY_SIZE(dev->scratch_bos); i++) {
+ if (p_atomic_read(&dev->scratch_bos[i].initialized)) {
+ /* Fast path: just return the already-allocated BO. */
+ *bo = &dev->scratch_bos[i].bo;
+ return VK_SUCCESS;
+ }
+ }
+
+ /* Slow path: actually allocate the BO. We take a lock because the process
+ * of allocating it is slow, and we don't want to block the CPU while it
+ * finishes.
+ */
+ mtx_lock(&dev->scratch_bos[index].construct_mtx);
+
+ /* Another thread may have allocated it already while we were waiting on
+ * the lock. We need to check this in order to avoid double-allocating.
+ */
+ if (dev->scratch_bos[index].initialized) {
+ mtx_unlock(&dev->scratch_bos[index].construct_mtx);
+ *bo = &dev->scratch_bos[index].bo;
+ return VK_SUCCESS;
+ }
+
+ unsigned bo_size = 1ull << size_log2;
+ VkResult result = tu_bo_init_new(dev, &dev->scratch_bos[index].bo, bo_size);
+ if (result != VK_SUCCESS) {
+ mtx_unlock(&dev->scratch_bos[index].construct_mtx);
+ return result;
+ }
+
+ p_atomic_set(&dev->scratch_bos[index].initialized, true);
+
+ mtx_unlock(&dev->scratch_bos[index].construct_mtx);
+
+ *bo = &dev->scratch_bos[index].bo;
+ return VK_SUCCESS;
+}
+
VkResult
tu_EnumerateInstanceLayerProperties(uint32_t *pPropertyCount,
VkLayerProperties *pProperties)
tu_GetDeviceQueue2(_device, &info, pQueue);
}
+static VkResult
+tu_get_semaphore_syncobjs(const VkSemaphore *sems,
+ uint32_t sem_count,
+ bool wait,
+ struct drm_msm_gem_submit_syncobj **out,
+ uint32_t *out_count)
+{
+ uint32_t syncobj_count = 0;
+ struct drm_msm_gem_submit_syncobj *syncobjs;
+
+ for (uint32_t i = 0; i < sem_count; ++i) {
+ TU_FROM_HANDLE(tu_semaphore, sem, sems[i]);
+
+ struct tu_semaphore_part *part =
+ sem->temporary.kind != TU_SEMAPHORE_NONE ?
+ &sem->temporary : &sem->permanent;
+
+ if (part->kind == TU_SEMAPHORE_SYNCOBJ)
+ ++syncobj_count;
+ }
+
+ *out = NULL;
+ *out_count = syncobj_count;
+ if (!syncobj_count)
+ return VK_SUCCESS;
+
+ *out = syncobjs = calloc(syncobj_count, sizeof (*syncobjs));
+ if (!syncobjs)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+
+ for (uint32_t i = 0, j = 0; i < sem_count; ++i) {
+ TU_FROM_HANDLE(tu_semaphore, sem, sems[i]);
+
+ struct tu_semaphore_part *part =
+ sem->temporary.kind != TU_SEMAPHORE_NONE ?
+ &sem->temporary : &sem->permanent;
+
+ if (part->kind == TU_SEMAPHORE_SYNCOBJ) {
+ syncobjs[j].handle = part->syncobj;
+ syncobjs[j].flags = wait ? MSM_SUBMIT_SYNCOBJ_RESET : 0;
+ ++j;
+ }
+ }
+
+ return VK_SUCCESS;
+}
+
+
+static void
+tu_semaphores_remove_temp(struct tu_device *device,
+ const VkSemaphore *sems,
+ uint32_t sem_count)
+{
+ for (uint32_t i = 0; i < sem_count; ++i) {
+ TU_FROM_HANDLE(tu_semaphore, sem, sems[i]);
+ tu_semaphore_remove_temp(device, sem);
+ }
+}
+
VkResult
tu_QueueSubmit(VkQueue _queue,
uint32_t submitCount,
VkFence _fence)
{
TU_FROM_HANDLE(tu_queue, queue, _queue);
+ VkResult result;
for (uint32_t i = 0; i < submitCount; ++i) {
const VkSubmitInfo *submit = pSubmits + i;
const bool last_submit = (i == submitCount - 1);
+ struct drm_msm_gem_submit_syncobj *in_syncobjs = NULL, *out_syncobjs = NULL;
+ uint32_t nr_in_syncobjs, nr_out_syncobjs;
struct tu_bo_list bo_list;
tu_bo_list_init(&bo_list);
+ result = tu_get_semaphore_syncobjs(pSubmits[i].pWaitSemaphores,
+ pSubmits[i].waitSemaphoreCount,
+ false, &in_syncobjs, &nr_in_syncobjs);
+ if (result != VK_SUCCESS) {
+ return tu_device_set_lost(queue->device,
+ "failed to allocate space for semaphore submission\n");
+ }
+
+ result = tu_get_semaphore_syncobjs(pSubmits[i].pSignalSemaphores,
+ pSubmits[i].signalSemaphoreCount,
+ false, &out_syncobjs, &nr_out_syncobjs);
+ if (result != VK_SUCCESS) {
+ free(in_syncobjs);
+ return tu_device_set_lost(queue->device,
+ "failed to allocate space for semaphore submission\n");
+ }
+
uint32_t entry_count = 0;
for (uint32_t j = 0; j < submit->commandBufferCount; ++j) {
TU_FROM_HANDLE(tu_cmd_buffer, cmdbuf, submit->pCommandBuffers[j]);
}
uint32_t flags = MSM_PIPE_3D0;
+ if (nr_in_syncobjs) {
+ flags |= MSM_SUBMIT_SYNCOBJ_IN;
+ }
+ if (nr_out_syncobjs) {
+ flags |= MSM_SUBMIT_SYNCOBJ_OUT;
+ }
+
if (last_submit) {
flags |= MSM_SUBMIT_FENCE_FD_OUT;
}
.nr_bos = bo_list.count,
.cmds = (uint64_t)(uintptr_t)cmds,
.nr_cmds = entry_count,
+ .in_syncobjs = (uint64_t)(uintptr_t)in_syncobjs,
+ .out_syncobjs = (uint64_t)(uintptr_t)out_syncobjs,
+ .nr_in_syncobjs = nr_in_syncobjs,
+ .nr_out_syncobjs = nr_out_syncobjs,
+ .syncobj_stride = sizeof(struct drm_msm_gem_submit_syncobj),
};
int ret = drmCommandWriteRead(queue->device->physical_device->local_fd,
DRM_MSM_GEM_SUBMIT,
&req, sizeof(req));
if (ret) {
- fprintf(stderr, "submit failed: %s\n", strerror(errno));
- abort();
+ free(in_syncobjs);
+ free(out_syncobjs);
+ return tu_device_set_lost(queue->device, "submit failed: %s\n",
+ strerror(errno));
}
tu_bo_list_destroy(&bo_list);
+ free(in_syncobjs);
+ free(out_syncobjs);
+ tu_semaphores_remove_temp(queue->device, pSubmits[i].pWaitSemaphores,
+ pSubmits[i].waitSemaphoreCount);
if (last_submit) {
/* no need to merge fences as queue execution is serialized */
tu_fence_update_fd(&queue->submit_fence, req.fence_fd);
+ } else if (last_submit) {
+ close(req.fence_fd);
}
}
{
TU_FROM_HANDLE(tu_queue, queue, _queue);
+ if (tu_device_is_lost(queue->device))
+ return VK_ERROR_DEVICE_LOST;
+
tu_fence_wait_idle(&queue->submit_fence);
return VK_SUCCESS;
{
TU_FROM_HANDLE(tu_device, device, _device);
+ if (tu_device_is_lost(device))
+ return VK_ERROR_DEVICE_LOST;
+
for (unsigned i = 0; i < TU_MAX_QUEUE_FAMILIES; i++) {
for (unsigned q = 0; q < device->queue_count[i]; q++) {
tu_QueueWaitIdle(tu_queue_to_handle(&device->queues[i][q]));
return VK_SUCCESS;
}
-VkResult
-tu_ImportSemaphoreFdKHR(VkDevice _device,
- const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo)
-{
- tu_stub();
-
- return VK_SUCCESS;
-}
-
-VkResult
-tu_GetSemaphoreFdKHR(VkDevice _device,
- const VkSemaphoreGetFdInfoKHR *pGetFdInfo,
- int *pFd)
-{
- tu_stub();
-
- return VK_SUCCESS;
-}
-
-VkResult
-tu_ImportFenceFdKHR(VkDevice _device,
- const VkImportFenceFdInfoKHR *pImportFenceFdInfo)
-{
- tu_stub();
-
- return VK_SUCCESS;
-}
-
-VkResult
-tu_GetFenceFdKHR(VkDevice _device,
- const VkFenceGetFdInfoKHR *pGetFdInfo,
- int *pFd)
-{
- tu_stub();
-
- return VK_SUCCESS;
-}
-
VkResult
tu_EnumerateInstanceExtensionProperties(const char *pLayerName,
uint32_t *pPropertyCount,
return vk_error(NULL, VK_ERROR_LAYER_NOT_PRESENT);
for (int i = 0; i < TU_INSTANCE_EXTENSION_COUNT; i++) {
- if (tu_supported_instance_extensions.extensions[i]) {
+ if (tu_instance_extensions_supported.extensions[i]) {
vk_outarray_append(&out, prop) { *prop = tu_instance_extensions[i]; }
}
}
// Queue semaphore functions
+
+static void
+tu_semaphore_part_destroy(struct tu_device *device,
+ struct tu_semaphore_part *part)
+{
+ switch(part->kind) {
+ case TU_SEMAPHORE_NONE:
+ break;
+ case TU_SEMAPHORE_SYNCOBJ:
+ drmSyncobjDestroy(device->physical_device->local_fd, part->syncobj);
+ break;
+ }
+ part->kind = TU_SEMAPHORE_NONE;
+}
+
+static void
+tu_semaphore_remove_temp(struct tu_device *device,
+ struct tu_semaphore *sem)
+{
+ if (sem->temporary.kind != TU_SEMAPHORE_NONE) {
+ tu_semaphore_part_destroy(device, &sem->temporary);
+ }
+}
+
VkResult
tu_CreateSemaphore(VkDevice _device,
const VkSemaphoreCreateInfo *pCreateInfo,
if (!sem)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
+ const VkExportSemaphoreCreateInfo *export =
+ vk_find_struct_const(pCreateInfo->pNext, EXPORT_SEMAPHORE_CREATE_INFO);
+ VkExternalSemaphoreHandleTypeFlags handleTypes =
+ export ? export->handleTypes : 0;
+
+ sem->permanent.kind = TU_SEMAPHORE_NONE;
+ sem->temporary.kind = TU_SEMAPHORE_NONE;
+
+ if (handleTypes) {
+ if (drmSyncobjCreate(device->physical_device->local_fd, 0, &sem->permanent.syncobj) < 0) {
+ vk_free2(&device->alloc, pAllocator, sem);
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+ }
+ sem->permanent.kind = TU_SEMAPHORE_SYNCOBJ;
+ }
*pSemaphore = tu_semaphore_to_handle(sem);
return VK_SUCCESS;
}
if (!_semaphore)
return;
+ tu_semaphore_part_destroy(device, &sem->permanent);
+ tu_semaphore_part_destroy(device, &sem->temporary);
+
vk_free2(&device->alloc, pAllocator, sem);
}
vk_free2(&device->alloc, pAllocator, fb);
}
-static enum a6xx_tex_clamp
-tu6_tex_wrap(VkSamplerAddressMode address_mode)
-{
- switch (address_mode) {
- case VK_SAMPLER_ADDRESS_MODE_REPEAT:
- return A6XX_TEX_REPEAT;
- case VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT:
- return A6XX_TEX_MIRROR_REPEAT;
- case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE:
- return A6XX_TEX_CLAMP_TO_EDGE;
- case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER:
- return A6XX_TEX_CLAMP_TO_BORDER;
- case VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE:
- /* only works for PoT.. need to emulate otherwise! */
- return A6XX_TEX_MIRROR_CLAMP;
- default:
- unreachable("illegal tex wrap mode");
- break;
- }
-}
-
-static enum a6xx_tex_filter
-tu6_tex_filter(VkFilter filter, unsigned aniso)
-{
- switch (filter) {
- case VK_FILTER_NEAREST:
- return A6XX_TEX_NEAREST;
- case VK_FILTER_LINEAR:
- return aniso ? A6XX_TEX_ANISO : A6XX_TEX_LINEAR;
- case VK_FILTER_CUBIC_EXT:
- return A6XX_TEX_CUBIC;
- default:
- unreachable("illegal texture filter");
- break;
- }
-}
-
-static inline enum adreno_compare_func
-tu6_compare_func(VkCompareOp op)
-{
- return (enum adreno_compare_func) op;
-}
-
static void
tu_init_sampler(struct tu_device *device,
struct tu_sampler *sampler,
{
const struct VkSamplerReductionModeCreateInfo *reduction =
vk_find_struct_const(pCreateInfo->pNext, SAMPLER_REDUCTION_MODE_CREATE_INFO);
+ const struct VkSamplerYcbcrConversionInfo *ycbcr_conversion =
+ vk_find_struct_const(pCreateInfo->pNext, SAMPLER_YCBCR_CONVERSION_INFO);
unsigned aniso = pCreateInfo->anisotropyEnable ?
util_last_bit(MIN2((uint32_t)pCreateInfo->maxAnisotropy >> 1, 8)) : 0;
bool miplinear = (pCreateInfo->mipmapMode == VK_SAMPLER_MIPMAP_MODE_LINEAR);
+ float min_lod = CLAMP(pCreateInfo->minLod, 0.0f, 4095.0f / 256.0f);
+ float max_lod = CLAMP(pCreateInfo->maxLod, 0.0f, 4095.0f / 256.0f);
sampler->descriptor[0] =
COND(miplinear, A6XX_TEX_SAMP_0_MIPFILTER_LINEAR_NEAR) |
sampler->descriptor[1] =
/* COND(!cso->seamless_cube_map, A6XX_TEX_SAMP_1_CUBEMAPSEAMLESSFILTOFF) | */
COND(pCreateInfo->unnormalizedCoordinates, A6XX_TEX_SAMP_1_UNNORM_COORDS) |
- A6XX_TEX_SAMP_1_MIN_LOD(pCreateInfo->minLod) |
- A6XX_TEX_SAMP_1_MAX_LOD(pCreateInfo->maxLod) |
+ A6XX_TEX_SAMP_1_MIN_LOD(min_lod) |
+ A6XX_TEX_SAMP_1_MAX_LOD(max_lod) |
COND(pCreateInfo->compareEnable,
A6XX_TEX_SAMP_1_COMPARE_FUNC(tu6_compare_func(pCreateInfo->compareOp)));
/* This is an offset into the border_color BO, which we fill with all the
sampler->descriptor[3] = 0;
if (reduction) {
- /* note: vulkan enum matches hw */
- sampler->descriptor[2] |= A6XX_TEX_SAMP_2_REDUCTION_MODE(reduction->reductionMode);
+ sampler->descriptor[2] |= A6XX_TEX_SAMP_2_REDUCTION_MODE(
+ tu6_reduction_mode(reduction->reductionMode));
+ }
+
+ sampler->ycbcr_sampler = ycbcr_conversion ?
+ tu_sampler_ycbcr_conversion_from_handle(ycbcr_conversion->conversion) : NULL;
+
+ if (sampler->ycbcr_sampler &&
+ sampler->ycbcr_sampler->chroma_filter == VK_FILTER_LINEAR) {
+ sampler->descriptor[2] |= A6XX_TEX_SAMP_2_CHROMA_LINEAR;
}
/* TODO:
return VK_SUCCESS;
}
+VkResult
+tu_ImportFenceFdKHR(VkDevice _device,
+ const VkImportFenceFdInfoKHR *pImportFenceFdInfo)
+{
+ tu_stub();
+
+ return VK_SUCCESS;
+}
+
+VkResult
+tu_GetFenceFdKHR(VkDevice _device,
+ const VkFenceGetFdInfoKHR *pGetFdInfo,
+ int *pFd)
+{
+ tu_stub();
+
+ return VK_SUCCESS;
+}
+
+VkResult
+tu_ImportSemaphoreFdKHR(VkDevice _device,
+ const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo)
+{
+ TU_FROM_HANDLE(tu_device, device, _device);
+ TU_FROM_HANDLE(tu_semaphore, sem, pImportSemaphoreFdInfo->semaphore);
+ int ret;
+ struct tu_semaphore_part *dst = NULL;
+
+ if (pImportSemaphoreFdInfo->flags & VK_SEMAPHORE_IMPORT_TEMPORARY_BIT) {
+ dst = &sem->temporary;
+ } else {
+ dst = &sem->permanent;
+ }
+
+ uint32_t syncobj = dst->kind == TU_SEMAPHORE_SYNCOBJ ? dst->syncobj : 0;
+
+ switch(pImportSemaphoreFdInfo->handleType) {
+ case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT: {
+ uint32_t old_syncobj = syncobj;
+ ret = drmSyncobjFDToHandle(device->physical_device->local_fd, pImportSemaphoreFdInfo->fd, &syncobj);
+ if (ret == 0) {
+ close(pImportSemaphoreFdInfo->fd);
+ if (old_syncobj)
+ drmSyncobjDestroy(device->physical_device->local_fd, old_syncobj);
+ }
+ break;
+ }
+ case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT: {
+ if (!syncobj) {
+ ret = drmSyncobjCreate(device->physical_device->local_fd, 0, &syncobj);
+ if (ret)
+ break;
+ }
+ if (pImportSemaphoreFdInfo->fd == -1) {
+ ret = drmSyncobjSignal(device->physical_device->local_fd, &syncobj, 1);
+ } else {
+ ret = drmSyncobjImportSyncFile(device->physical_device->local_fd, syncobj, pImportSemaphoreFdInfo->fd);
+ }
+ if (!ret)
+ close(pImportSemaphoreFdInfo->fd);
+ break;
+ }
+ default:
+ unreachable("Unhandled semaphore handle type");
+ }
+
+ if (ret) {
+ return VK_ERROR_INVALID_EXTERNAL_HANDLE;
+ }
+ dst->syncobj = syncobj;
+ dst->kind = TU_SEMAPHORE_SYNCOBJ;
+
+ return VK_SUCCESS;
+}
+
+VkResult
+tu_GetSemaphoreFdKHR(VkDevice _device,
+ const VkSemaphoreGetFdInfoKHR *pGetFdInfo,
+ int *pFd)
+{
+ TU_FROM_HANDLE(tu_device, device, _device);
+ TU_FROM_HANDLE(tu_semaphore, sem, pGetFdInfo->semaphore);
+ int ret;
+ uint32_t syncobj_handle;
+
+ if (sem->temporary.kind != TU_SEMAPHORE_NONE) {
+ assert(sem->temporary.kind == TU_SEMAPHORE_SYNCOBJ);
+ syncobj_handle = sem->temporary.syncobj;
+ } else {
+ assert(sem->permanent.kind == TU_SEMAPHORE_SYNCOBJ);
+ syncobj_handle = sem->permanent.syncobj;
+ }
+
+ switch(pGetFdInfo->handleType) {
+ case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT:
+ ret = drmSyncobjHandleToFD(device->physical_device->local_fd, syncobj_handle, pFd);
+ break;
+ case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT:
+ ret = drmSyncobjExportSyncFile(device->physical_device->local_fd, syncobj_handle, pFd);
+ if (!ret) {
+ if (sem->temporary.kind != TU_SEMAPHORE_NONE) {
+ tu_semaphore_part_destroy(device, &sem->temporary);
+ } else {
+ drmSyncobjReset(device->physical_device->local_fd, &syncobj_handle, 1);
+ }
+ }
+ break;
+ default:
+ unreachable("Unhandled semaphore handle type");
+ }
+
+ if (ret)
+ return vk_error(device->instance, VK_ERROR_INVALID_EXTERNAL_HANDLE);
+ return VK_SUCCESS;
+}
+
+
+static bool tu_has_syncobj(struct tu_physical_device *pdev)
+{
+ uint64_t value;
+ if (drmGetCap(pdev->local_fd, DRM_CAP_SYNCOBJ, &value))
+ return false;
+ return value && pdev->msm_major_version == 1 && pdev->msm_minor_version >= 6;
+}
+
void
tu_GetPhysicalDeviceExternalSemaphoreProperties(
VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo,
VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
{
- pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0;
- pExternalSemaphoreProperties->compatibleHandleTypes = 0;
- pExternalSemaphoreProperties->externalSemaphoreFeatures = 0;
+ TU_FROM_HANDLE(tu_physical_device, pdev, physicalDevice);
+
+ if (tu_has_syncobj(pdev) &&
+ (pExternalSemaphoreInfo->handleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT ||
+ pExternalSemaphoreInfo->handleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT)) {
+ pExternalSemaphoreProperties->exportFromImportedHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT | VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT;
+ pExternalSemaphoreProperties->compatibleHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT | VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT;
+ pExternalSemaphoreProperties->externalSemaphoreFeatures = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT |
+ VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT;
+ } else {
+ pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0;
+ pExternalSemaphoreProperties->compatibleHandleTypes = 0;
+ pExternalSemaphoreProperties->externalSemaphoreFeatures = 0;
+ }
}
void