2018-08-31 15:50:20 +01:00
|
|
|
/*
|
|
|
|
* Copyright 2018 Collabora Ltd.
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
|
|
* to deal in the Software without restriction, including without limitation
|
|
|
|
* on the rights to use, copy, modify, merge, publish, distribute, sub
|
|
|
|
* license, and/or sell copies of the Software, and to permit persons to whom
|
|
|
|
* the Software is furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice (including the next
|
|
|
|
* paragraph) shall be included in all copies or substantial portions of the
|
|
|
|
* Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
|
|
|
|
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
|
|
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|
|
|
* USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "zink_screen.h"
|
|
|
|
|
|
|
|
#include "zink_compiler.h"
|
|
|
|
#include "zink_context.h"
|
2020-09-26 07:49:49 +01:00
|
|
|
#include "zink_device_info.h"
|
2018-08-31 15:50:20 +01:00
|
|
|
#include "zink_fence.h"
|
|
|
|
#include "zink_public.h"
|
|
|
|
#include "zink_resource.h"
|
|
|
|
|
|
|
|
#include "os/os_process.h"
|
|
|
|
#include "util/u_debug.h"
|
2019-06-27 23:05:31 +01:00
|
|
|
#include "util/format/u_format.h"
|
2018-08-31 15:50:20 +01:00
|
|
|
#include "util/u_math.h"
|
|
|
|
#include "util/u_memory.h"
|
|
|
|
#include "util/u_screen.h"
|
|
|
|
#include "util/u_string.h"
|
|
|
|
|
2019-12-03 23:01:31 +00:00
|
|
|
#include "frontend/sw_winsys.h"
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
static const struct debug_named_value
|
|
|
|
debug_options[] = {
|
|
|
|
{ "nir", ZINK_DEBUG_NIR, "Dump NIR during program compile" },
|
|
|
|
{ "spirv", ZINK_DEBUG_SPIRV, "Dump SPIR-V during program compile" },
|
|
|
|
{ "tgsi", ZINK_DEBUG_TGSI, "Dump TGSI during program compile" },
|
|
|
|
DEBUG_NAMED_VALUE_END
|
|
|
|
};
|
|
|
|
|
|
|
|
DEBUG_GET_ONCE_FLAGS_OPTION(zink_debug, "ZINK_DEBUG", debug_options, 0)
|
|
|
|
|
|
|
|
uint32_t
|
|
|
|
zink_debug;
|
|
|
|
|
|
|
|
static const char *
|
|
|
|
zink_get_vendor(struct pipe_screen *pscreen)
|
|
|
|
{
|
|
|
|
return "Collabora Ltd";
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char *
|
|
|
|
zink_get_device_vendor(struct pipe_screen *pscreen)
|
|
|
|
{
|
|
|
|
struct zink_screen *screen = zink_screen(pscreen);
|
|
|
|
static char buf[1000];
|
2020-09-28 11:43:36 +01:00
|
|
|
snprintf(buf, sizeof(buf), "Unknown (vendor-id: 0x%04x)", screen->info.props.vendorID);
|
2018-08-31 15:50:20 +01:00
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char *
|
|
|
|
zink_get_name(struct pipe_screen *pscreen)
|
|
|
|
{
|
|
|
|
struct zink_screen *screen = zink_screen(pscreen);
|
|
|
|
static char buf[1000];
|
2020-09-28 11:43:36 +01:00
|
|
|
snprintf(buf, sizeof(buf), "zink (%s)", screen->info.props.deviceName);
|
2018-08-31 15:50:20 +01:00
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
get_video_mem(struct zink_screen *screen)
|
|
|
|
{
|
|
|
|
VkDeviceSize size = 0;
|
2020-09-28 11:43:36 +01:00
|
|
|
for (uint32_t i = 0; i < screen->info.mem_props.memoryHeapCount; ++i) {
|
|
|
|
if (screen->info.mem_props.memoryHeaps[i].flags &
|
2020-06-09 20:54:23 +01:00
|
|
|
VK_MEMORY_HEAP_DEVICE_LOCAL_BIT)
|
2020-09-28 11:43:36 +01:00
|
|
|
size += screen->info.mem_props.memoryHeaps[i].size;
|
2020-06-09 20:54:23 +01:00
|
|
|
}
|
2018-08-31 15:50:20 +01:00
|
|
|
return (int)(size >> 20);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
zink_get_param(struct pipe_screen *pscreen, enum pipe_cap param)
|
|
|
|
{
|
|
|
|
struct zink_screen *screen = zink_screen(pscreen);
|
|
|
|
|
|
|
|
switch (param) {
|
|
|
|
case PIPE_CAP_NPOT_TEXTURES:
|
2020-06-17 22:40:04 +01:00
|
|
|
case PIPE_CAP_TGSI_TEXCOORD:
|
2020-07-11 16:46:21 +01:00
|
|
|
case PIPE_CAP_DRAW_INDIRECT:
|
2018-08-31 15:50:20 +01:00
|
|
|
return 1;
|
|
|
|
|
2020-07-10 14:48:23 +01:00
|
|
|
case PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.have_EXT_vertex_attribute_divisor;
|
2020-07-10 14:48:23 +01:00
|
|
|
|
2018-08-31 15:50:20 +01:00
|
|
|
case PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS:
|
2020-09-28 11:43:36 +01:00
|
|
|
if (!screen->info.feats.features.dualSrcBlend)
|
2020-02-04 10:21:58 +00:00
|
|
|
return 0;
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.props.limits.maxFragmentDualSrcAttachments;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
2018-11-12 12:20:15 +00:00
|
|
|
case PIPE_CAP_POINT_SPRITE:
|
|
|
|
return 1;
|
|
|
|
|
2018-08-31 15:50:20 +01:00
|
|
|
case PIPE_CAP_MAX_RENDER_TARGETS:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.props.limits.maxColorAttachments;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
2018-10-03 00:57:41 +01:00
|
|
|
case PIPE_CAP_OCCLUSION_QUERY:
|
2019-07-17 10:26:53 +01:00
|
|
|
return 1;
|
|
|
|
|
2018-10-03 00:57:41 +01:00
|
|
|
case PIPE_CAP_QUERY_TIME_ELAPSED:
|
|
|
|
return 1;
|
|
|
|
|
2020-02-03 16:41:18 +00:00
|
|
|
case PIPE_CAP_TEXTURE_MULTISAMPLE:
|
|
|
|
return 1;
|
|
|
|
|
2018-08-31 15:50:20 +01:00
|
|
|
case PIPE_CAP_TEXTURE_SWIZZLE:
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
case PIPE_CAP_MAX_TEXTURE_2D_SIZE:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.props.limits.maxImageDimension2D;
|
2018-08-31 15:50:20 +01:00
|
|
|
case PIPE_CAP_MAX_TEXTURE_3D_LEVELS:
|
2020-09-28 11:43:36 +01:00
|
|
|
return 1 + util_logbase2(screen->info.props.limits.maxImageDimension3D);
|
2018-08-31 15:50:20 +01:00
|
|
|
case PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS:
|
2020-09-28 11:43:36 +01:00
|
|
|
return 1 + util_logbase2(screen->info.props.limits.maxImageDimensionCube);
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
case PIPE_CAP_BLEND_EQUATION_SEPARATE:
|
|
|
|
case PIPE_CAP_FRAGMENT_SHADER_TEXTURE_LOD:
|
|
|
|
case PIPE_CAP_FRAGMENT_SHADER_DERIVATIVES:
|
|
|
|
case PIPE_CAP_VERTEX_SHADER_SATURATE:
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
case PIPE_CAP_INDEP_BLEND_ENABLE:
|
|
|
|
case PIPE_CAP_INDEP_BLEND_FUNC:
|
|
|
|
return 1;
|
|
|
|
|
2020-06-01 20:01:47 +01:00
|
|
|
case PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.have_EXT_transform_feedback ? screen->info.tf_props.maxTransformFeedbackBuffers : 0;
|
2020-06-01 20:01:47 +01:00
|
|
|
case PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME:
|
|
|
|
case PIPE_CAP_STREAM_OUTPUT_INTERLEAVE_BUFFERS:
|
|
|
|
return 1;
|
|
|
|
|
2018-08-31 15:50:20 +01:00
|
|
|
case PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.props.limits.maxImageArrayLayers;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
case PIPE_CAP_DEPTH_CLIP_DISABLE:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.feats.features.depthClamp;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
2020-01-30 19:35:04 +00:00
|
|
|
case PIPE_CAP_TGSI_INSTANCEID:
|
2018-08-31 15:50:20 +01:00
|
|
|
case PIPE_CAP_MIXED_COLORBUFFER_FORMATS:
|
|
|
|
case PIPE_CAP_SEAMLESS_CUBE_MAP:
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
case PIPE_CAP_MIN_TEXEL_OFFSET:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.props.limits.minTexelOffset;
|
2018-08-31 15:50:20 +01:00
|
|
|
case PIPE_CAP_MAX_TEXEL_OFFSET:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.props.limits.maxTexelOffset;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
case PIPE_CAP_VERTEX_COLOR_UNCLAMPED:
|
|
|
|
return 1;
|
|
|
|
|
2018-10-15 00:15:50 +01:00
|
|
|
case PIPE_CAP_CONDITIONAL_RENDER:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.have_EXT_conditional_rendering;
|
2018-10-15 00:15:50 +01:00
|
|
|
|
2018-08-31 15:50:20 +01:00
|
|
|
case PIPE_CAP_GLSL_FEATURE_LEVEL_COMPATIBILITY:
|
2020-02-03 16:41:46 +00:00
|
|
|
return 130;
|
2020-07-01 20:51:14 +01:00
|
|
|
case PIPE_CAP_GLSL_FEATURE_LEVEL:
|
2020-07-10 20:02:24 +01:00
|
|
|
return 330;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
#if 0 /* TODO: Enable me */
|
|
|
|
case PIPE_CAP_COMPUTE:
|
|
|
|
return 1;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
case PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.props.limits.minUniformBufferOffsetAlignment;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
2018-10-03 00:57:41 +01:00
|
|
|
case PIPE_CAP_QUERY_TIMESTAMP:
|
2020-07-10 19:47:32 +01:00
|
|
|
return screen->info.have_EXT_calibrated_timestamps;
|
2018-10-03 00:57:41 +01:00
|
|
|
|
2018-08-31 15:50:20 +01:00
|
|
|
case PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.props.limits.minMemoryMapAlignment;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
case PIPE_CAP_CUBE_MAP_ARRAY:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.feats.features.imageCubeArray;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
2020-01-30 22:15:51 +00:00
|
|
|
case PIPE_CAP_TEXTURE_BUFFER_OBJECTS:
|
2020-07-31 14:32:23 +01:00
|
|
|
case PIPE_CAP_PRIMITIVE_RESTART:
|
2020-01-30 22:15:51 +00:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
case PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.props.limits.minTexelBufferOffsetAlignment;
|
2020-01-30 22:15:51 +00:00
|
|
|
|
2018-08-31 15:50:20 +01:00
|
|
|
case PIPE_CAP_PREFER_BLIT_BASED_TEXTURE_TRANSFER:
|
|
|
|
return 0; /* unsure */
|
|
|
|
|
|
|
|
case PIPE_CAP_MAX_TEXTURE_BUFFER_SIZE:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.props.limits.maxTexelBufferElements;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
case PIPE_CAP_ENDIANNESS:
|
|
|
|
return PIPE_ENDIAN_NATIVE; /* unsure */
|
|
|
|
|
|
|
|
case PIPE_CAP_MAX_VIEWPORTS:
|
2020-09-28 11:43:36 +01:00
|
|
|
return 1; /* TODO: When GS is supported, use screen->info.props.limits.maxViewports */
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
case PIPE_CAP_MIXED_FRAMEBUFFER_SIZES:
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
case PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.props.limits.maxGeometryOutputVertices;
|
2018-08-31 15:50:20 +01:00
|
|
|
case PIPE_CAP_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS:
|
2020-10-14 15:42:17 +01:00
|
|
|
return screen->info.props.limits.maxGeometryTotalOutputComponents;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
#if 0 /* TODO: Enable me. Enables ARB_texture_gather */
|
|
|
|
case PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS:
|
|
|
|
return 4;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
case PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.props.limits.minTexelGatherOffset;
|
2018-08-31 15:50:20 +01:00
|
|
|
case PIPE_CAP_MAX_TEXTURE_GATHER_OFFSET:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.props.limits.maxTexelGatherOffset;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
2020-01-30 15:50:59 +00:00
|
|
|
case PIPE_CAP_TGSI_FS_FINE_DERIVATIVE:
|
|
|
|
return 1;
|
|
|
|
|
2018-08-31 15:50:20 +01:00
|
|
|
case PIPE_CAP_VENDOR_ID:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.props.vendorID;
|
2018-08-31 15:50:20 +01:00
|
|
|
case PIPE_CAP_DEVICE_ID:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.props.deviceID;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
case PIPE_CAP_ACCELERATED:
|
|
|
|
return 1;
|
|
|
|
case PIPE_CAP_VIDEO_MEMORY:
|
|
|
|
return get_video_mem(screen);
|
|
|
|
case PIPE_CAP_UMA:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.props.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
case PIPE_CAP_MAX_VERTEX_ATTRIB_STRIDE:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.props.limits.maxVertexInputBindingStride;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
#if 0 /* TODO: Enable me */
|
|
|
|
case PIPE_CAP_SAMPLER_VIEW_TARGET:
|
|
|
|
return 1;
|
|
|
|
#endif
|
|
|
|
|
2019-07-15 14:02:15 +01:00
|
|
|
#if 0 /* TODO: Enable me */
|
|
|
|
case PIPE_CAP_CLIP_HALFZ:
|
|
|
|
return 1;
|
|
|
|
#endif
|
|
|
|
|
2018-08-31 15:50:20 +01:00
|
|
|
#if 0 /* TODO: Enable me */
|
|
|
|
case PIPE_CAP_TEXTURE_FLOAT_LINEAR:
|
|
|
|
case PIPE_CAP_TEXTURE_HALF_FLOAT_LINEAR:
|
|
|
|
return 1;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
case PIPE_CAP_SHAREABLE_SHADERS:
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
#if 0 /* TODO: Enable me. Enables GL_ARB_shader_storage_buffer_object */
|
|
|
|
case PIPE_CAP_SHADER_BUFFER_OFFSET_ALIGNMENT:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.props.limits.minStorageBufferOffsetAlignment;
|
2018-08-31 15:50:20 +01:00
|
|
|
#endif
|
|
|
|
|
|
|
|
case PIPE_CAP_PCI_GROUP:
|
|
|
|
case PIPE_CAP_PCI_BUS:
|
|
|
|
case PIPE_CAP_PCI_DEVICE:
|
|
|
|
case PIPE_CAP_PCI_FUNCTION:
|
|
|
|
return 0; /* TODO: figure these out */
|
|
|
|
|
|
|
|
case PIPE_CAP_CULL_DISTANCE:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.feats.features.shaderCullDistance;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
case PIPE_CAP_VIEWPORT_SUBPIXEL_BITS:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.props.limits.viewportSubPixelBits;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
case PIPE_CAP_GLSL_OPTIMIZE_CONSERVATIVELY:
|
|
|
|
return 0; /* not sure */
|
|
|
|
|
|
|
|
case PIPE_CAP_MAX_GS_INVOCATIONS:
|
2020-10-14 15:42:17 +01:00
|
|
|
return screen->info.props.limits.maxGeometryShaderInvocations;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
case PIPE_CAP_MAX_COMBINED_SHADER_BUFFERS:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.props.limits.maxDescriptorSetStorageBuffers;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
case PIPE_CAP_MAX_SHADER_BUFFER_SIZE:
|
2020-06-26 20:17:32 +01:00
|
|
|
return 65536;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
case PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT:
|
|
|
|
case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER:
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
case PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT:
|
|
|
|
case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER:
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case PIPE_CAP_BUFFER_MAP_PERSISTENT_COHERENT:
|
2019-10-30 10:18:58 +00:00
|
|
|
return 0;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
2019-07-25 13:06:53 +01:00
|
|
|
case PIPE_CAP_NIR_COMPACT_ARRAYS:
|
|
|
|
return 1;
|
|
|
|
|
2019-07-22 12:24:14 +01:00
|
|
|
case PIPE_CAP_TGSI_FS_FACE_IS_INTEGER_SYSVAL:
|
|
|
|
return 1;
|
|
|
|
|
2020-06-17 18:47:22 +01:00
|
|
|
case PIPE_CAP_VIEWPORT_TRANSFORM_LOWERED:
|
|
|
|
return 1;
|
|
|
|
|
2019-01-24 03:13:26 +00:00
|
|
|
case PIPE_CAP_FLATSHADE:
|
2019-07-25 13:09:52 +01:00
|
|
|
case PIPE_CAP_ALPHA_TEST:
|
2019-07-25 13:06:53 +01:00
|
|
|
case PIPE_CAP_CLIP_PLANES:
|
2019-07-18 16:04:09 +01:00
|
|
|
case PIPE_CAP_POINT_SIZE_FIXED:
|
2019-07-25 12:50:40 +01:00
|
|
|
case PIPE_CAP_TWO_SIDED_COLOR:
|
2019-01-24 03:13:26 +00:00
|
|
|
return 0;
|
|
|
|
|
2020-09-08 20:08:20 +01:00
|
|
|
case PIPE_CAP_MAX_SHADER_PATCH_VARYINGS:
|
|
|
|
return screen->info.props.limits.maxTessellationControlPerVertexOutputComponents / 4;
|
|
|
|
case PIPE_CAP_MAX_VARYINGS:
|
|
|
|
/* need to reserve up to 60 of our varying components and 16 slots for streamout */
|
|
|
|
return MIN2(screen->info.props.limits.maxVertexOutputComponents / 4 / 2, 16);
|
|
|
|
|
2019-10-23 11:16:22 +01:00
|
|
|
case PIPE_CAP_DMABUF:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.have_KHR_external_memory_fd;
|
2019-10-23 11:16:22 +01:00
|
|
|
|
2018-08-31 15:50:20 +01:00
|
|
|
default:
|
|
|
|
return u_pipe_screen_get_param_defaults(pscreen, param);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static float
|
|
|
|
zink_get_paramf(struct pipe_screen *pscreen, enum pipe_capf param)
|
|
|
|
{
|
|
|
|
struct zink_screen *screen = zink_screen(pscreen);
|
|
|
|
|
|
|
|
switch (param) {
|
|
|
|
case PIPE_CAPF_MAX_LINE_WIDTH:
|
|
|
|
case PIPE_CAPF_MAX_LINE_WIDTH_AA:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.props.limits.lineWidthRange[1];
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
case PIPE_CAPF_MAX_POINT_WIDTH:
|
|
|
|
case PIPE_CAPF_MAX_POINT_WIDTH_AA:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.props.limits.pointSizeRange[1];
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
case PIPE_CAPF_MAX_TEXTURE_ANISOTROPY:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.props.limits.maxSamplerAnisotropy;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
case PIPE_CAPF_MAX_TEXTURE_LOD_BIAS:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.props.limits.maxSamplerLodBias;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
case PIPE_CAPF_MIN_CONSERVATIVE_RASTER_DILATE:
|
|
|
|
case PIPE_CAPF_MAX_CONSERVATIVE_RASTER_DILATE:
|
|
|
|
case PIPE_CAPF_CONSERVATIVE_RASTER_DILATE_GRANULARITY:
|
|
|
|
return 0.0f; /* not implemented */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* should only get here on unhandled cases */
|
|
|
|
return 0.0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
zink_get_shader_param(struct pipe_screen *pscreen,
|
|
|
|
enum pipe_shader_type shader,
|
|
|
|
enum pipe_shader_cap param)
|
|
|
|
{
|
|
|
|
struct zink_screen *screen = zink_screen(pscreen);
|
|
|
|
|
|
|
|
switch (param) {
|
|
|
|
case PIPE_SHADER_CAP_MAX_INSTRUCTIONS:
|
2020-10-14 15:42:17 +01:00
|
|
|
switch (shader) {
|
|
|
|
case PIPE_SHADER_FRAGMENT:
|
|
|
|
case PIPE_SHADER_VERTEX:
|
|
|
|
case PIPE_SHADER_GEOMETRY:
|
|
|
|
return INT_MAX;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return 0;
|
2018-08-31 15:50:20 +01:00
|
|
|
case PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS:
|
|
|
|
case PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS:
|
|
|
|
case PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS:
|
|
|
|
case PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH:
|
|
|
|
if (shader == PIPE_SHADER_VERTEX ||
|
|
|
|
shader == PIPE_SHADER_FRAGMENT)
|
|
|
|
return INT_MAX;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case PIPE_SHADER_CAP_MAX_INPUTS:
|
|
|
|
switch (shader) {
|
|
|
|
case PIPE_SHADER_VERTEX:
|
2020-09-28 11:43:36 +01:00
|
|
|
return MIN2(screen->info.props.limits.maxVertexInputAttributes,
|
2018-08-31 15:50:20 +01:00
|
|
|
PIPE_MAX_SHADER_INPUTS);
|
2020-10-14 15:42:17 +01:00
|
|
|
case PIPE_SHADER_GEOMETRY:
|
|
|
|
return MIN2(screen->info.props.limits.maxGeometryInputComponents,
|
|
|
|
PIPE_MAX_SHADER_INPUTS);
|
2018-08-31 15:50:20 +01:00
|
|
|
case PIPE_SHADER_FRAGMENT:
|
2020-09-28 11:43:36 +01:00
|
|
|
return MIN2(screen->info.props.limits.maxFragmentInputComponents / 4,
|
2018-08-31 15:50:20 +01:00
|
|
|
PIPE_MAX_SHADER_INPUTS);
|
|
|
|
default:
|
|
|
|
return 0; /* unsupported stage */
|
|
|
|
}
|
|
|
|
|
|
|
|
case PIPE_SHADER_CAP_MAX_OUTPUTS:
|
|
|
|
switch (shader) {
|
|
|
|
case PIPE_SHADER_VERTEX:
|
2020-09-28 11:43:36 +01:00
|
|
|
return MIN2(screen->info.props.limits.maxVertexOutputComponents / 4,
|
2018-08-31 15:50:20 +01:00
|
|
|
PIPE_MAX_SHADER_OUTPUTS);
|
2020-10-14 15:42:17 +01:00
|
|
|
case PIPE_SHADER_GEOMETRY:
|
|
|
|
return MIN2(screen->info.props.limits.maxGeometryOutputComponents / 4,
|
|
|
|
PIPE_MAX_SHADER_OUTPUTS);
|
2018-08-31 15:50:20 +01:00
|
|
|
case PIPE_SHADER_FRAGMENT:
|
2020-09-28 11:43:36 +01:00
|
|
|
return MIN2(screen->info.props.limits.maxColorAttachments,
|
2018-08-31 15:50:20 +01:00
|
|
|
PIPE_MAX_SHADER_OUTPUTS);
|
|
|
|
default:
|
|
|
|
return 0; /* unsupported stage */
|
|
|
|
}
|
|
|
|
|
|
|
|
case PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS:
|
2020-02-14 14:42:51 +00:00
|
|
|
switch (shader) {
|
|
|
|
case PIPE_SHADER_VERTEX:
|
|
|
|
case PIPE_SHADER_FRAGMENT:
|
2020-10-14 15:42:17 +01:00
|
|
|
case PIPE_SHADER_GEOMETRY:
|
2020-02-14 14:42:51 +00:00
|
|
|
/* this might be a bit simplistic... */
|
2020-09-28 11:43:36 +01:00
|
|
|
return MIN2(screen->info.props.limits.maxPerStageDescriptorSamplers,
|
2020-02-14 14:42:51 +00:00
|
|
|
PIPE_MAX_SAMPLERS);
|
|
|
|
default:
|
|
|
|
return 0; /* unsupported stage */
|
|
|
|
}
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
case PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE:
|
2020-06-26 20:17:32 +01:00
|
|
|
return 65536;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
case PIPE_SHADER_CAP_MAX_CONST_BUFFERS:
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.props.limits.maxPerStageDescriptorUniformBuffers;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
case PIPE_SHADER_CAP_MAX_TEMPS:
|
|
|
|
return INT_MAX;
|
|
|
|
|
2019-10-30 10:25:00 +00:00
|
|
|
case PIPE_SHADER_CAP_INTEGERS:
|
|
|
|
return 1;
|
|
|
|
|
2020-06-26 20:57:11 +01:00
|
|
|
case PIPE_SHADER_CAP_INDIRECT_CONST_ADDR:
|
|
|
|
return 1;
|
|
|
|
|
2018-08-31 15:50:20 +01:00
|
|
|
case PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR:
|
|
|
|
case PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR:
|
|
|
|
case PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR:
|
|
|
|
case PIPE_SHADER_CAP_SUBROUTINES:
|
|
|
|
case PIPE_SHADER_CAP_INT64_ATOMICS:
|
|
|
|
case PIPE_SHADER_CAP_FP16:
|
2020-05-10 22:05:00 +01:00
|
|
|
case PIPE_SHADER_CAP_FP16_DERIVATIVES:
|
|
|
|
case PIPE_SHADER_CAP_INT16:
|
2020-08-05 18:21:46 +01:00
|
|
|
case PIPE_SHADER_CAP_GLSL_16BIT_CONSTS:
|
2018-08-31 15:50:20 +01:00
|
|
|
return 0; /* not implemented */
|
|
|
|
|
|
|
|
case PIPE_SHADER_CAP_PREFERRED_IR:
|
|
|
|
return PIPE_SHADER_IR_NIR;
|
|
|
|
|
|
|
|
case PIPE_SHADER_CAP_TGSI_SQRT_SUPPORTED:
|
|
|
|
return 0; /* not implemented */
|
|
|
|
|
|
|
|
case PIPE_SHADER_CAP_MAX_SAMPLER_VIEWS:
|
2020-09-28 11:43:36 +01:00
|
|
|
return MIN2(screen->info.props.limits.maxPerStageDescriptorSampledImages,
|
2018-08-31 15:50:20 +01:00
|
|
|
PIPE_MAX_SHADER_SAMPLER_VIEWS);
|
|
|
|
|
|
|
|
case PIPE_SHADER_CAP_TGSI_DROUND_SUPPORTED:
|
|
|
|
case PIPE_SHADER_CAP_TGSI_DFRACEXP_DLDEXP_SUPPORTED:
|
|
|
|
case PIPE_SHADER_CAP_TGSI_FMA_SUPPORTED:
|
|
|
|
return 0; /* not implemented */
|
|
|
|
|
|
|
|
case PIPE_SHADER_CAP_TGSI_ANY_INOUT_DECL_RANGE:
|
|
|
|
return 0; /* no idea */
|
|
|
|
|
|
|
|
case PIPE_SHADER_CAP_MAX_UNROLL_ITERATIONS_HINT:
|
|
|
|
return 32; /* arbitrary */
|
|
|
|
|
|
|
|
case PIPE_SHADER_CAP_MAX_SHADER_BUFFERS:
|
2020-10-13 14:18:20 +01:00
|
|
|
return 0;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
case PIPE_SHADER_CAP_SUPPORTED_IRS:
|
|
|
|
return (1 << PIPE_SHADER_IR_NIR) | (1 << PIPE_SHADER_IR_TGSI);
|
|
|
|
|
|
|
|
case PIPE_SHADER_CAP_MAX_SHADER_IMAGES:
|
2020-05-13 16:13:47 +01:00
|
|
|
#if 0 /* TODO: needs compiler support */
|
2020-09-28 11:43:36 +01:00
|
|
|
return MIN2(screen->info.props.limits.maxPerStageDescriptorStorageImages,
|
2019-04-09 17:22:53 +01:00
|
|
|
PIPE_MAX_SHADER_IMAGES);
|
2020-05-13 16:13:47 +01:00
|
|
|
#else
|
|
|
|
return 0;
|
|
|
|
#endif
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
case PIPE_SHADER_CAP_LOWER_IF_THRESHOLD:
|
|
|
|
case PIPE_SHADER_CAP_TGSI_SKIP_MERGE_REGISTERS:
|
|
|
|
return 0; /* unsure */
|
|
|
|
|
|
|
|
case PIPE_SHADER_CAP_TGSI_LDEXP_SUPPORTED:
|
|
|
|
case PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTERS:
|
|
|
|
case PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTER_BUFFERS:
|
|
|
|
case PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED:
|
|
|
|
return 0; /* not implemented */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* should only get here on unhandled cases */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-11-05 02:41:37 +00:00
|
|
|
static VkSampleCountFlagBits
|
|
|
|
vk_sample_count_flags(uint32_t sample_count)
|
|
|
|
{
|
|
|
|
switch (sample_count) {
|
|
|
|
case 1: return VK_SAMPLE_COUNT_1_BIT;
|
|
|
|
case 2: return VK_SAMPLE_COUNT_2_BIT;
|
|
|
|
case 4: return VK_SAMPLE_COUNT_4_BIT;
|
|
|
|
case 8: return VK_SAMPLE_COUNT_8_BIT;
|
|
|
|
case 16: return VK_SAMPLE_COUNT_16_BIT;
|
|
|
|
case 32: return VK_SAMPLE_COUNT_32_BIT;
|
|
|
|
case 64: return VK_SAMPLE_COUNT_64_BIT;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-08-31 15:50:20 +01:00
|
|
|
static bool
|
|
|
|
zink_is_format_supported(struct pipe_screen *pscreen,
|
|
|
|
enum pipe_format format,
|
|
|
|
enum pipe_texture_target target,
|
|
|
|
unsigned sample_count,
|
|
|
|
unsigned storage_sample_count,
|
|
|
|
unsigned bind)
|
|
|
|
{
|
|
|
|
struct zink_screen *screen = zink_screen(pscreen);
|
|
|
|
|
2018-11-05 02:41:37 +00:00
|
|
|
if (format == PIPE_FORMAT_NONE)
|
2020-09-28 11:43:36 +01:00
|
|
|
return screen->info.props.limits.framebufferNoAttachmentsSampleCounts &
|
2018-11-05 02:41:37 +00:00
|
|
|
vk_sample_count_flags(sample_count);
|
2018-08-31 15:50:20 +01:00
|
|
|
|
2019-10-23 10:59:03 +01:00
|
|
|
VkFormat vkformat = zink_get_format(screen, format);
|
2018-08-31 15:50:20 +01:00
|
|
|
if (vkformat == VK_FORMAT_UNDEFINED)
|
2019-11-28 17:41:05 +00:00
|
|
|
return false;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
2018-11-05 02:41:37 +00:00
|
|
|
if (sample_count >= 1) {
|
|
|
|
VkSampleCountFlagBits sample_mask = vk_sample_count_flags(sample_count);
|
2019-11-28 17:41:30 +00:00
|
|
|
if (!sample_mask)
|
|
|
|
return false;
|
2019-07-10 13:59:58 +01:00
|
|
|
const struct util_format_description *desc = util_format_description(format);
|
2018-11-05 02:41:37 +00:00
|
|
|
if (util_format_is_depth_or_stencil(format)) {
|
|
|
|
if (util_format_has_depth(desc)) {
|
|
|
|
if (bind & PIPE_BIND_DEPTH_STENCIL &&
|
2020-09-28 11:43:36 +01:00
|
|
|
(screen->info.props.limits.framebufferDepthSampleCounts & sample_mask) != sample_mask)
|
2019-11-28 17:41:05 +00:00
|
|
|
return false;
|
2018-11-05 02:41:37 +00:00
|
|
|
if (bind & PIPE_BIND_SAMPLER_VIEW &&
|
2020-09-28 11:43:36 +01:00
|
|
|
(screen->info.props.limits.sampledImageDepthSampleCounts & sample_mask) != sample_mask)
|
2019-11-28 17:41:05 +00:00
|
|
|
return false;
|
2018-11-05 02:41:37 +00:00
|
|
|
}
|
|
|
|
if (util_format_has_stencil(desc)) {
|
|
|
|
if (bind & PIPE_BIND_DEPTH_STENCIL &&
|
2020-09-28 11:43:36 +01:00
|
|
|
(screen->info.props.limits.framebufferStencilSampleCounts & sample_mask) != sample_mask)
|
2019-11-28 17:41:05 +00:00
|
|
|
return false;
|
2018-11-05 02:41:37 +00:00
|
|
|
if (bind & PIPE_BIND_SAMPLER_VIEW &&
|
2020-09-28 11:43:36 +01:00
|
|
|
(screen->info.props.limits.sampledImageStencilSampleCounts & sample_mask) != sample_mask)
|
2019-11-28 17:41:05 +00:00
|
|
|
return false;
|
2018-11-05 02:41:37 +00:00
|
|
|
}
|
|
|
|
} else if (util_format_is_pure_integer(format)) {
|
|
|
|
if (bind & PIPE_BIND_RENDER_TARGET &&
|
2020-09-28 11:43:36 +01:00
|
|
|
!(screen->info.props.limits.framebufferColorSampleCounts & sample_mask))
|
2019-11-28 17:41:05 +00:00
|
|
|
return false;
|
2018-11-05 02:41:37 +00:00
|
|
|
if (bind & PIPE_BIND_SAMPLER_VIEW &&
|
2020-09-28 11:43:36 +01:00
|
|
|
!(screen->info.props.limits.sampledImageIntegerSampleCounts & sample_mask))
|
2019-11-28 17:41:05 +00:00
|
|
|
return false;
|
2018-11-05 02:41:37 +00:00
|
|
|
} else {
|
|
|
|
if (bind & PIPE_BIND_RENDER_TARGET &&
|
2020-09-28 11:43:36 +01:00
|
|
|
!(screen->info.props.limits.framebufferColorSampleCounts & sample_mask))
|
2019-11-28 17:41:05 +00:00
|
|
|
return false;
|
2018-11-05 02:41:37 +00:00
|
|
|
if (bind & PIPE_BIND_SAMPLER_VIEW &&
|
2020-09-28 11:43:36 +01:00
|
|
|
!(screen->info.props.limits.sampledImageColorSampleCounts & sample_mask))
|
2019-11-28 17:41:05 +00:00
|
|
|
return false;
|
2018-11-05 02:41:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-08-31 15:50:20 +01:00
|
|
|
VkFormatProperties props;
|
|
|
|
vkGetPhysicalDeviceFormatProperties(screen->pdev, vkformat, &props);
|
|
|
|
|
|
|
|
if (target == PIPE_BUFFER) {
|
|
|
|
if (bind & PIPE_BIND_VERTEX_BUFFER &&
|
|
|
|
!(props.bufferFeatures & VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))
|
2019-11-28 17:41:05 +00:00
|
|
|
return false;
|
2018-08-31 15:50:20 +01:00
|
|
|
} else {
|
|
|
|
/* all other targets are texture-targets */
|
|
|
|
if (bind & PIPE_BIND_RENDER_TARGET &&
|
|
|
|
!(props.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT))
|
2019-11-28 17:41:05 +00:00
|
|
|
return false;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
if (bind & PIPE_BIND_BLENDABLE &&
|
|
|
|
!(props.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT))
|
2019-11-28 17:41:05 +00:00
|
|
|
return false;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
if (bind & PIPE_BIND_SAMPLER_VIEW &&
|
|
|
|
!(props.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT))
|
2019-11-28 17:41:05 +00:00
|
|
|
return false;
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
if (bind & PIPE_BIND_DEPTH_STENCIL &&
|
|
|
|
!(props.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT))
|
2019-11-28 17:41:05 +00:00
|
|
|
return false;
|
2018-08-31 15:50:20 +01:00
|
|
|
}
|
|
|
|
|
2019-07-10 13:59:58 +01:00
|
|
|
if (util_format_is_compressed(format)) {
|
|
|
|
const struct util_format_description *desc = util_format_description(format);
|
|
|
|
if (desc->layout == UTIL_FORMAT_LAYOUT_BPTC &&
|
2020-09-28 11:43:36 +01:00
|
|
|
!screen->info.feats.features.textureCompressionBC)
|
2019-11-28 17:41:05 +00:00
|
|
|
return false;
|
2019-07-10 13:59:58 +01:00
|
|
|
}
|
2018-10-03 06:25:09 +01:00
|
|
|
|
2019-11-28 17:41:05 +00:00
|
|
|
return true;
|
2018-08-31 15:50:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
zink_destroy_screen(struct pipe_screen *pscreen)
|
|
|
|
{
|
|
|
|
struct zink_screen *screen = zink_screen(pscreen);
|
|
|
|
slab_destroy_parent(&screen->transfer_pool);
|
|
|
|
FREE(screen);
|
|
|
|
}
|
|
|
|
|
|
|
|
static VkInstance
|
|
|
|
create_instance()
|
|
|
|
{
|
|
|
|
VkApplicationInfo ai = {};
|
|
|
|
ai.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
|
|
|
|
|
|
|
|
char proc_name[128];
|
|
|
|
if (os_get_process_name(proc_name, ARRAY_SIZE(proc_name)))
|
|
|
|
ai.pApplicationName = proc_name;
|
|
|
|
else
|
|
|
|
ai.pApplicationName = "unknown";
|
|
|
|
|
|
|
|
ai.pEngineName = "mesa zink";
|
|
|
|
ai.apiVersion = VK_API_VERSION_1_0;
|
|
|
|
|
2018-10-02 23:27:36 +01:00
|
|
|
const char *extensions[] = {
|
|
|
|
VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
|
|
|
|
VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME,
|
|
|
|
};
|
|
|
|
|
2018-08-31 15:50:20 +01:00
|
|
|
VkInstanceCreateInfo ici = {};
|
|
|
|
ici.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
|
|
|
|
ici.pApplicationInfo = &ai;
|
2018-10-02 23:27:36 +01:00
|
|
|
ici.ppEnabledExtensionNames = extensions;
|
|
|
|
ici.enabledExtensionCount = ARRAY_SIZE(extensions);
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
VkInstance instance = VK_NULL_HANDLE;
|
|
|
|
VkResult err = vkCreateInstance(&ici, NULL, &instance);
|
|
|
|
if (err != VK_SUCCESS)
|
|
|
|
return VK_NULL_HANDLE;
|
|
|
|
|
|
|
|
return instance;
|
|
|
|
}
|
|
|
|
|
|
|
|
static VkPhysicalDevice
|
|
|
|
choose_pdev(const VkInstance instance)
|
|
|
|
{
|
|
|
|
uint32_t i, pdev_count;
|
|
|
|
VkPhysicalDevice *pdevs, pdev;
|
|
|
|
vkEnumeratePhysicalDevices(instance, &pdev_count, NULL);
|
|
|
|
assert(pdev_count > 0);
|
|
|
|
|
|
|
|
pdevs = malloc(sizeof(*pdevs) * pdev_count);
|
|
|
|
vkEnumeratePhysicalDevices(instance, &pdev_count, pdevs);
|
|
|
|
assert(pdev_count > 0);
|
|
|
|
|
|
|
|
pdev = pdevs[0];
|
|
|
|
for (i = 0; i < pdev_count; ++i) {
|
|
|
|
VkPhysicalDeviceProperties props;
|
|
|
|
vkGetPhysicalDeviceProperties(pdevs[i], &props);
|
|
|
|
if (props.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) {
|
|
|
|
pdev = pdevs[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free(pdevs);
|
|
|
|
return pdev;
|
|
|
|
}
|
|
|
|
|
2020-07-10 19:40:01 +01:00
|
|
|
static void
|
|
|
|
update_queue_props(struct zink_screen *screen)
|
2018-08-31 15:50:20 +01:00
|
|
|
{
|
|
|
|
uint32_t num_queues;
|
2020-07-10 19:40:01 +01:00
|
|
|
vkGetPhysicalDeviceQueueFamilyProperties(screen->pdev, &num_queues, NULL);
|
2018-08-31 15:50:20 +01:00
|
|
|
assert(num_queues > 0);
|
|
|
|
|
|
|
|
VkQueueFamilyProperties *props = malloc(sizeof(*props) * num_queues);
|
2020-07-10 19:40:01 +01:00
|
|
|
vkGetPhysicalDeviceQueueFamilyProperties(screen->pdev, &num_queues, props);
|
2018-08-31 15:50:20 +01:00
|
|
|
|
|
|
|
for (uint32_t i = 0; i < num_queues; i++) {
|
|
|
|
if (props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
|
2020-07-10 19:40:01 +01:00
|
|
|
screen->gfx_queue = i;
|
|
|
|
screen->timestamp_valid_bits = props[i].timestampValidBits;
|
|
|
|
assert(screen->timestamp_valid_bits);
|
|
|
|
break;
|
2018-08-31 15:50:20 +01:00
|
|
|
}
|
|
|
|
}
|
2020-07-10 19:40:01 +01:00
|
|
|
free(props);
|
2018-08-31 15:50:20 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
zink_flush_frontbuffer(struct pipe_screen *pscreen,
|
|
|
|
struct pipe_resource *pres,
|
|
|
|
unsigned level, unsigned layer,
|
|
|
|
void *winsys_drawable_handle,
|
|
|
|
struct pipe_box *sub_box)
|
|
|
|
{
|
|
|
|
struct zink_screen *screen = zink_screen(pscreen);
|
|
|
|
struct sw_winsys *winsys = screen->winsys;
|
|
|
|
struct zink_resource *res = zink_resource(pres);
|
|
|
|
|
2018-10-02 23:27:36 +01:00
|
|
|
if (!winsys)
|
|
|
|
return;
|
2018-08-31 15:50:20 +01:00
|
|
|
void *map = winsys->displaytarget_map(winsys, res->dt, 0);
|
|
|
|
|
|
|
|
if (map) {
|
|
|
|
VkImageSubresource isr = {};
|
|
|
|
isr.aspectMask = res->aspect;
|
|
|
|
isr.mipLevel = level;
|
|
|
|
isr.arrayLayer = layer;
|
|
|
|
VkSubresourceLayout layout;
|
|
|
|
vkGetImageSubresourceLayout(screen->dev, res->image, &isr, &layout);
|
|
|
|
|
|
|
|
void *ptr;
|
|
|
|
VkResult result = vkMapMemory(screen->dev, res->mem, res->offset, res->size, 0, &ptr);
|
|
|
|
if (result != VK_SUCCESS) {
|
|
|
|
debug_printf("failed to map memory for display\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
for (int i = 0; i < pres->height0; ++i) {
|
|
|
|
uint8_t *src = (uint8_t *)ptr + i * layout.rowPitch;
|
|
|
|
uint8_t *dst = (uint8_t *)map + i * res->dt_stride;
|
|
|
|
memcpy(dst, src, res->dt_stride);
|
|
|
|
}
|
|
|
|
vkUnmapMemory(screen->dev, res->mem);
|
|
|
|
}
|
|
|
|
|
|
|
|
winsys->displaytarget_unmap(winsys, res->dt);
|
|
|
|
|
|
|
|
assert(res->dt);
|
|
|
|
if (res->dt)
|
|
|
|
winsys->displaytarget_display(winsys, res->dt, winsys_drawable_handle, sub_box);
|
|
|
|
}
|
|
|
|
|
2020-04-30 18:06:51 +01:00
|
|
|
static bool
|
|
|
|
load_device_extensions(struct zink_screen *screen)
|
|
|
|
{
|
2020-05-08 11:07:48 +01:00
|
|
|
#define GET_PROC_ADDR(x) do { \
|
|
|
|
screen->vk_##x = (PFN_vk##x)vkGetDeviceProcAddr(screen->dev, "vk"#x); \
|
2020-07-11 14:46:23 +01:00
|
|
|
if (!screen->vk_##x) { \
|
|
|
|
debug_printf("vkGetDeviceProcAddr failed: vk"#x"\n"); \
|
2020-05-08 11:07:48 +01:00
|
|
|
return false; \
|
2020-07-11 14:46:23 +01:00
|
|
|
} \
|
2020-05-08 11:07:48 +01:00
|
|
|
} while (0)
|
2020-07-10 19:42:08 +01:00
|
|
|
|
|
|
|
#define GET_PROC_ADDR_INSTANCE(x) do { \
|
|
|
|
screen->vk_##x = (PFN_vk##x)vkGetInstanceProcAddr(screen->instance, "vk"#x); \
|
|
|
|
if (!screen->vk_##x) { \
|
|
|
|
debug_printf("GetInstanceProcAddr failed: vk"#x"\n"); \
|
|
|
|
return false; \
|
|
|
|
} \
|
|
|
|
} while (0)
|
2020-09-28 11:43:36 +01:00
|
|
|
if (screen->info.have_EXT_transform_feedback) {
|
2020-06-01 19:59:15 +01:00
|
|
|
GET_PROC_ADDR(CmdBindTransformFeedbackBuffersEXT);
|
|
|
|
GET_PROC_ADDR(CmdBeginTransformFeedbackEXT);
|
|
|
|
GET_PROC_ADDR(CmdEndTransformFeedbackEXT);
|
|
|
|
GET_PROC_ADDR(CmdBeginQueryIndexedEXT);
|
|
|
|
GET_PROC_ADDR(CmdEndQueryIndexedEXT);
|
|
|
|
GET_PROC_ADDR(CmdDrawIndirectByteCountEXT);
|
|
|
|
}
|
2020-09-28 11:43:36 +01:00
|
|
|
if (screen->info.have_KHR_external_memory_fd)
|
2020-05-08 11:07:48 +01:00
|
|
|
GET_PROC_ADDR(GetMemoryFdKHR);
|
|
|
|
|
2020-09-28 11:43:36 +01:00
|
|
|
if (screen->info.have_EXT_conditional_rendering) {
|
2018-10-15 00:15:50 +01:00
|
|
|
GET_PROC_ADDR(CmdBeginConditionalRenderingEXT);
|
|
|
|
GET_PROC_ADDR(CmdEndConditionalRenderingEXT);
|
|
|
|
}
|
|
|
|
|
2020-09-28 11:43:36 +01:00
|
|
|
if (screen->info.have_EXT_calibrated_timestamps) {
|
2020-07-10 19:42:08 +01:00
|
|
|
GET_PROC_ADDR_INSTANCE(GetPhysicalDeviceCalibrateableTimeDomainsEXT);
|
|
|
|
GET_PROC_ADDR(GetCalibratedTimestampsEXT);
|
|
|
|
|
|
|
|
uint32_t num_domains = 0;
|
|
|
|
screen->vk_GetPhysicalDeviceCalibrateableTimeDomainsEXT(screen->pdev, &num_domains, NULL);
|
|
|
|
assert(num_domains > 0);
|
|
|
|
|
|
|
|
VkTimeDomainEXT *domains = malloc(sizeof(VkTimeDomainEXT) * num_domains);
|
|
|
|
screen->vk_GetPhysicalDeviceCalibrateableTimeDomainsEXT(screen->pdev, &num_domains, domains);
|
|
|
|
|
|
|
|
/* VK_TIME_DOMAIN_DEVICE_EXT is used for the ctx->get_timestamp hook and is the only one we really need */
|
2020-08-25 19:30:07 +01:00
|
|
|
ASSERTED bool have_device_time = false;
|
2020-07-10 19:42:08 +01:00
|
|
|
for (unsigned i = 0; i < num_domains; i++) {
|
|
|
|
if (domains[i] == VK_TIME_DOMAIN_DEVICE_EXT) {
|
|
|
|
have_device_time = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
assert(have_device_time);
|
|
|
|
free(domains);
|
|
|
|
}
|
2020-09-16 17:56:05 +01:00
|
|
|
if (screen->info.have_EXT_extended_dynamic_state) {
|
|
|
|
GET_PROC_ADDR(CmdSetViewportWithCountEXT);
|
|
|
|
GET_PROC_ADDR(CmdSetScissorWithCountEXT);
|
|
|
|
}
|
2020-07-10 19:42:08 +01:00
|
|
|
|
2020-05-08 11:07:48 +01:00
|
|
|
#undef GET_PROC_ADDR
|
2020-04-30 18:06:51 +01:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-10-02 23:27:36 +01:00
|
|
|
static struct pipe_screen *
|
2020-09-23 20:42:18 +01:00
|
|
|
zink_internal_create_screen(struct sw_winsys *winsys, int fd, const struct pipe_screen_config *config)
|
2018-08-31 15:50:20 +01:00
|
|
|
{
|
|
|
|
struct zink_screen *screen = CALLOC_STRUCT(zink_screen);
|
|
|
|
if (!screen)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
zink_debug = debug_get_option_zink_debug();
|
|
|
|
|
|
|
|
screen->instance = create_instance();
|
|
|
|
screen->pdev = choose_pdev(screen->instance);
|
2020-07-10 19:40:01 +01:00
|
|
|
update_queue_props(screen);
|
2018-08-31 15:50:20 +01:00
|
|
|
|
2019-11-06 14:26:12 +00:00
|
|
|
screen->have_X8_D24_UNORM_PACK32 = zink_is_depth_format_supported(screen,
|
|
|
|
VK_FORMAT_X8_D24_UNORM_PACK32);
|
|
|
|
screen->have_D24_UNORM_S8_UINT = zink_is_depth_format_supported(screen,
|
|
|
|
VK_FORMAT_D24_UNORM_S8_UINT);
|
2019-10-23 10:59:03 +01:00
|
|
|
|
2020-09-26 07:49:49 +01:00
|
|
|
if (!zink_get_physical_device_info(screen)) {
|
|
|
|
debug_printf("ZINK: failed to detect features\n");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fd >= 0 && !screen->info.have_KHR_external_memory_fd) {
|
|
|
|
debug_printf("ZINK: KHR_external_memory_fd required!\n");
|
|
|
|
goto fail;
|
|
|
|
}
|
2020-09-28 11:40:37 +01:00
|
|
|
|
|
|
|
VkDeviceQueueCreateInfo qci = {};
|
|
|
|
float dummy = 0.0f;
|
|
|
|
qci.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
|
|
|
|
qci.queueFamilyIndex = screen->gfx_queue;
|
|
|
|
qci.queueCount = 1;
|
|
|
|
qci.pQueuePriorities = &dummy;
|
|
|
|
|
2020-08-21 13:37:13 +01:00
|
|
|
/* TODO: we can probably support non-premul here with some work? */
|
|
|
|
screen->info.have_EXT_blend_operation_advanced = screen->info.have_EXT_blend_operation_advanced &&
|
|
|
|
screen->info.blend_props.advancedBlendNonPremultipliedSrcColor &&
|
|
|
|
screen->info.blend_props.advancedBlendNonPremultipliedDstColor;
|
|
|
|
|
2020-09-28 11:40:37 +01:00
|
|
|
VkDeviceCreateInfo dci = {};
|
|
|
|
dci.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
|
|
|
|
dci.queueCreateInfoCount = 1;
|
|
|
|
dci.pQueueCreateInfos = &qci;
|
|
|
|
/* extensions don't have bool members in pEnabledFeatures.
|
|
|
|
* this requires us to pass the whole VkPhysicalDeviceFeatures2 struct
|
|
|
|
*/
|
|
|
|
dci.pNext = &screen->info.feats;
|
|
|
|
|
|
|
|
dci.ppEnabledExtensionNames = screen->info.extensions;
|
|
|
|
dci.enabledExtensionCount = screen->info.num_extensions;
|
2020-09-26 07:49:49 +01:00
|
|
|
|
2018-08-31 15:50:20 +01:00
|
|
|
if (vkCreateDevice(screen->pdev, &dci, NULL, &screen->dev) != VK_SUCCESS)
|
|
|
|
goto fail;
|
|
|
|
|
2020-04-30 18:06:51 +01:00
|
|
|
if (!load_device_extensions(screen))
|
|
|
|
goto fail;
|
|
|
|
|
2018-08-31 15:50:20 +01:00
|
|
|
screen->winsys = winsys;
|
|
|
|
|
|
|
|
screen->base.get_name = zink_get_name;
|
|
|
|
screen->base.get_vendor = zink_get_vendor;
|
|
|
|
screen->base.get_device_vendor = zink_get_device_vendor;
|
|
|
|
screen->base.get_param = zink_get_param;
|
|
|
|
screen->base.get_paramf = zink_get_paramf;
|
|
|
|
screen->base.get_shader_param = zink_get_shader_param;
|
|
|
|
screen->base.get_compiler_options = zink_get_compiler_options;
|
|
|
|
screen->base.is_format_supported = zink_is_format_supported;
|
|
|
|
screen->base.context_create = zink_context_create;
|
|
|
|
screen->base.flush_frontbuffer = zink_flush_frontbuffer;
|
|
|
|
screen->base.destroy = zink_destroy_screen;
|
|
|
|
|
|
|
|
zink_screen_resource_init(&screen->base);
|
|
|
|
zink_screen_fence_init(&screen->base);
|
|
|
|
|
|
|
|
slab_create_parent(&screen->transfer_pool, sizeof(struct zink_transfer), 16);
|
|
|
|
|
|
|
|
return &screen->base;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
FREE(screen);
|
|
|
|
return NULL;
|
|
|
|
}
|
2018-10-02 23:27:36 +01:00
|
|
|
|
|
|
|
struct pipe_screen *
|
|
|
|
zink_create_screen(struct sw_winsys *winsys)
|
|
|
|
{
|
2020-09-23 20:42:18 +01:00
|
|
|
return zink_internal_create_screen(winsys, -1, NULL);
|
2018-10-02 23:27:36 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
struct pipe_screen *
|
2020-09-23 20:42:18 +01:00
|
|
|
zink_drm_create_screen(int fd, const struct pipe_screen_config *config)
|
2018-10-02 23:27:36 +01:00
|
|
|
{
|
2020-09-23 20:42:18 +01:00
|
|
|
return zink_internal_create_screen(NULL, fd, config);
|
2018-10-02 23:27:36 +01:00
|
|
|
}
|