#include "util/u_screen.h"
#include "util/u_string.h"
-#include "state_tracker/sw_winsys.h"
+#include "frontend/sw_winsys.h"
static const struct debug_named_value
debug_options[] = {
get_video_mem(struct zink_screen *screen)
{
VkDeviceSize size = 0;
- for (uint32_t i = 0; i < screen->mem_props.memoryHeapCount; ++i)
- size += screen->mem_props.memoryHeaps[i].size;
+ for (uint32_t i = 0; i < screen->mem_props.memoryHeapCount; ++i) {
+ if (screen->mem_props.memoryHeaps[i].flags &
+ VK_MEMORY_HEAP_DEVICE_LOCAL_BIT)
+ size += screen->mem_props.memoryHeaps[i].size;
+ }
return (int)(size >> 20);
}
return 1;
case PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS:
+ if (!screen->feats.dualSrcBlend)
+ return 0;
return screen->props.limits.maxFragmentDualSrcAttachments;
case PIPE_CAP_POINT_SPRITE:
return 1;
#endif
+ case PIPE_CAP_TEXTURE_MULTISAMPLE:
+ return 1;
+
case PIPE_CAP_TEXTURE_SWIZZLE:
return 1;
return 1 + util_logbase2(screen->props.limits.maxImageDimensionCube);
case PIPE_CAP_BLEND_EQUATION_SEPARATE:
- return 1;
-
case PIPE_CAP_FRAGMENT_SHADER_TEXTURE_LOD:
- return 0; /* TODO: re-enable after implementing nir_texop_txd */
-
case PIPE_CAP_FRAGMENT_SHADER_DERIVATIVES:
case PIPE_CAP_VERTEX_SHADER_SATURATE:
return 1;
case PIPE_CAP_INDEP_BLEND_FUNC:
return 1;
+ case PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS:
+ return screen->have_EXT_transform_feedback ? screen->tf_props.maxTransformFeedbackBuffers : 0;
+ case PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME:
+ case PIPE_CAP_STREAM_OUTPUT_INTERLEAVE_BUFFERS:
+ return 1;
+
case PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS:
return screen->props.limits.maxImageArrayLayers;
return 0;
#endif
+ case PIPE_CAP_TGSI_INSTANCEID:
case PIPE_CAP_MIXED_COLORBUFFER_FORMATS:
- return 1;
-
case PIPE_CAP_SEAMLESS_CUBE_MAP:
return 1;
case PIPE_CAP_VERTEX_COLOR_UNCLAMPED:
return 1;
+ case PIPE_CAP_CONDITIONAL_RENDER:
+ return screen->have_EXT_conditional_rendering;
+
case PIPE_CAP_GLSL_FEATURE_LEVEL:
case PIPE_CAP_GLSL_FEATURE_LEVEL_COMPATIBILITY:
- return 120;
+ return 130;
#if 0 /* TODO: Enable me */
case PIPE_CAP_COMPUTE:
case PIPE_CAP_CUBE_MAP_ARRAY:
return screen->feats.imageCubeArray;
+ case PIPE_CAP_TEXTURE_BUFFER_OBJECTS:
+ return 1;
+
+ case PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT:
+ return screen->props.limits.minTexelBufferOffsetAlignment;
+
case PIPE_CAP_PREFER_BLIT_BASED_TEXTURE_TRANSFER:
return 0; /* unsure */
return PIPE_ENDIAN_NATIVE; /* unsure */
case PIPE_CAP_MAX_VIEWPORTS:
- return screen->props.limits.maxViewports;
+ return 1; /* TODO: When GS is supported, use screen->props.limits.maxViewports */
case PIPE_CAP_MIXED_FRAMEBUFFER_SIZES:
return 1;
case PIPE_CAP_MAX_TEXTURE_GATHER_OFFSET:
return screen->props.limits.maxTexelGatherOffset;
+ case PIPE_CAP_TGSI_FS_FINE_DERIVATIVE:
+ return 1;
+
case PIPE_CAP_VENDOR_ID:
return screen->props.vendorID;
case PIPE_CAP_DEVICE_ID:
case PIPE_CAP_PCI_FUNCTION:
return 0; /* TODO: figure these out */
-#if 0 /* TODO: Enable me */
case PIPE_CAP_CULL_DISTANCE:
return screen->feats.shaderCullDistance;
-#endif
case PIPE_CAP_VIEWPORT_SUBPIXEL_BITS:
return screen->props.limits.viewportSubPixelBits;
case PIPE_CAP_TGSI_FS_FACE_IS_INTEGER_SYSVAL:
return 1;
+ case PIPE_CAP_VIEWPORT_TRANSFORM_LOWERED:
+ return 1;
+
case PIPE_CAP_FLATSHADE:
case PIPE_CAP_ALPHA_TEST:
case PIPE_CAP_CLIP_PLANES:
}
case PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS:
- /* this might be a bit simplistic... */
- return MIN2(screen->props.limits.maxPerStageDescriptorSamplers,
- PIPE_MAX_SAMPLERS);
+ switch (shader) {
+ case PIPE_SHADER_VERTEX:
+ case PIPE_SHADER_FRAGMENT:
+ /* this might be a bit simplistic... */
+ return MIN2(screen->props.limits.maxPerStageDescriptorSamplers,
+ PIPE_MAX_SAMPLERS);
+ default:
+ return 0; /* unsupported stage */
+ }
case PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE:
return MIN2(screen->props.limits.maxUniformBufferRange, INT_MAX);
case PIPE_SHADER_CAP_SUBROUTINES:
case PIPE_SHADER_CAP_INT64_ATOMICS:
case PIPE_SHADER_CAP_FP16:
+ case PIPE_SHADER_CAP_FP16_DERIVATIVES:
+ case PIPE_SHADER_CAP_INT16:
return 0; /* not implemented */
case PIPE_SHADER_CAP_PREFERRED_IR:
return (1 << PIPE_SHADER_IR_NIR) | (1 << PIPE_SHADER_IR_TGSI);
case PIPE_SHADER_CAP_MAX_SHADER_IMAGES:
+#if 0 /* TODO: needs compiler support */
return MIN2(screen->props.limits.maxPerStageDescriptorStorageImages,
PIPE_MAX_SHADER_IMAGES);
+#else
+ return 0;
+#endif
case PIPE_SHADER_CAP_LOWER_IF_THRESHOLD:
case PIPE_SHADER_CAP_TGSI_SKIP_MERGE_REGISTERS:
winsys->displaytarget_display(winsys, res->dt, winsys_drawable_handle, sub_box);
}
+static bool
+load_device_extensions(struct zink_screen *screen)
+{
+#define GET_PROC_ADDR(x) do { \
+ screen->vk_##x = (PFN_vk##x)vkGetDeviceProcAddr(screen->dev, "vk"#x); \
+ if (!screen->vk_##x) \
+ return false; \
+ } while (0)
+ if (screen->have_EXT_transform_feedback) {
+ GET_PROC_ADDR(CmdBindTransformFeedbackBuffersEXT);
+ GET_PROC_ADDR(CmdBeginTransformFeedbackEXT);
+ GET_PROC_ADDR(CmdEndTransformFeedbackEXT);
+ GET_PROC_ADDR(CmdBeginQueryIndexedEXT);
+ GET_PROC_ADDR(CmdEndQueryIndexedEXT);
+ GET_PROC_ADDR(CmdDrawIndirectByteCountEXT);
+ }
+ if (screen->have_KHR_external_memory_fd)
+ GET_PROC_ADDR(GetMemoryFdKHR);
+
+ if (screen->have_EXT_conditional_rendering) {
+ GET_PROC_ADDR(CmdBeginConditionalRenderingEXT);
+ GET_PROC_ADDR(CmdEndConditionalRenderingEXT);
+ }
+
+#undef GET_PROC_ADDR
+
+ return true;
+}
+
static struct pipe_screen *
zink_internal_create_screen(struct sw_winsys *winsys, int fd)
{
struct zink_screen *screen = CALLOC_STRUCT(zink_screen);
+ bool have_tf_ext = false, have_cond_render_ext = false, have_EXT_index_type_uint8 = false;
if (!screen)
return NULL;
screen->pdev = choose_pdev(screen->instance);
screen->gfx_queue = find_gfx_queue(screen->pdev);
- vkGetPhysicalDeviceProperties(screen->pdev, &screen->props);
- vkGetPhysicalDeviceFeatures(screen->pdev, &screen->feats);
vkGetPhysicalDeviceMemoryProperties(screen->pdev, &screen->mem_props);
screen->have_X8_D24_UNORM_PACK32 = zink_is_depth_format_supported(screen,
if (!strcmp(extensions[i].extensionName,
VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME))
screen->have_KHR_external_memory_fd = true;
+ if (!strcmp(extensions[i].extensionName,
+ VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME))
+ have_cond_render_ext = true;
+ if (!strcmp(extensions[i].extensionName,
+ VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME))
+ have_tf_ext = true;
+ if (!strcmp(extensions[i].extensionName,
+ VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME))
+ have_EXT_index_type_uint8 = true;
+
}
FREE(extensions);
}
}
+ VkPhysicalDeviceFeatures2 feats = {};
+ VkPhysicalDeviceTransformFeedbackFeaturesEXT tf_feats = {};
+ VkPhysicalDeviceConditionalRenderingFeaturesEXT cond_render_feats = {};
+ VkPhysicalDeviceIndexTypeUint8FeaturesEXT index_uint8_feats = {};
+
+ feats.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+ if (have_tf_ext) {
+ tf_feats.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
+ tf_feats.pNext = feats.pNext;
+ feats.pNext = &tf_feats;
+ }
+ if (have_cond_render_ext) {
+ cond_render_feats.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
+ cond_render_feats.pNext = feats.pNext;
+ feats.pNext = &cond_render_feats;
+ }
+ if (have_EXT_index_type_uint8) {
+ index_uint8_feats.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
+ index_uint8_feats.pNext = feats.pNext;
+ feats.pNext = &index_uint8_feats;
+ }
+ vkGetPhysicalDeviceFeatures2(screen->pdev, &feats);
+ memcpy(&screen->feats, &feats.features, sizeof(screen->feats));
+ if (have_tf_ext && tf_feats.transformFeedback)
+ screen->have_EXT_transform_feedback = true;
+ if (have_cond_render_ext && cond_render_feats.conditionalRendering)
+ screen->have_EXT_conditional_rendering = true;
+ if (have_EXT_index_type_uint8 && index_uint8_feats.indexTypeUint8)
+ screen->have_EXT_index_type_uint8 = true;
+
+ VkPhysicalDeviceProperties2 props = {};
+ props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
+ if (screen->have_EXT_transform_feedback) {
+ screen->tf_props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
+ screen->tf_props.pNext = NULL;
+ props.pNext = &screen->tf_props;
+ }
+ vkGetPhysicalDeviceProperties2(screen->pdev, &props);
+ memcpy(&screen->props, &props.properties, sizeof(screen->props));
if (!screen->have_KHR_maintenance1) {
debug_printf("ZINK: VK_KHR_maintenance1 required!\n");
dci.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
dci.queueCreateInfoCount = 1;
dci.pQueueCreateInfos = &qci;
- dci.pEnabledFeatures = &screen->feats;
- const char *extensions[3] = {
+ /* extensions don't have bool members in pEnabledFeatures.
+ * this requires us to pass the whole VkPhysicalDeviceFeatures2 struct
+ */
+ dci.pNext = &feats;
+ const char *extensions[6] = {
VK_KHR_MAINTENANCE1_EXTENSION_NAME,
};
num_extensions = 1;
extensions[num_extensions++] = VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME;
extensions[num_extensions++] = VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME;
}
+
+ if (screen->have_EXT_conditional_rendering)
+ extensions[num_extensions++] = VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME;
+
+ if (screen->have_EXT_index_type_uint8)
+ extensions[num_extensions++] = VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME;
+
+ if (screen->have_EXT_transform_feedback)
+ extensions[num_extensions++] = VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME;
assert(num_extensions <= ARRAY_SIZE(extensions));
dci.ppEnabledExtensionNames = extensions;
if (vkCreateDevice(screen->pdev, &dci, NULL, &screen->dev) != VK_SUCCESS)
goto fail;
+ if (!load_device_extensions(screen))
+ goto fail;
+
screen->winsys = winsys;
screen->base.get_name = zink_get_name;
projects / mesa.git / blobdiff