src/gallium/drivers/zink/zink_screen.c

   1 /*
   2  * Copyright 2018 Collabora Ltd.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * on the rights to use, copy, modify, merge, publish, distribute, sub
   8  * license, and/or sell copies of the Software, and to permit persons to whom
   9  * the Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  18  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  21  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 #include "zink_screen.h"
  25
  26 #include "zink_kopper.h"
  27 #include "zink_compiler.h"
  28 #include "zink_context.h"
  29 #include "zink_descriptors.h"
  30 #include "zink_fence.h"
  31 #include "zink_format.h"
  32 #include "zink_framebuffer.h"
  33 #include "zink_program.h"
  34 #include "zink_public.h"
  35 #include "zink_query.h"
  36 #include "zink_resource.h"
  37 #include "zink_state.h"
  38 #include "nir_to_spirv/nir_to_spirv.h" // for SPIRV_VERSION
  39
  40 #include "os/os_process.h"
  41 #include "util/u_debug.h"
  42 #include "util/u_dl.h"
  43 #include "util/os_file.h"
  44 #include "util/u_memory.h"
  45 #include "util/u_screen.h"
  46 #include "util/u_string.h"
  47 #include "util/u_transfer_helper.h"
  48 #include "util/xmlconfig.h"
  49
  50 #include "util/u_cpu_detect.h"
  51
  52 #if DETECT_OS_WINDOWS
  53 #include <io.h>
  54 #define VK_LIBNAME "vulkan-1.dll"
  55 #else
  56 #include <unistd.h>
  57 #if DETECT_OS_APPLE
  58 #define VK_LIBNAME "libvulkan.1.dylib"
  59 #elif DETECT_OS_ANDROID
  60 #define VK_LIBNAME "libvulkan.so"
  61 #else
  62 #define VK_LIBNAME "libvulkan.so.1"
  63 #endif
  64 #endif
  65
  66 #if defined(__APPLE__)
  67 // Source of MVK_VERSION
  68 #include "MoltenVK/vk_mvk_moltenvk.h"
  69 #endif
  70
  71 static const struct debug_named_value
  72 zink_debug_options[] = {
  73    { "nir", ZINK_DEBUG_NIR, "Dump NIR during program compile" },
  74    { "spirv", ZINK_DEBUG_SPIRV, "Dump SPIR-V during program compile" },
  75    { "tgsi", ZINK_DEBUG_TGSI, "Dump TGSI during program compile" },
  76    { "validation", ZINK_DEBUG_VALIDATION, "Dump Validation layer output" },
  77    { "sync", ZINK_DEBUG_SYNC, "Force synchronization before draws/dispatches" },
  78    { "compact", ZINK_DEBUG_COMPACT, "Use only 4 descriptor sets" },
  79    { "noreorder", ZINK_DEBUG_NOREORDER, "Do not reorder command streams" },
  80    { "gpl", ZINK_DEBUG_GPL, "Force using Graphics Pipeline Library for all shaders" },
  81    { "shaderdb", ZINK_DEBUG_SHADERDB, "Do stuff to make shader-db work" },
  82    DEBUG_NAMED_VALUE_END
  83 };
  84
  85 DEBUG_GET_ONCE_FLAGS_OPTION(zink_debug, "ZINK_DEBUG", zink_debug_options, 0)
  86
  87 uint32_t
  88 zink_debug;
  89
  90
  91 static const struct debug_named_value
  92 zink_descriptor_options[] = {
  93    { "auto", ZINK_DESCRIPTOR_MODE_AUTO, "Automatically detect best mode" },
  94    { "lazy", ZINK_DESCRIPTOR_MODE_LAZY, "Don't cache, do least amount of updates" },
  95    DEBUG_NAMED_VALUE_END
  96 };
  97
  98 DEBUG_GET_ONCE_FLAGS_OPTION(zink_descriptor_mode, "ZINK_DESCRIPTORS", zink_descriptor_options, ZINK_DESCRIPTOR_MODE_AUTO)
  99
 100 enum zink_descriptor_mode zink_descriptor_mode;
 101
 102 static const char *
 103 zink_get_vendor(struct pipe_screen *pscreen)
 104 {
 105    return "Collabora Ltd";
 106 }
 107
 108 static const char *
 109 zink_get_device_vendor(struct pipe_screen *pscreen)
 110 {
 111    struct zink_screen *screen = zink_screen(pscreen);
 112    static char buf[1000];
 113    snprintf(buf, sizeof(buf), "Unknown (vendor-id: 0x%04x)", screen->info.props.vendorID);
 114    return buf;
 115 }
 116
 117 static const char *
 118 zink_get_name(struct pipe_screen *pscreen)
 119 {
 120    struct zink_screen *screen = zink_screen(pscreen);
 121    static char buf[1000];
 122    snprintf(buf, sizeof(buf), "zink (%s)", screen->info.props.deviceName);
 123    return buf;
 124 }
 125
 126 static void
 127 zink_get_driver_uuid(struct pipe_screen *pscreen, char *uuid)
 128 {
 129    struct zink_screen *screen = zink_screen(pscreen);
 130    if (screen->vk_version >= VK_MAKE_VERSION(1,2,0)) {
 131       memcpy(uuid, screen->info.props11.driverUUID, VK_UUID_SIZE);
 132    } else {
 133       memcpy(uuid, screen->info.deviceid_props.driverUUID, VK_UUID_SIZE);
 134    }
 135 }
 136
 137 static void
 138 zink_get_device_uuid(struct pipe_screen *pscreen, char *uuid)
 139 {
 140    struct zink_screen *screen = zink_screen(pscreen);
 141    if (screen->vk_version >= VK_MAKE_VERSION(1,2,0)) {
 142       memcpy(uuid, screen->info.props11.deviceUUID, VK_UUID_SIZE);
 143    } else {
 144       memcpy(uuid, screen->info.deviceid_props.deviceUUID, VK_UUID_SIZE);
 145    }
 146 }
 147
 148 static void
 149 zink_get_device_luid(struct pipe_screen *pscreen, char *luid)
 150 {
 151    struct zink_screen *screen = zink_screen(pscreen);
 152    if (screen->info.have_vulkan12) {
 153       memcpy(luid, screen->info.props11.deviceLUID, VK_LUID_SIZE);
 154    } else {
 155       memcpy(luid, screen->info.deviceid_props.deviceLUID, VK_LUID_SIZE);
 156    }
 157 }
 158
 159 static uint32_t
 160 zink_get_device_node_mask(struct pipe_screen *pscreen)
 161 {
 162    struct zink_screen *screen = zink_screen(pscreen);
 163    if (screen->info.have_vulkan12) {
 164       return screen->info.props11.deviceNodeMask;
 165    } else {
 166       return screen->info.deviceid_props.deviceNodeMask;
 167    }
 168 }
 169
 170 static void
 171 zink_set_max_shader_compiler_threads(struct pipe_screen *pscreen, unsigned max_threads)
 172 {
 173    struct zink_screen *screen = zink_screen(pscreen);
 174    util_queue_adjust_num_threads(&screen->cache_get_thread, max_threads);
 175 }
 176
 177 static bool
 178 zink_is_parallel_shader_compilation_finished(struct pipe_screen *screen, void *shader, enum pipe_shader_type shader_type)
 179 {
 180    if (shader_type == MESA_SHADER_COMPUTE) {
 181       struct zink_program *pg = shader;
 182       return !pg->can_precompile || util_queue_fence_is_signalled(&pg->cache_fence);
 183    }
 184
 185    struct zink_shader *zs = shader;
 186    bool finished = true;
 187    set_foreach(zs->programs, entry) {
 188       struct zink_gfx_program *prog = (void*)entry->key;
 189       finished &= util_queue_fence_is_signalled(&prog->base.cache_fence);
 190    }
 191    return finished;
 192 }
 193
 194 static VkDeviceSize
 195 get_video_mem(struct zink_screen *screen)
 196 {
 197    VkDeviceSize size = 0;
 198    for (uint32_t i = 0; i < screen->info.mem_props.memoryHeapCount; ++i) {
 199       if (screen->info.mem_props.memoryHeaps[i].flags &
 200           VK_MEMORY_HEAP_DEVICE_LOCAL_BIT)
 201          size += screen->info.mem_props.memoryHeaps[i].size;
 202    }
 203    return size;
 204 }
 205
 206 static bool
 207 disk_cache_init(struct zink_screen *screen)
 208 {
 209    if (zink_debug & ZINK_DEBUG_SHADERDB)
 210       return true;
 211 #ifdef ENABLE_SHADER_CACHE
 212    static char buf[1000];
 213    snprintf(buf, sizeof(buf), "zink_%x04x", screen->info.props.vendorID);
 214
 215    screen->disk_cache = disk_cache_create(buf, screen->info.props.deviceName, 0);
 216    if (!screen->disk_cache)
 217       return true;
 218
 219    if (!util_queue_init(&screen->cache_put_thread, "zcq", 8, 1, UTIL_QUEUE_INIT_RESIZE_IF_FULL, screen)) {
 220       mesa_loge("zink: Failed to create disk cache queue\n");
 221
 222       disk_cache_destroy(screen->disk_cache);
 223       screen->disk_cache = NULL;
 224
 225       util_queue_destroy(&screen->cache_put_thread);
 226
 227       return false;
 228    }
 229 #endif
 230
 231    return true;
 232 }
 233
 234
 235 static void
 236 cache_put_job(void *data, void *gdata, int thread_index)
 237 {
 238    struct zink_program *pg = data;
 239    struct zink_screen *screen = gdata;
 240    size_t size = 0;
 241    VkResult result = VKSCR(GetPipelineCacheData)(screen->dev, pg->pipeline_cache, &size, NULL);
 242    if (result != VK_SUCCESS) {
 243       mesa_loge("ZINK: vkGetPipelineCacheData failed (%s)", vk_Result_to_str(result));
 244       return;
 245    }
 246    if (pg->pipeline_cache_size == size)
 247       return;
 248    void *pipeline_data = malloc(size);
 249    if (!pipeline_data)
 250       return;
 251    result = VKSCR(GetPipelineCacheData)(screen->dev, pg->pipeline_cache, &size, pipeline_data);
 252    if (result == VK_SUCCESS) {
 253       pg->pipeline_cache_size = size;
 254
 255       cache_key key;
 256       disk_cache_compute_key(screen->disk_cache, pg->sha1, sizeof(pg->sha1), key);
 257       disk_cache_put_nocopy(screen->disk_cache, key, pipeline_data, size, NULL);
 258    } else {
 259       mesa_loge("ZINK: vkGetPipelineCacheData failed (%s)", vk_Result_to_str(result));
 260    }
 261 }
 262
 263 void
 264 zink_screen_update_pipeline_cache(struct zink_screen *screen, struct zink_program *pg, bool in_thread)
 265 {
 266    if (!screen->disk_cache)
 267       return;
 268
 269    if (in_thread)
 270       cache_put_job(pg, screen, 0);
 271    else
 272       util_queue_add_job(&screen->cache_put_thread, pg, &pg->cache_fence, cache_put_job, NULL, 0);
 273 }
 274
 275 static void
 276 cache_get_job(void *data, void *gdata, int thread_index)
 277 {
 278    struct zink_program *pg = data;
 279    struct zink_screen *screen = gdata;
 280
 281    VkPipelineCacheCreateInfo pcci;
 282    pcci.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
 283    pcci.pNext = NULL;
 284    pcci.flags = screen->info.have_EXT_pipeline_creation_cache_control || screen->info.feats13.pipelineCreationCacheControl ?
 285                 VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT : 0;
 286    pcci.initialDataSize = 0;
 287    pcci.pInitialData = NULL;
 288
 289    cache_key key;
 290    disk_cache_compute_key(screen->disk_cache, pg->sha1, sizeof(pg->sha1), key);
 291    pcci.pInitialData = disk_cache_get(screen->disk_cache, key, &pg->pipeline_cache_size);
 292    pcci.initialDataSize = pg->pipeline_cache_size;
 293
 294    VkResult res = VKSCR(CreatePipelineCache)(screen->dev, &pcci, NULL, &pg->pipeline_cache);
 295    if (res != VK_SUCCESS) {
 296       mesa_loge("ZINK: vkCreatePipelineCache failed (%s)", vk_Result_to_str(res));
 297    }
 298    free((void*)pcci.pInitialData);
 299 }
 300
 301 void
 302 zink_screen_get_pipeline_cache(struct zink_screen *screen, struct zink_program *pg, bool in_thread)
 303 {
 304    if (!screen->disk_cache)
 305       return;
 306
 307    if (in_thread)
 308       cache_get_job(pg, screen, 0);
 309    else
 310       util_queue_add_job(&screen->cache_get_thread, pg, &pg->cache_fence, cache_get_job, NULL, 0);
 311 }
 312
 313 static int
 314 zink_get_compute_param(struct pipe_screen *pscreen, enum pipe_shader_ir ir_type,
 315                        enum pipe_compute_cap param, void *ret)
 316 {
 317    struct zink_screen *screen = zink_screen(pscreen);
 318 #define RET(x) do {                  \
 319    if (ret)                          \
 320       memcpy(ret, x, sizeof(x));     \
 321    return sizeof(x);                 \
 322 } while (0)
 323
 324    switch (param) {
 325    case PIPE_COMPUTE_CAP_ADDRESS_BITS:
 326       RET((uint32_t []){ 32 });
 327
 328    case PIPE_COMPUTE_CAP_IR_TARGET:
 329       if (ret)
 330          strcpy(ret, "nir");
 331       return 4;
 332
 333    case PIPE_COMPUTE_CAP_GRID_DIMENSION:
 334       RET((uint64_t []) { 3 });
 335
 336    case PIPE_COMPUTE_CAP_MAX_GRID_SIZE:
 337       RET(((uint64_t []) { screen->info.props.limits.maxComputeWorkGroupCount[0],
 338                            screen->info.props.limits.maxComputeWorkGroupCount[1],
 339                            screen->info.props.limits.maxComputeWorkGroupCount[2] }));
 340
 341    case PIPE_COMPUTE_CAP_MAX_BLOCK_SIZE:
 342       /* MaxComputeWorkGroupSize[0..2] */
 343       RET(((uint64_t []) {screen->info.props.limits.maxComputeWorkGroupSize[0],
 344                           screen->info.props.limits.maxComputeWorkGroupSize[1],
 345                           screen->info.props.limits.maxComputeWorkGroupSize[2]}));
 346
 347    case PIPE_COMPUTE_CAP_MAX_THREADS_PER_BLOCK:
 348    case PIPE_COMPUTE_CAP_MAX_VARIABLE_THREADS_PER_BLOCK:
 349       RET((uint64_t []) { screen->info.props.limits.maxComputeWorkGroupInvocations });
 350
 351    case PIPE_COMPUTE_CAP_MAX_LOCAL_SIZE:
 352       RET((uint64_t []) { screen->info.props.limits.maxComputeSharedMemorySize });
 353
 354    case PIPE_COMPUTE_CAP_IMAGES_SUPPORTED:
 355       RET((uint32_t []) { 1 });
 356
 357    case PIPE_COMPUTE_CAP_SUBGROUP_SIZE:
 358       RET((uint32_t []) { screen->info.props11.subgroupSize });
 359
 360    case PIPE_COMPUTE_CAP_MAX_MEM_ALLOC_SIZE:
 361    case PIPE_COMPUTE_CAP_MAX_CLOCK_FREQUENCY:
 362    case PIPE_COMPUTE_CAP_MAX_COMPUTE_UNITS:
 363    case PIPE_COMPUTE_CAP_MAX_GLOBAL_SIZE:
 364    case PIPE_COMPUTE_CAP_MAX_PRIVATE_SIZE:
 365    case PIPE_COMPUTE_CAP_MAX_INPUT_SIZE:
 366       // XXX: I think these are for Clover...
 367       return 0;
 368
 369    default:
 370       unreachable("unknown compute param");
 371    }
 372 }
 373
 374 static uint32_t
 375 get_smallest_buffer_heap(struct zink_screen *screen)
 376 {
 377    enum zink_heap heaps[] = {
 378       ZINK_HEAP_DEVICE_LOCAL,
 379       ZINK_HEAP_DEVICE_LOCAL_VISIBLE,
 380       ZINK_HEAP_HOST_VISIBLE_COHERENT,
 381       ZINK_HEAP_HOST_VISIBLE_COHERENT
 382    };
 383    unsigned size = UINT32_MAX;
 384    for (unsigned i = 0; i < ARRAY_SIZE(heaps); i++) {
 385       unsigned heap_idx = screen->info.mem_props.memoryTypes[screen->heap_map[i]].heapIndex;
 386       size = MIN2(screen->info.mem_props.memoryHeaps[heap_idx].size, size);
 387    }
 388    return size;
 389 }
 390
 391 static inline bool
 392 have_fp32_filter_linear(struct zink_screen *screen)
 393 {
 394    const VkFormat fp32_formats[] = {
 395       VK_FORMAT_R32_SFLOAT,
 396       VK_FORMAT_R32G32_SFLOAT,
 397       VK_FORMAT_R32G32B32_SFLOAT,
 398       VK_FORMAT_R32G32B32A32_SFLOAT,
 399       VK_FORMAT_D32_SFLOAT,
 400    };
 401    for (int i = 0; i < ARRAY_SIZE(fp32_formats); ++i) {
 402       VkFormatProperties props;
 403       VKSCR(GetPhysicalDeviceFormatProperties)(screen->pdev,
 404                                                fp32_formats[i],
 405                                                &props);
 406       if (((props.linearTilingFeatures | props.optimalTilingFeatures) &
 407            (VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
 408             VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT)) ==
 409           VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) {
 410          return false;
 411       }
 412    }
 413    return true;
 414 }
 415
 416 static int
 417 zink_get_param(struct pipe_screen *pscreen, enum pipe_cap param)
 418 {
 419    struct zink_screen *screen = zink_screen(pscreen);
 420
 421    switch (param) {
 422    case PIPE_CAP_TEXRECT:
 423    case PIPE_CAP_MULTI_DRAW_INDIRECT_PARTIAL_STRIDE:
 424       return 0;
 425    case PIPE_CAP_ANISOTROPIC_FILTER:
 426       return screen->info.feats.features.samplerAnisotropy;
 427    case PIPE_CAP_EMULATE_NONFIXED_PRIMITIVE_RESTART:
 428       return 1;
 429    case PIPE_CAP_SUPPORTED_PRIM_MODES_WITH_RESTART: {
 430       uint32_t modes = BITFIELD_BIT(PIPE_PRIM_LINE_STRIP) |
 431                        BITFIELD_BIT(PIPE_PRIM_TRIANGLE_STRIP) |
 432                        BITFIELD_BIT(PIPE_PRIM_LINE_STRIP_ADJACENCY) |
 433                        BITFIELD_BIT(PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY);
 434       if (screen->have_triangle_fans)
 435          modes |= BITFIELD_BIT(PIPE_PRIM_TRIANGLE_FAN);
 436       if (screen->info.have_EXT_primitive_topology_list_restart) {
 437          modes |= BITFIELD_BIT(PIPE_PRIM_POINTS) |
 438                   BITFIELD_BIT(PIPE_PRIM_LINES) |
 439                   BITFIELD_BIT(PIPE_PRIM_LINES_ADJACENCY) |
 440                   BITFIELD_BIT(PIPE_PRIM_TRIANGLES) |
 441                   BITFIELD_BIT(PIPE_PRIM_TRIANGLES_ADJACENCY);
 442          if (screen->info.list_restart_feats.primitiveTopologyPatchListRestart)
 443             modes |= BITFIELD_BIT(PIPE_PRIM_PATCHES);
 444       }
 445       return modes;
 446    }
 447    case PIPE_CAP_SUPPORTED_PRIM_MODES: {
 448       uint32_t modes = BITFIELD_MASK(PIPE_PRIM_MAX);
 449       modes &= ~BITFIELD_BIT(PIPE_PRIM_QUADS);
 450       modes &= ~BITFIELD_BIT(PIPE_PRIM_QUAD_STRIP);
 451       modes &= ~BITFIELD_BIT(PIPE_PRIM_POLYGON);
 452       modes &= ~BITFIELD_BIT(PIPE_PRIM_LINE_LOOP);
 453       if (!screen->have_triangle_fans)
 454          modes &= ~BITFIELD_BIT(PIPE_PRIM_TRIANGLE_FAN);
 455       return modes;
 456    }
 457
 458    case PIPE_CAP_FBFETCH:
 459       return 1;
 460    case PIPE_CAP_FBFETCH_COHERENT:
 461       return screen->info.have_EXT_rasterization_order_attachment_access;
 462
 463    case PIPE_CAP_MEMOBJ:
 464       return screen->instance_info.have_KHR_external_memory_capabilities && (screen->info.have_KHR_external_memory_fd || screen->info.have_KHR_external_memory_win32);
 465    case PIPE_CAP_FENCE_SIGNAL:
 466       return screen->info.have_KHR_external_semaphore_fd || screen->info.have_KHR_external_semaphore_win32;
 467    case PIPE_CAP_NATIVE_FENCE_FD:
 468       return screen->instance_info.have_KHR_external_semaphore_capabilities && screen->info.have_KHR_external_semaphore_fd;
 469
 470    case PIPE_CAP_ALLOW_MAPPED_BUFFERS_DURING_EXECUTION:
 471    case PIPE_CAP_MAP_UNSYNCHRONIZED_THREAD_SAFE:
 472    case PIPE_CAP_SHAREABLE_SHADERS:
 473    case PIPE_CAP_DEVICE_RESET_STATUS_QUERY:
 474    case PIPE_CAP_QUERY_MEMORY_INFO:
 475    case PIPE_CAP_NPOT_TEXTURES:
 476    case PIPE_CAP_TGSI_TEXCOORD:
 477    case PIPE_CAP_DRAW_INDIRECT:
 478    case PIPE_CAP_TEXTURE_QUERY_LOD:
 479    case PIPE_CAP_GLSL_TESS_LEVELS_AS_INPUTS:
 480    case PIPE_CAP_CLEAR_TEXTURE:
 481    case PIPE_CAP_COPY_BETWEEN_COMPRESSED_AND_PLAIN_FORMATS:
 482    case PIPE_CAP_FORCE_PERSAMPLE_INTERP:
 483    case PIPE_CAP_FRAMEBUFFER_NO_ATTACHMENT:
 484    case PIPE_CAP_BUFFER_MAP_PERSISTENT_COHERENT:
 485    case PIPE_CAP_SHADER_ARRAY_COMPONENTS:
 486    case PIPE_CAP_QUERY_BUFFER_OBJECT:
 487    case PIPE_CAP_CONDITIONAL_RENDER_INVERTED:
 488    case PIPE_CAP_CLIP_HALFZ:
 489    case PIPE_CAP_TEXTURE_QUERY_SAMPLES:
 490    case PIPE_CAP_TEXTURE_BARRIER:
 491    case PIPE_CAP_QUERY_SO_OVERFLOW:
 492    case PIPE_CAP_GL_SPIRV:
 493    case PIPE_CAP_CLEAR_SCISSORED:
 494    case PIPE_CAP_INVALIDATE_BUFFER:
 495    case PIPE_CAP_PREFER_REAL_BUFFER_IN_CONSTBUF0:
 496    case PIPE_CAP_PACKED_UNIFORMS:
 497    case PIPE_CAP_SHADER_PACK_HALF_FLOAT:
 498    case PIPE_CAP_CULL_DISTANCE_NOCOMBINE:
 499    case PIPE_CAP_SEAMLESS_CUBE_MAP_PER_TEXTURE:
 500    case PIPE_CAP_LOAD_CONSTBUF:
 501    case PIPE_CAP_MULTISAMPLE_Z_RESOLVE:
 502    case PIPE_CAP_RGB_OVERRIDE_DST_ALPHA_BLEND:
 503       return 1;
 504
 505    case PIPE_CAP_DRAW_VERTEX_STATE:
 506       return screen->info.have_EXT_vertex_input_dynamic_state;
 507
 508    case PIPE_CAP_SURFACE_SAMPLE_COUNT:
 509       return screen->vk_version >= VK_MAKE_VERSION(1,2,0);
 510
 511    case PIPE_CAP_SHADER_GROUP_VOTE:
 512       if (screen->info.have_vulkan11 &&
 513           (screen->info.subgroup.supportedOperations & VK_SUBGROUP_FEATURE_VOTE_BIT) &&
 514           (screen->info.subgroup.supportedStages & VK_SHADER_STAGE_COMPUTE_BIT))
 515          return true;
 516       if (screen->info.have_EXT_shader_subgroup_vote)
 517          return true;
 518       return false;
 519    case PIPE_CAP_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION:
 520       return screen->info.have_EXT_provoking_vertex;
 521
 522    case PIPE_CAP_TEXTURE_MIRROR_CLAMP_TO_EDGE:
 523       return screen->info.have_KHR_sampler_mirror_clamp_to_edge;
 524
 525    case PIPE_CAP_POLYGON_OFFSET_UNITS_UNSCALED:
 526       return 1;
 527
 528    case PIPE_CAP_POLYGON_OFFSET_CLAMP:
 529       return screen->info.feats.features.depthBiasClamp;
 530
 531    case PIPE_CAP_QUERY_PIPELINE_STATISTICS_SINGLE:
 532       return screen->info.feats.features.pipelineStatisticsQuery;
 533
 534    case PIPE_CAP_ROBUST_BUFFER_ACCESS_BEHAVIOR:
 535       return screen->info.feats.features.robustBufferAccess;
 536
 537    case PIPE_CAP_MULTI_DRAW_INDIRECT:
 538       return screen->info.feats.features.multiDrawIndirect;
 539
 540    case PIPE_CAP_IMAGE_ATOMIC_FLOAT_ADD:
 541       return screen->info.have_EXT_shader_atomic_float;
 542    case PIPE_CAP_SHADER_ATOMIC_INT64:
 543       return screen->info.have_KHR_shader_atomic_int64;
 544
 545    case PIPE_CAP_MULTI_DRAW_INDIRECT_PARAMS:
 546       return screen->info.have_KHR_draw_indirect_count;
 547
 548    case PIPE_CAP_START_INSTANCE:
 549    case PIPE_CAP_DRAW_PARAMETERS:
 550       return (screen->info.have_vulkan12 && screen->info.feats11.shaderDrawParameters) ||
 551               screen->info.have_KHR_shader_draw_parameters;
 552
 553    case PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR:
 554       return screen->info.have_EXT_vertex_attribute_divisor;
 555
 556    case PIPE_CAP_MAX_VERTEX_STREAMS:
 557       return screen->info.tf_props.maxTransformFeedbackStreams;
 558
 559    case PIPE_CAP_INT64:
 560    case PIPE_CAP_INT64_DIVMOD:
 561    case PIPE_CAP_DOUBLES:
 562       return 1;
 563
 564    case PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS:
 565       if (!screen->info.feats.features.dualSrcBlend)
 566          return 0;
 567       return screen->info.props.limits.maxFragmentDualSrcAttachments;
 568
 569    case PIPE_CAP_MAX_RENDER_TARGETS:
 570       return screen->info.props.limits.maxColorAttachments;
 571
 572    case PIPE_CAP_OCCLUSION_QUERY:
 573       return screen->info.feats.features.occlusionQueryPrecise;
 574
 575    case PIPE_CAP_PROGRAMMABLE_SAMPLE_LOCATIONS:
 576       return screen->info.have_EXT_sample_locations && screen->info.have_EXT_extended_dynamic_state;
 577
 578    case PIPE_CAP_QUERY_TIME_ELAPSED:
 579       return screen->timestamp_valid_bits > 0;
 580
 581    case PIPE_CAP_TEXTURE_MULTISAMPLE:
 582       return 1;
 583
 584    case PIPE_CAP_FRAGMENT_SHADER_INTERLOCK:
 585       return screen->info.have_EXT_fragment_shader_interlock;
 586
 587    case PIPE_CAP_SHADER_CLOCK:
 588       return screen->info.have_KHR_shader_clock;
 589
 590    case PIPE_CAP_POINT_SPRITE:
 591       return 1;
 592
 593    case PIPE_CAP_SHADER_BALLOT:
 594       if (screen->info.props11.subgroupSize > 64)
 595          return false;
 596       if (screen->info.have_vulkan11 &&
 597           screen->info.subgroup.supportedOperations & VK_SUBGROUP_FEATURE_BALLOT_BIT)
 598          return true;
 599       if (screen->info.have_EXT_shader_subgroup_ballot)
 600          return true;
 601       return false;
 602
 603    case PIPE_CAP_DEMOTE_TO_HELPER_INVOCATION:
 604       return screen->info.have_EXT_shader_demote_to_helper_invocation;
 605
 606    case PIPE_CAP_SAMPLE_SHADING:
 607       return screen->info.feats.features.sampleRateShading;
 608
 609    case PIPE_CAP_TEXTURE_SWIZZLE:
 610       return 1;
 611
 612    case PIPE_CAP_VERTEX_ATTRIB_ELEMENT_ALIGNED_ONLY:
 613       return 1;
 614
 615    case PIPE_CAP_GL_CLAMP:
 616       return 0;
 617
 618    case PIPE_CAP_PREFER_IMM_ARRAYS_AS_CONSTBUF:
 619       return 0; /* Assume that the vk driver is capable of moving imm arrays to some sort of constant storage on its own. */
 620
 621    case PIPE_CAP_TEXTURE_BORDER_COLOR_QUIRK: {
 622       enum pipe_quirk_texture_border_color_swizzle quirk = PIPE_QUIRK_TEXTURE_BORDER_COLOR_SWIZZLE_ALPHA_NOT_W;
 623       if (!screen->info.border_color_feats.customBorderColorWithoutFormat)
 624          return quirk | PIPE_QUIRK_TEXTURE_BORDER_COLOR_SWIZZLE_FREEDRENO;
 625       /* assume that if drivers don't implement this extension they either:
 626        * - don't support custom border colors
 627        * - handle things correctly
 628        * - hate border color accuracy
 629        */
 630       if (screen->info.have_EXT_border_color_swizzle &&
 631           !screen->info.border_swizzle_feats.borderColorSwizzleFromImage)
 632          return quirk | PIPE_QUIRK_TEXTURE_BORDER_COLOR_SWIZZLE_NV50;
 633       return quirk;
 634    }
 635
 636    case PIPE_CAP_MAX_TEXTURE_2D_SIZE:
 637       return screen->info.props.limits.maxImageDimension2D;
 638    case PIPE_CAP_MAX_TEXTURE_3D_LEVELS:
 639       return 1 + util_logbase2(screen->info.props.limits.maxImageDimension3D);
 640    case PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS:
 641       return 1 + util_logbase2(screen->info.props.limits.maxImageDimensionCube);
 642
 643    case PIPE_CAP_FRAGMENT_SHADER_TEXTURE_LOD:
 644    case PIPE_CAP_FRAGMENT_SHADER_DERIVATIVES:
 645       return 1;
 646
 647    case PIPE_CAP_BLEND_EQUATION_SEPARATE:
 648    case PIPE_CAP_INDEP_BLEND_ENABLE:
 649    case PIPE_CAP_INDEP_BLEND_FUNC:
 650       return screen->info.feats.features.independentBlend;
 651
 652    case PIPE_CAP_DITHERING:
 653       return 0;
 654
 655    case PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS:
 656       return screen->info.have_EXT_transform_feedback ? screen->info.tf_props.maxTransformFeedbackBuffers : 0;
 657    case PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME:
 658    case PIPE_CAP_STREAM_OUTPUT_INTERLEAVE_BUFFERS:
 659       return screen->info.have_EXT_transform_feedback;
 660
 661    case PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS:
 662       return screen->info.props.limits.maxImageArrayLayers;
 663
 664    case PIPE_CAP_DEPTH_CLIP_DISABLE:
 665       return !screen->driver_workarounds.depth_clip_control_missing;
 666
 667    case PIPE_CAP_SHADER_STENCIL_EXPORT:
 668       return screen->info.have_EXT_shader_stencil_export;
 669
 670    case PIPE_CAP_VS_INSTANCEID:
 671    case PIPE_CAP_MIXED_COLORBUFFER_FORMATS:
 672    case PIPE_CAP_SEAMLESS_CUBE_MAP:
 673       return 1;
 674
 675    case PIPE_CAP_MIN_TEXEL_OFFSET:
 676       return screen->info.props.limits.minTexelOffset;
 677    case PIPE_CAP_MAX_TEXEL_OFFSET:
 678       return screen->info.props.limits.maxTexelOffset;
 679
 680    case PIPE_CAP_VERTEX_COLOR_UNCLAMPED:
 681       return 1;
 682
 683    case PIPE_CAP_CONDITIONAL_RENDER:
 684      return 1;
 685
 686    case PIPE_CAP_GLSL_FEATURE_LEVEL_COMPATIBILITY:
 687    case PIPE_CAP_GLSL_FEATURE_LEVEL:
 688       return 460;
 689
 690    case PIPE_CAP_COMPUTE:
 691       return 1;
 692
 693    case PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT:
 694       return screen->info.props.limits.minUniformBufferOffsetAlignment;
 695
 696    case PIPE_CAP_QUERY_TIMESTAMP:
 697       return screen->timestamp_valid_bits > 0;
 698
 699    case PIPE_CAP_QUERY_TIMESTAMP_BITS:
 700       return screen->timestamp_valid_bits;
 701
 702    case PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT:
 703       return 1 << MIN_SLAB_ORDER;
 704
 705    case PIPE_CAP_CUBE_MAP_ARRAY:
 706       return screen->info.feats.features.imageCubeArray;
 707
 708    case PIPE_CAP_TEXTURE_BUFFER_OBJECTS:
 709    case PIPE_CAP_PRIMITIVE_RESTART:
 710       return 1;
 711
 712    case PIPE_CAP_BINDLESS_TEXTURE:
 713       return screen->info.have_EXT_descriptor_indexing;
 714
 715    case PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT:
 716       return screen->info.props.limits.minTexelBufferOffsetAlignment;
 717
 718    case PIPE_CAP_TEXTURE_TRANSFER_MODES: {
 719       enum pipe_texture_transfer_mode mode = PIPE_TEXTURE_TRANSFER_BLIT;
 720       if (!screen->is_cpu &&
 721           /* this needs substantial perf tuning */
 722           screen->info.driver_props.driverID != VK_DRIVER_ID_MESA_TURNIP &&
 723           screen->info.have_KHR_8bit_storage &&
 724           screen->info.have_KHR_16bit_storage &&
 725           screen->info.have_KHR_shader_float16_int8)
 726          mode |= PIPE_TEXTURE_TRANSFER_COMPUTE;
 727       return mode;
 728    }
 729
 730    case PIPE_CAP_MAX_TEXEL_BUFFER_ELEMENTS_UINT:
 731       return MIN2(get_smallest_buffer_heap(screen),
 732                   screen->info.props.limits.maxTexelBufferElements);
 733
 734    case PIPE_CAP_ENDIANNESS:
 735       return PIPE_ENDIAN_NATIVE; /* unsure */
 736
 737    case PIPE_CAP_MAX_VIEWPORTS:
 738       return MIN2(screen->info.props.limits.maxViewports, PIPE_MAX_VIEWPORTS);
 739
 740    case PIPE_CAP_IMAGE_LOAD_FORMATTED:
 741       return screen->info.feats.features.shaderStorageImageReadWithoutFormat;
 742
 743    case PIPE_CAP_IMAGE_STORE_FORMATTED:
 744       return screen->info.feats.features.shaderStorageImageWriteWithoutFormat;
 745
 746    case PIPE_CAP_MIXED_FRAMEBUFFER_SIZES:
 747       return 1;
 748
 749    case PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES:
 750       return screen->info.props.limits.maxGeometryOutputVertices;
 751    case PIPE_CAP_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS:
 752       return screen->info.props.limits.maxGeometryTotalOutputComponents;
 753
 754    case PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS:
 755       return 4;
 756
 757    case PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET:
 758       return screen->info.props.limits.minTexelGatherOffset;
 759    case PIPE_CAP_MAX_TEXTURE_GATHER_OFFSET:
 760       return screen->info.props.limits.maxTexelGatherOffset;
 761
 762    case PIPE_CAP_SAMPLER_REDUCTION_MINMAX_ARB:
 763       return screen->info.feats12.samplerFilterMinmax || screen->info.have_EXT_sampler_filter_minmax;
 764
 765    case PIPE_CAP_FS_FINE_DERIVATIVE:
 766       return 1;
 767
 768    case PIPE_CAP_VENDOR_ID:
 769       return screen->info.props.vendorID;
 770    case PIPE_CAP_DEVICE_ID:
 771       return screen->info.props.deviceID;
 772
 773    case PIPE_CAP_ACCELERATED:
 774       return !screen->is_cpu;
 775    case PIPE_CAP_VIDEO_MEMORY:
 776       return get_video_mem(screen) >> 20;
 777    case PIPE_CAP_UMA:
 778       return screen->info.props.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
 779
 780    case PIPE_CAP_MAX_VERTEX_ATTRIB_STRIDE:
 781       return screen->info.props.limits.maxVertexInputBindingStride;
 782
 783    case PIPE_CAP_SAMPLER_VIEW_TARGET:
 784       return 1;
 785
 786    case PIPE_CAP_VS_LAYER_VIEWPORT:
 787    case PIPE_CAP_TES_LAYER_VIEWPORT:
 788       return screen->info.have_EXT_shader_viewport_index_layer ||
 789              (screen->spirv_version >= SPIRV_VERSION(1, 5) &&
 790               screen->info.feats12.shaderOutputLayer &&
 791               screen->info.feats12.shaderOutputViewportIndex);
 792
 793    case PIPE_CAP_TEXTURE_FLOAT_LINEAR:
 794       return have_fp32_filter_linear(screen);
 795
 796    case PIPE_CAP_TEXTURE_HALF_FLOAT_LINEAR:
 797       return 1;
 798
 799    case PIPE_CAP_SHADER_BUFFER_OFFSET_ALIGNMENT:
 800       return screen->info.props.limits.minStorageBufferOffsetAlignment;
 801
 802    case PIPE_CAP_PCI_GROUP:
 803    case PIPE_CAP_PCI_BUS:
 804    case PIPE_CAP_PCI_DEVICE:
 805    case PIPE_CAP_PCI_FUNCTION:
 806       return 0; /* TODO: figure these out */
 807
 808    case PIPE_CAP_CULL_DISTANCE:
 809       return screen->info.feats.features.shaderCullDistance;
 810
 811    case PIPE_CAP_SPARSE_BUFFER_PAGE_SIZE:
 812       return screen->info.feats.features.sparseBinding ? ZINK_SPARSE_BUFFER_PAGE_SIZE : 0;
 813
 814    /* Sparse texture */
 815    case PIPE_CAP_MAX_SPARSE_TEXTURE_SIZE:
 816       return screen->info.feats.features.sparseResidencyImage2D ?
 817          zink_get_param(pscreen, PIPE_CAP_MAX_TEXTURE_2D_SIZE) : 0;
 818    case PIPE_CAP_MAX_SPARSE_3D_TEXTURE_SIZE:
 819       return screen->info.feats.features.sparseResidencyImage3D ?
 820          (1 << (zink_get_param(pscreen, PIPE_CAP_MAX_TEXTURE_3D_LEVELS) - 1)) : 0;
 821    case PIPE_CAP_MAX_SPARSE_ARRAY_TEXTURE_LAYERS:
 822       return screen->info.feats.features.sparseResidencyImage2D ?
 823          zink_get_param(pscreen, PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS) : 0;
 824    case PIPE_CAP_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS:
 825       return screen->info.feats.features.sparseResidencyImage2D ? 1 : 0;
 826    case PIPE_CAP_QUERY_SPARSE_TEXTURE_RESIDENCY:
 827    case PIPE_CAP_CLAMP_SPARSE_TEXTURE_LOD:
 828       return screen->info.feats.features.sparseResidency2Samples ? 1 : 0;
 829
 830    case PIPE_CAP_VIEWPORT_SUBPIXEL_BITS:
 831       return screen->info.props.limits.viewportSubPixelBits;
 832
 833    case PIPE_CAP_MAX_GS_INVOCATIONS:
 834       return screen->info.props.limits.maxGeometryShaderInvocations;
 835
 836    case PIPE_CAP_MAX_COMBINED_SHADER_BUFFERS:
 837       /* gallium handles this automatically */
 838       return 0;
 839
 840    case PIPE_CAP_MAX_SHADER_BUFFER_SIZE_UINT:
 841       /* 1<<27 is required by VK spec */
 842       assert(screen->info.props.limits.maxStorageBufferRange >= 1 << 27);
 843       /* clamp to VK spec minimum */
 844       return MIN2(get_smallest_buffer_heap(screen), screen->info.props.limits.maxStorageBufferRange);
 845
 846    case PIPE_CAP_FS_COORD_ORIGIN_UPPER_LEFT:
 847    case PIPE_CAP_FS_COORD_PIXEL_CENTER_HALF_INTEGER:
 848       return 1;
 849
 850    case PIPE_CAP_FS_COORD_ORIGIN_LOWER_LEFT:
 851    case PIPE_CAP_FS_COORD_PIXEL_CENTER_INTEGER:
 852       return 0;
 853
 854    case PIPE_CAP_NIR_COMPACT_ARRAYS:
 855       return 1;
 856
 857    case PIPE_CAP_FS_FACE_IS_INTEGER_SYSVAL:
 858       return 1;
 859
 860    case PIPE_CAP_VIEWPORT_TRANSFORM_LOWERED:
 861       return 1;
 862
 863    case PIPE_CAP_FLATSHADE:
 864    case PIPE_CAP_ALPHA_TEST:
 865    case PIPE_CAP_CLIP_PLANES:
 866    case PIPE_CAP_POINT_SIZE_FIXED:
 867    case PIPE_CAP_TWO_SIDED_COLOR:
 868       return 0;
 869
 870    case PIPE_CAP_MAX_SHADER_PATCH_VARYINGS:
 871       return screen->info.props.limits.maxTessellationControlPerVertexOutputComponents / 4;
 872    case PIPE_CAP_MAX_VARYINGS:
 873       /* need to reserve up to 60 of our varying components and 16 slots for streamout */
 874       return MIN2(screen->info.props.limits.maxVertexOutputComponents / 4 / 2, 16);
 875
 876    case PIPE_CAP_DMABUF:
 877       return screen->info.have_KHR_external_memory_fd &&
 878              screen->info.have_EXT_external_memory_dma_buf &&
 879              screen->info.have_EXT_queue_family_foreign;
 880
 881    case PIPE_CAP_DEPTH_BOUNDS_TEST:
 882       return screen->info.feats.features.depthBounds;
 883
 884    case PIPE_CAP_POST_DEPTH_COVERAGE:
 885       return screen->info.have_EXT_post_depth_coverage;
 886
 887    case PIPE_CAP_STRING_MARKER:
 888       return screen->instance_info.have_EXT_debug_utils;
 889
 890    default:
 891       return u_pipe_screen_get_param_defaults(pscreen, param);
 892    }
 893 }
 894
 895 static float
 896 zink_get_paramf(struct pipe_screen *pscreen, enum pipe_capf param)
 897 {
 898    struct zink_screen *screen = zink_screen(pscreen);
 899
 900    switch (param) {
 901    case PIPE_CAPF_MIN_LINE_WIDTH:
 902    case PIPE_CAPF_MIN_LINE_WIDTH_AA:
 903       if (!screen->info.feats.features.wideLines)
 904          return 1.0f;
 905       return MAX2(screen->info.props.limits.lineWidthRange[0], 0.01);
 906
 907    case PIPE_CAPF_MIN_POINT_SIZE:
 908    case PIPE_CAPF_MIN_POINT_SIZE_AA:
 909       if (!screen->info.feats.features.largePoints)
 910          return 1.0f;
 911       return MAX2(screen->info.props.limits.pointSizeRange[0], 0.01);
 912
 913
 914    case PIPE_CAPF_LINE_WIDTH_GRANULARITY:
 915       if (!screen->info.feats.features.wideLines)
 916          return 0.1f;
 917       return screen->info.props.limits.lineWidthGranularity;
 918
 919    case PIPE_CAPF_POINT_SIZE_GRANULARITY:
 920       if (!screen->info.feats.features.largePoints)
 921          return 0.1f;
 922       return screen->info.props.limits.pointSizeGranularity;
 923
 924
 925    case PIPE_CAPF_MAX_LINE_WIDTH:
 926    case PIPE_CAPF_MAX_LINE_WIDTH_AA:
 927       if (!screen->info.feats.features.wideLines)
 928          return 1.0f;
 929       return screen->info.props.limits.lineWidthRange[1];
 930
 931    case PIPE_CAPF_MAX_POINT_SIZE:
 932    case PIPE_CAPF_MAX_POINT_SIZE_AA:
 933       if (!screen->info.feats.features.largePoints)
 934          return 1.0f;
 935       return screen->info.props.limits.pointSizeRange[1];
 936
 937    case PIPE_CAPF_MAX_TEXTURE_ANISOTROPY:
 938       if (!screen->info.feats.features.samplerAnisotropy)
 939          return 1.0f;
 940       return screen->info.props.limits.maxSamplerAnisotropy;
 941
 942    case PIPE_CAPF_MAX_TEXTURE_LOD_BIAS:
 943       return screen->info.props.limits.maxSamplerLodBias;
 944
 945    case PIPE_CAPF_MIN_CONSERVATIVE_RASTER_DILATE:
 946    case PIPE_CAPF_MAX_CONSERVATIVE_RASTER_DILATE:
 947    case PIPE_CAPF_CONSERVATIVE_RASTER_DILATE_GRANULARITY:
 948       return 0.0f; /* not implemented */
 949    }
 950
 951    /* should only get here on unhandled cases */
 952    return 0.0f;
 953 }
 954
 955 static int
 956 zink_get_shader_param(struct pipe_screen *pscreen,
 957                        gl_shader_stage shader,
 958                        enum pipe_shader_cap param)
 959 {
 960    struct zink_screen *screen = zink_screen(pscreen);
 961
 962    switch (param) {
 963    case PIPE_SHADER_CAP_MAX_INSTRUCTIONS:
 964       switch (shader) {
 965       case MESA_SHADER_FRAGMENT:
 966       case MESA_SHADER_VERTEX:
 967          return INT_MAX;
 968       case MESA_SHADER_TESS_CTRL:
 969       case MESA_SHADER_TESS_EVAL:
 970          if (screen->info.feats.features.tessellationShader &&
 971              screen->info.have_KHR_maintenance2)
 972             return INT_MAX;
 973          break;
 974
 975       case MESA_SHADER_GEOMETRY:
 976          if (screen->info.feats.features.geometryShader)
 977             return INT_MAX;
 978          break;
 979
 980       case MESA_SHADER_COMPUTE:
 981          return INT_MAX;
 982       default:
 983          break;
 984       }
 985       return 0;
 986    case PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS:
 987    case PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS:
 988    case PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS:
 989    case PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH:
 990       return INT_MAX;
 991
 992    case PIPE_SHADER_CAP_MAX_INPUTS: {
 993       uint32_t max = 0;
 994       switch (shader) {
 995       case MESA_SHADER_VERTEX:
 996          max = MIN2(screen->info.props.limits.maxVertexInputAttributes, PIPE_MAX_ATTRIBS);
 997          break;
 998       case MESA_SHADER_TESS_CTRL:
 999          max = screen->info.props.limits.maxTessellationControlPerVertexInputComponents / 4;
1000          break;
1001       case MESA_SHADER_TESS_EVAL:
1002          max = screen->info.props.limits.maxTessellationEvaluationInputComponents / 4;
1003          break;
1004       case MESA_SHADER_GEOMETRY:
1005          max = screen->info.props.limits.maxGeometryInputComponents / 4;
1006          break;
1007       case MESA_SHADER_FRAGMENT:
1008          /* intel drivers report fewer components, but it's a value that's compatible
1009           * with what we need for GL, so we can still force a conformant value here
1010           */
1011          if (screen->info.driver_props.driverID == VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA ||
1012              screen->info.driver_props.driverID == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS)
1013             return 32;
1014          max = screen->info.props.limits.maxFragmentInputComponents / 4;
1015          break;
1016       default:
1017          return 0; /* unsupported stage */
1018       }
1019       switch (shader) {
1020       case MESA_SHADER_VERTEX:
1021       case MESA_SHADER_TESS_EVAL:
1022       case MESA_SHADER_GEOMETRY:
1023          /* last vertex stage must support streamout, and this is capped in glsl compiler */
1024          return MIN2(max, MAX_VARYING);
1025       default: break;
1026       }
1027       return MIN2(max, 64); // prevent overflowing struct shader_info::inputs_read
1028    }
1029
1030    case PIPE_SHADER_CAP_MAX_OUTPUTS: {
1031       uint32_t max = 0;
1032       switch (shader) {
1033       case MESA_SHADER_VERTEX:
1034          max = screen->info.props.limits.maxVertexOutputComponents / 4;
1035          break;
1036       case MESA_SHADER_TESS_CTRL:
1037          max = screen->info.props.limits.maxTessellationControlPerVertexOutputComponents / 4;
1038          break;
1039       case MESA_SHADER_TESS_EVAL:
1040          max = screen->info.props.limits.maxTessellationEvaluationOutputComponents / 4;
1041          break;
1042       case MESA_SHADER_GEOMETRY:
1043          max = screen->info.props.limits.maxGeometryOutputComponents / 4;
1044          break;
1045       case MESA_SHADER_FRAGMENT:
1046          max = screen->info.props.limits.maxColorAttachments;
1047          break;
1048       default:
1049          return 0; /* unsupported stage */
1050       }
1051       return MIN2(max, 64); // prevent overflowing struct shader_info::outputs_read/written
1052    }
1053
1054    case PIPE_SHADER_CAP_MAX_CONST_BUFFER0_SIZE:
1055       /* At least 16384 is guaranteed by VK spec */
1056       assert(screen->info.props.limits.maxUniformBufferRange >= 16384);
1057       /* but Gallium can't handle values that are too big */
1058       return MIN3(get_smallest_buffer_heap(screen),
1059                   screen->info.props.limits.maxUniformBufferRange, BITFIELD_BIT(31));
1060
1061    case PIPE_SHADER_CAP_MAX_CONST_BUFFERS:
1062       return  MIN2(screen->info.props.limits.maxPerStageDescriptorUniformBuffers,
1063                    PIPE_MAX_CONSTANT_BUFFERS);
1064
1065    case PIPE_SHADER_CAP_MAX_TEMPS:
1066       return INT_MAX;
1067
1068    case PIPE_SHADER_CAP_INTEGERS:
1069       return 1;
1070
1071    case PIPE_SHADER_CAP_INDIRECT_CONST_ADDR:
1072    case PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR:
1073    case PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR:
1074    case PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR:
1075       return 1;
1076
1077    case PIPE_SHADER_CAP_SUBROUTINES:
1078    case PIPE_SHADER_CAP_INT64_ATOMICS:
1079    case PIPE_SHADER_CAP_GLSL_16BIT_CONSTS:
1080       return 0; /* not implemented */
1081
1082    case PIPE_SHADER_CAP_FP16_CONST_BUFFERS:
1083       //enabling this breaks GTF-GL46.gtf21.GL2Tests.glGetUniform.glGetUniform
1084       //return screen->info.feats11.uniformAndStorageBuffer16BitAccess ||
1085              //(screen->info.have_KHR_16bit_storage && screen->info.storage_16bit_feats.uniformAndStorageBuffer16BitAccess);
1086       return 0;
1087    case PIPE_SHADER_CAP_FP16_DERIVATIVES:
1088       return 0; //spirv requires 32bit derivative srcs and dests
1089    case PIPE_SHADER_CAP_FP16:
1090       return screen->info.feats12.shaderFloat16 ||
1091              (screen->info.have_KHR_shader_float16_int8 &&
1092               screen->info.shader_float16_int8_feats.shaderFloat16);
1093
1094    case PIPE_SHADER_CAP_INT16:
1095       return screen->info.feats.features.shaderInt16;
1096
1097    case PIPE_SHADER_CAP_PREFERRED_IR:
1098       return PIPE_SHADER_IR_NIR;
1099
1100    case PIPE_SHADER_CAP_TGSI_SQRT_SUPPORTED:
1101       return 0; /* not implemented */
1102
1103    case PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS:
1104    case PIPE_SHADER_CAP_MAX_SAMPLER_VIEWS:
1105       return MIN2(MIN2(screen->info.props.limits.maxPerStageDescriptorSamplers,
1106                        screen->info.props.limits.maxPerStageDescriptorSampledImages),
1107                   PIPE_MAX_SAMPLERS);
1108
1109    case PIPE_SHADER_CAP_DROUND_SUPPORTED:
1110    case PIPE_SHADER_CAP_DFRACEXP_DLDEXP_SUPPORTED:
1111       return 0; /* not implemented */
1112
1113    case PIPE_SHADER_CAP_TGSI_ANY_INOUT_DECL_RANGE:
1114       return 0; /* no idea */
1115
1116    case PIPE_SHADER_CAP_MAX_SHADER_BUFFERS:
1117       switch (shader) {
1118       case MESA_SHADER_VERTEX:
1119       case MESA_SHADER_TESS_CTRL:
1120       case MESA_SHADER_TESS_EVAL:
1121       case MESA_SHADER_GEOMETRY:
1122          if (!screen->info.feats.features.vertexPipelineStoresAndAtomics)
1123             return 0;
1124          break;
1125
1126       case MESA_SHADER_FRAGMENT:
1127          if (!screen->info.feats.features.fragmentStoresAndAtomics)
1128             return 0;
1129          break;
1130
1131       default:
1132          break;
1133       }
1134
1135       /* TODO: this limitation is dumb, and will need some fixes in mesa */
1136       return MIN2(screen->info.props.limits.maxPerStageDescriptorStorageBuffers, PIPE_MAX_SHADER_BUFFERS);
1137
1138    case PIPE_SHADER_CAP_SUPPORTED_IRS:
1139       return (1 << PIPE_SHADER_IR_NIR) | (1 << PIPE_SHADER_IR_TGSI);
1140
1141    case PIPE_SHADER_CAP_MAX_SHADER_IMAGES:
1142       if (screen->info.feats.features.shaderStorageImageExtendedFormats &&
1143           screen->info.feats.features.shaderStorageImageWriteWithoutFormat)
1144          return MIN2(screen->info.props.limits.maxPerStageDescriptorStorageImages,
1145                      ZINK_MAX_SHADER_IMAGES);
1146       return 0;
1147
1148    case PIPE_SHADER_CAP_LDEXP_SUPPORTED:
1149    case PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTERS:
1150    case PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTER_BUFFERS:
1151       return 0; /* not implemented */
1152    case PIPE_SHADER_CAP_CONT_SUPPORTED:
1153       return 1;
1154    }
1155
1156    /* should only get here on unhandled cases */
1157    return 0;
1158 }
1159
1160 static VkSampleCountFlagBits
1161 vk_sample_count_flags(uint32_t sample_count)
1162 {
1163    switch (sample_count) {
1164    case 1: return VK_SAMPLE_COUNT_1_BIT;
1165    case 2: return VK_SAMPLE_COUNT_2_BIT;
1166    case 4: return VK_SAMPLE_COUNT_4_BIT;
1167    case 8: return VK_SAMPLE_COUNT_8_BIT;
1168    case 16: return VK_SAMPLE_COUNT_16_BIT;
1169    case 32: return VK_SAMPLE_COUNT_32_BIT;
1170    case 64: return VK_SAMPLE_COUNT_64_BIT;
1171    default:
1172       return 0;
1173    }
1174 }
1175
1176 static bool
1177 zink_is_compute_copy_faster(struct pipe_screen *pscreen,
1178                             enum pipe_format src_format,
1179                             enum pipe_format dst_format,
1180                             unsigned width,
1181                             unsigned height,
1182                             unsigned depth,
1183                             bool cpu)
1184 {
1185    if (cpu)
1186       /* very basic for now, probably even worse for some cases,
1187        * but fixes lots of others
1188        */
1189       return width * height * depth > 64 * 64;
1190    return false;
1191 }
1192
1193 static bool
1194 zink_is_format_supported(struct pipe_screen *pscreen,
1195                          enum pipe_format format,
1196                          enum pipe_texture_target target,
1197                          unsigned sample_count,
1198                          unsigned storage_sample_count,
1199                          unsigned bind)
1200 {
1201    struct zink_screen *screen = zink_screen(pscreen);
1202
1203    if (storage_sample_count && !screen->info.feats.features.shaderStorageImageMultisample && bind & PIPE_BIND_SHADER_IMAGE)
1204       return false;
1205
1206    if (format == PIPE_FORMAT_NONE)
1207       return screen->info.props.limits.framebufferNoAttachmentsSampleCounts &
1208              vk_sample_count_flags(sample_count);
1209
1210    if (bind & PIPE_BIND_INDEX_BUFFER) {
1211       if (format == PIPE_FORMAT_R8_UINT &&
1212           !screen->info.have_EXT_index_type_uint8)
1213          return false;
1214       if (format != PIPE_FORMAT_R8_UINT &&
1215           format != PIPE_FORMAT_R16_UINT &&
1216           format != PIPE_FORMAT_R32_UINT)
1217          return false;
1218    }
1219
1220    VkFormat vkformat = zink_get_format(screen, format);
1221    if (vkformat == VK_FORMAT_UNDEFINED)
1222       return false;
1223
1224    if (sample_count >= 1) {
1225       VkSampleCountFlagBits sample_mask = vk_sample_count_flags(sample_count);
1226       if (!sample_mask)
1227          return false;
1228       const struct util_format_description *desc = util_format_description(format);
1229       if (util_format_is_depth_or_stencil(format)) {
1230          if (util_format_has_depth(desc)) {
1231             if (bind & PIPE_BIND_DEPTH_STENCIL &&
1232                 (screen->info.props.limits.framebufferDepthSampleCounts & sample_mask) != sample_mask)
1233                return false;
1234             if (bind & PIPE_BIND_SAMPLER_VIEW &&
1235                 (screen->info.props.limits.sampledImageDepthSampleCounts & sample_mask) != sample_mask)
1236                return false;
1237          }
1238          if (util_format_has_stencil(desc)) {
1239             if (bind & PIPE_BIND_DEPTH_STENCIL &&
1240                 (screen->info.props.limits.framebufferStencilSampleCounts & sample_mask) != sample_mask)
1241                return false;
1242             if (bind & PIPE_BIND_SAMPLER_VIEW &&
1243                 (screen->info.props.limits.sampledImageStencilSampleCounts & sample_mask) != sample_mask)
1244                return false;
1245          }
1246       } else if (util_format_is_pure_integer(format)) {
1247          if (bind & PIPE_BIND_RENDER_TARGET &&
1248              !(screen->info.props.limits.framebufferColorSampleCounts & sample_mask))
1249             return false;
1250          if (bind & PIPE_BIND_SAMPLER_VIEW &&
1251              !(screen->info.props.limits.sampledImageIntegerSampleCounts & sample_mask))
1252             return false;
1253       } else {
1254          if (bind & PIPE_BIND_RENDER_TARGET &&
1255              !(screen->info.props.limits.framebufferColorSampleCounts & sample_mask))
1256             return false;
1257          if (bind & PIPE_BIND_SAMPLER_VIEW &&
1258              !(screen->info.props.limits.sampledImageColorSampleCounts & sample_mask))
1259             return false;
1260       }
1261       if (bind & PIPE_BIND_SHADER_IMAGE) {
1262           if (!(screen->info.props.limits.storageImageSampleCounts & sample_mask))
1263              return false;
1264       }
1265    }
1266
1267    VkFormatProperties props = screen->format_props[format];
1268
1269    if (target == PIPE_BUFFER) {
1270       if (bind & PIPE_BIND_VERTEX_BUFFER) {
1271          if (!(props.bufferFeatures & VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT)) {
1272             enum pipe_format new_format = zink_decompose_vertex_format(format);
1273             if (!new_format)
1274                return false;
1275             if (!(screen->format_props[new_format].bufferFeatures & VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))
1276                return false;
1277          }
1278       }
1279
1280       if (bind & PIPE_BIND_SAMPLER_VIEW &&
1281          !(props.bufferFeatures & VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT))
1282             return false;
1283
1284       if (bind & PIPE_BIND_SHADER_IMAGE &&
1285           !(props.bufferFeatures & VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT))
1286          return false;
1287    } else {
1288       /* all other targets are texture-targets */
1289       if (bind & PIPE_BIND_RENDER_TARGET &&
1290           !(props.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT))
1291          return false;
1292
1293       if (bind & PIPE_BIND_BLENDABLE &&
1294          !(props.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT))
1295         return false;
1296
1297       if (bind & PIPE_BIND_SAMPLER_VIEW &&
1298          !(props.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT))
1299             return false;
1300
1301       if (bind & PIPE_BIND_SAMPLER_REDUCTION_MINMAX &&
1302           !(props.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT))
1303          return false;
1304
1305       if ((bind & PIPE_BIND_SAMPLER_VIEW) || (bind & PIPE_BIND_RENDER_TARGET)) {
1306          /* if this is a 3-component texture, force gallium to give us 4 components by rejecting this one */
1307          const struct util_format_description *desc = util_format_description(format);
1308          if (desc->nr_channels == 3 &&
1309              (desc->block.bits == 24 || desc->block.bits == 48 || desc->block.bits == 96))
1310             return false;
1311       }
1312
1313       if (bind & PIPE_BIND_DEPTH_STENCIL &&
1314           !(props.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT))
1315          return false;
1316
1317       if (bind & PIPE_BIND_SHADER_IMAGE &&
1318           !(props.optimalTilingFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT))
1319          return false;
1320    }
1321
1322    return true;
1323 }
1324
1325 static void
1326 zink_destroy_screen(struct pipe_screen *pscreen)
1327 {
1328    struct zink_screen *screen = zink_screen(pscreen);
1329
1330    hash_table_foreach(&screen->dts, entry)
1331       zink_kopper_deinit_displaytarget(screen, entry->data);
1332    simple_mtx_destroy(&screen->dt_lock);
1333
1334    if (screen->copy_context)
1335       screen->copy_context->base.destroy(&screen->copy_context->base);
1336
1337    if (VK_NULL_HANDLE != screen->debugUtilsCallbackHandle) {
1338       VKSCR(DestroyDebugUtilsMessengerEXT)(screen->instance, screen->debugUtilsCallbackHandle, NULL);
1339    }
1340
1341    util_vertex_state_cache_deinit(&screen->vertex_state_cache);
1342
1343    u_transfer_helper_destroy(pscreen->transfer_helper);
1344    util_queue_finish(&screen->cache_get_thread);
1345    util_queue_destroy(&screen->cache_get_thread);
1346 #ifdef ENABLE_SHADER_CACHE
1347    if (screen->disk_cache) {
1348       util_queue_finish(&screen->cache_put_thread);
1349       disk_cache_wait_for_idle(screen->disk_cache);
1350       util_queue_destroy(&screen->cache_put_thread);
1351    }
1352 #endif
1353    disk_cache_destroy(screen->disk_cache);
1354    zink_bo_deinit(screen);
1355    util_live_shader_cache_deinit(&screen->shaders);
1356
1357    zink_descriptor_layouts_deinit(screen);
1358
1359    if (screen->sem)
1360       VKSCR(DestroySemaphore)(screen->dev, screen->sem, NULL);
1361
1362    if (screen->fence)
1363       VKSCR(DestroyFence)(screen->dev, screen->fence, NULL);
1364
1365    if (screen->threaded)
1366       util_queue_destroy(&screen->flush_queue);
1367
1368    simple_mtx_destroy(&screen->queue_lock);
1369    VKSCR(DestroyDevice)(screen->dev, NULL);
1370    VKSCR(DestroyInstance)(screen->instance, NULL);
1371    util_idalloc_mt_fini(&screen->buffer_ids);
1372
1373    util_dl_close(screen->loader_lib);
1374    if (screen->drm_fd != -1)
1375       close(screen->drm_fd);
1376
1377    slab_destroy_parent(&screen->transfer_pool);
1378    ralloc_free(screen);
1379    glsl_type_singleton_decref();
1380 }
1381
1382 static bool
1383 choose_pdev(struct zink_screen *screen)
1384 {
1385    uint32_t i, pdev_count;
1386    VkPhysicalDevice *pdevs;
1387    bool is_cpu = false;
1388    VkResult result = VKSCR(EnumeratePhysicalDevices)(screen->instance, &pdev_count, NULL);
1389    if (result != VK_SUCCESS) {
1390       mesa_loge("ZINK: vkEnumeratePhysicalDevices failed (%s)", vk_Result_to_str(result));
1391       return is_cpu;
1392    }
1393
1394    assert(pdev_count > 0);
1395
1396    pdevs = malloc(sizeof(*pdevs) * pdev_count);
1397    result = VKSCR(EnumeratePhysicalDevices)(screen->instance, &pdev_count, pdevs);
1398    assert(result == VK_SUCCESS);
1399    assert(pdev_count > 0);
1400
1401    VkPhysicalDeviceProperties props;
1402    bool cpu = debug_get_bool_option("LIBGL_ALWAYS_SOFTWARE", false) ||
1403               debug_get_bool_option("D3D_ALWAYS_SOFTWARE", false);
1404    /* priority when multiple drivers are available (highest to lowest):
1405       VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU
1406       VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU
1407       VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU
1408       VK_PHYSICAL_DEVICE_TYPE_CPU
1409       VK_PHYSICAL_DEVICE_TYPE_OTHER
1410
1411     * users should specify VK_ICD_FILENAMES since this is a standardized variable
1412     * used by all vulkan applications
1413     */
1414    unsigned prio_map[] = {
1415       [VK_PHYSICAL_DEVICE_TYPE_OTHER] = 0,
1416       [VK_PHYSICAL_DEVICE_TYPE_CPU] = 1,
1417       [VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU] = 2,
1418       [VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU] = 3,
1419       [VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU] = 4,
1420    };
1421    unsigned idx = 0;
1422    int cur_prio = 0;
1423    for (i = 0; i < pdev_count; ++i) {
1424       VKSCR(GetPhysicalDeviceProperties)(pdevs[i], &props);
1425
1426       if (cpu) {
1427          /* if user wants cpu, only give them cpu */
1428          if (props.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU) {
1429             idx = i;
1430             cur_prio = prio_map[props.deviceType];
1431             break;
1432          }
1433       } else {
1434          assert(props.deviceType <= VK_PHYSICAL_DEVICE_TYPE_CPU);
1435          if (prio_map[props.deviceType] > cur_prio) {
1436             idx = i;
1437             cur_prio = prio_map[props.deviceType];
1438          }
1439       }
1440    }
1441    is_cpu = cur_prio == prio_map[VK_PHYSICAL_DEVICE_TYPE_CPU];
1442    if (cpu != is_cpu)
1443       goto out;
1444
1445    screen->pdev = pdevs[idx];
1446    VKSCR(GetPhysicalDeviceProperties)(screen->pdev, &screen->info.props);
1447    screen->info.device_version = screen->info.props.apiVersion;
1448
1449    /* runtime version is the lesser of the instance version and device version */
1450    screen->vk_version = MIN2(screen->info.device_version, screen->instance_info.loader_version);
1451
1452    /* calculate SPIR-V version based on VK version */
1453    if (screen->vk_version >= VK_MAKE_VERSION(1, 2, 0))
1454       screen->spirv_version = SPIRV_VERSION(1, 5);
1455    else if (screen->vk_version >= VK_MAKE_VERSION(1, 1, 0))
1456       screen->spirv_version = SPIRV_VERSION(1, 3);
1457    else
1458       screen->spirv_version = SPIRV_VERSION(1, 0);
1459 out:
1460    free(pdevs);
1461    return is_cpu;
1462 }
1463
1464 static void
1465 update_queue_props(struct zink_screen *screen)
1466 {
1467    uint32_t num_queues;
1468    VKSCR(GetPhysicalDeviceQueueFamilyProperties)(screen->pdev, &num_queues, NULL);
1469    assert(num_queues > 0);
1470
1471    VkQueueFamilyProperties *props = malloc(sizeof(*props) * num_queues);
1472    VKSCR(GetPhysicalDeviceQueueFamilyProperties)(screen->pdev, &num_queues, props);
1473
1474    bool found_gfx = false;
1475    uint32_t sparse_only = UINT32_MAX;
1476    screen->sparse_queue = UINT32_MAX;
1477    for (uint32_t i = 0; i < num_queues; i++) {
1478       if (props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
1479          if (found_gfx)
1480             continue;
1481          screen->sparse_queue = screen->gfx_queue = i;
1482          screen->max_queues = props[i].queueCount;
1483          screen->timestamp_valid_bits = props[i].timestampValidBits;
1484          found_gfx = true;
1485       } else if (props[i].queueFlags & VK_QUEUE_SPARSE_BINDING_BIT)
1486          sparse_only = i;
1487    }
1488    if (sparse_only != UINT32_MAX)
1489       screen->sparse_queue = sparse_only;
1490    free(props);
1491 }
1492
1493 static void
1494 init_queue(struct zink_screen *screen)
1495 {
1496    simple_mtx_init(&screen->queue_lock, mtx_plain);
1497    VKSCR(GetDeviceQueue)(screen->dev, screen->gfx_queue, 0, &screen->queue);
1498    if (screen->sparse_queue != screen->gfx_queue)
1499       VKSCR(GetDeviceQueue)(screen->dev, screen->sparse_queue, 0, &screen->queue_sparse);
1500    else
1501       screen->queue_sparse = screen->queue;
1502 }
1503
1504 static void
1505 zink_flush_frontbuffer(struct pipe_screen *pscreen,
1506                        struct pipe_context *pctx,
1507                        struct pipe_resource *pres,
1508                        unsigned level, unsigned layer,
1509                        void *winsys_drawable_handle,
1510                        struct pipe_box *sub_box)
1511 {
1512    struct zink_screen *screen = zink_screen(pscreen);
1513    struct zink_resource *res = zink_resource(pres);
1514    struct zink_context *ctx = zink_context(pctx);
1515
1516    /* if the surface is no longer a swapchain, this is a no-op */
1517    if (!zink_is_swapchain(res))
1518       return;
1519
1520    ctx = zink_tc_context_unwrap(pctx, screen->threaded);
1521
1522    if (!zink_kopper_acquired(res->obj->dt, res->obj->dt_idx)) {
1523       /* swapbuffers to an undefined surface: acquire and present garbage */
1524       zink_kopper_acquire(ctx, res, UINT64_MAX);
1525       ctx->needs_present = res;
1526       /* set batch usage to submit acquire semaphore */
1527       zink_batch_resource_usage_set(&ctx->batch, res, true, false);
1528       /* ensure the resource is set up to present garbage */
1529       ctx->base.flush_resource(&ctx->base, pres);
1530    }
1531
1532    /* handle any outstanding acquire submits (not just from above) */
1533    if (ctx->batch.swapchain || ctx->needs_present) {
1534       ctx->batch.has_work = true;
1535       pctx->flush(pctx, NULL, PIPE_FLUSH_END_OF_FRAME);
1536       if (ctx->last_fence && screen->threaded) {
1537          struct zink_batch_state *bs = zink_batch_state(ctx->last_fence);
1538          util_queue_fence_wait(&bs->flush_completed);
1539       }
1540    }
1541
1542    /* always verify that this was acquired */
1543    assert(zink_kopper_acquired(res->obj->dt, res->obj->dt_idx));
1544    zink_kopper_present_queue(screen, res);
1545 }
1546
1547 bool
1548 zink_is_depth_format_supported(struct zink_screen *screen, VkFormat format)
1549 {
1550    VkFormatProperties props;
1551    VKSCR(GetPhysicalDeviceFormatProperties)(screen->pdev, format, &props);
1552    return (props.linearTilingFeatures | props.optimalTilingFeatures) &
1553           VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT;
1554 }
1555
1556 static enum pipe_format
1557 emulate_x8(enum pipe_format format)
1558 {
1559    /* convert missing Xn variants to An */
1560    switch (format) {
1561    case PIPE_FORMAT_B8G8R8X8_UNORM:
1562       return PIPE_FORMAT_B8G8R8A8_UNORM;
1563
1564    case PIPE_FORMAT_B8G8R8X8_SRGB:
1565       return PIPE_FORMAT_B8G8R8A8_SRGB;
1566    case PIPE_FORMAT_R8G8B8X8_SRGB:
1567       return PIPE_FORMAT_R8G8B8A8_SRGB;
1568
1569    case PIPE_FORMAT_R8G8B8X8_SINT:
1570       return PIPE_FORMAT_R8G8B8A8_SINT;
1571    case PIPE_FORMAT_R8G8B8X8_SNORM:
1572       return PIPE_FORMAT_R8G8B8A8_SNORM;
1573    case PIPE_FORMAT_R8G8B8X8_UNORM:
1574       return PIPE_FORMAT_R8G8B8A8_UNORM;
1575
1576    case PIPE_FORMAT_R16G16B16X16_FLOAT:
1577       return PIPE_FORMAT_R16G16B16A16_FLOAT;
1578    case PIPE_FORMAT_R16G16B16X16_SINT:
1579       return PIPE_FORMAT_R16G16B16A16_SINT;
1580    case PIPE_FORMAT_R16G16B16X16_SNORM:
1581       return PIPE_FORMAT_R16G16B16A16_SNORM;
1582    case PIPE_FORMAT_R16G16B16X16_UNORM:
1583       return PIPE_FORMAT_R16G16B16A16_UNORM;
1584
1585    case PIPE_FORMAT_R32G32B32X32_FLOAT:
1586       return PIPE_FORMAT_R32G32B32A32_FLOAT;
1587    case PIPE_FORMAT_R32G32B32X32_SINT:
1588       return PIPE_FORMAT_R32G32B32A32_SINT;
1589
1590    default:
1591       return format;
1592    }
1593 }
1594
1595 VkFormat
1596 zink_get_format(struct zink_screen *screen, enum pipe_format format)
1597 {
1598    if (!screen->driver_workarounds.broken_l4a4 || format != PIPE_FORMAT_L4A4_UNORM)
1599       format = zink_format_get_emulated_alpha(format);
1600
1601    VkFormat ret = zink_pipe_format_to_vk_format(emulate_x8(format));
1602
1603    if (format == PIPE_FORMAT_X32_S8X24_UINT &&
1604        screen->have_D32_SFLOAT_S8_UINT)
1605       return VK_FORMAT_D32_SFLOAT_S8_UINT;
1606
1607    if (format == PIPE_FORMAT_X24S8_UINT)
1608       /* valid when using aspects to extract stencil,
1609        * fails format test because it's emulated */
1610       ret = VK_FORMAT_D24_UNORM_S8_UINT;
1611
1612    if (ret == VK_FORMAT_X8_D24_UNORM_PACK32 &&
1613        !screen->have_X8_D24_UNORM_PACK32) {
1614       assert(zink_is_depth_format_supported(screen, VK_FORMAT_D32_SFLOAT));
1615       return VK_FORMAT_D32_SFLOAT;
1616    }
1617
1618    if (ret == VK_FORMAT_D24_UNORM_S8_UINT &&
1619        !screen->have_D24_UNORM_S8_UINT) {
1620       assert(screen->have_D32_SFLOAT_S8_UINT);
1621       return VK_FORMAT_D32_SFLOAT_S8_UINT;
1622    }
1623
1624    if ((ret == VK_FORMAT_A4B4G4R4_UNORM_PACK16 &&
1625         !screen->info.format_4444_feats.formatA4B4G4R4) ||
1626        (ret == VK_FORMAT_A4R4G4B4_UNORM_PACK16 &&
1627         !screen->info.format_4444_feats.formatA4R4G4B4))
1628       return VK_FORMAT_UNDEFINED;
1629
1630    if (format == PIPE_FORMAT_R4A4_UNORM)
1631       return VK_FORMAT_R4G4_UNORM_PACK8;
1632
1633    return ret;
1634 }
1635
1636 static bool
1637 check_have_device_time(struct zink_screen *screen)
1638 {
1639    uint32_t num_domains = 0;
1640    VkTimeDomainEXT domains[8]; //current max is 4
1641    VkResult result = VKSCR(GetPhysicalDeviceCalibrateableTimeDomainsEXT)(screen->pdev, &num_domains, NULL);
1642    if (result != VK_SUCCESS) {
1643       mesa_loge("ZINK: vkGetPhysicalDeviceCalibrateableTimeDomainsEXT failed (%s)", vk_Result_to_str(result));
1644    }
1645    assert(num_domains > 0);
1646    assert(num_domains < ARRAY_SIZE(domains));
1647
1648    result = VKSCR(GetPhysicalDeviceCalibrateableTimeDomainsEXT)(screen->pdev, &num_domains, domains);
1649    if (result != VK_SUCCESS) {
1650       mesa_loge("ZINK: vkGetPhysicalDeviceCalibrateableTimeDomainsEXT failed (%s)", vk_Result_to_str(result));
1651    }
1652
1653    /* VK_TIME_DOMAIN_DEVICE_EXT is used for the ctx->get_timestamp hook and is the only one we really need */
1654    for (unsigned i = 0; i < num_domains; i++) {
1655       if (domains[i] == VK_TIME_DOMAIN_DEVICE_EXT) {
1656          return true;
1657       }
1658    }
1659
1660    return false;
1661 }
1662
1663 static void
1664 zink_error(const char *msg)
1665 {
1666 }
1667
1668 static void
1669 zink_warn(const char *msg)
1670 {
1671 }
1672
1673 static void
1674 zink_info(const char *msg)
1675 {
1676 }
1677
1678 static void
1679 zink_msg(const char *msg)
1680 {
1681 }
1682
1683 static VKAPI_ATTR VkBool32 VKAPI_CALL
1684 zink_debug_util_callback(
1685     VkDebugUtilsMessageSeverityFlagBitsEXT           messageSeverity,
1686     VkDebugUtilsMessageTypeFlagsEXT                  messageType,
1687     const VkDebugUtilsMessengerCallbackDataEXT      *pCallbackData,
1688     void                                            *pUserData)
1689 {
1690    // Pick message prefix and color to use.
1691    // Only MacOS and Linux have been tested for color support
1692    if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) {
1693       zink_error(pCallbackData->pMessage);
1694    } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) {
1695       zink_warn(pCallbackData->pMessage);
1696    } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT) {
1697       zink_info(pCallbackData->pMessage);
1698    } else
1699       zink_msg(pCallbackData->pMessage);
1700
1701    return VK_FALSE;
1702 }
1703
1704 static bool
1705 create_debug(struct zink_screen *screen)
1706 {
1707    VkDebugUtilsMessengerCreateInfoEXT vkDebugUtilsMessengerCreateInfoEXT = {
1708        VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
1709        NULL,
1710        0,  // flags
1711        VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT |
1712        VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT |
1713        VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT |
1714        VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT,
1715        VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT |
1716        VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT |
1717        VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT,
1718        zink_debug_util_callback,
1719        NULL
1720    };
1721
1722    VkDebugUtilsMessengerEXT vkDebugUtilsCallbackEXT = VK_NULL_HANDLE;
1723
1724    VkResult result = VKSCR(CreateDebugUtilsMessengerEXT)(
1725            screen->instance,
1726            &vkDebugUtilsMessengerCreateInfoEXT,
1727            NULL,
1728            &vkDebugUtilsCallbackEXT);
1729    if (result != VK_SUCCESS) {
1730       mesa_loge("ZINK: vkCreateDebugUtilsMessengerEXT failed (%s)", vk_Result_to_str(result));
1731    }
1732
1733    screen->debugUtilsCallbackHandle = vkDebugUtilsCallbackEXT;
1734
1735    return true;
1736 }
1737
1738 static bool
1739 zink_internal_setup_moltenvk(struct zink_screen *screen)
1740 {
1741 #if defined(MVK_VERSION)
1742    if (!screen->instance_info.have_MVK_moltenvk)
1743       return true;
1744
1745    GET_PROC_ADDR_INSTANCE_LOCAL(screen, screen->instance, GetMoltenVKConfigurationMVK);
1746    GET_PROC_ADDR_INSTANCE_LOCAL(screen, screen->instance, SetMoltenVKConfigurationMVK);
1747    GET_PROC_ADDR_INSTANCE_LOCAL(screen, screen->instance, GetVersionStringsMVK);
1748
1749    if (vk_GetVersionStringsMVK) {
1750       char molten_version[64] = {0};
1751       char vulkan_version[64] = {0};
1752
1753       vk_GetVersionStringsMVK(molten_version, sizeof(molten_version) - 1, vulkan_version, sizeof(vulkan_version) - 1);
1754
1755       printf("zink: MoltenVK %s Vulkan %s \n", molten_version, vulkan_version);
1756    }
1757
1758    if (vk_GetMoltenVKConfigurationMVK && vk_SetMoltenVKConfigurationMVK) {
1759       MVKConfiguration molten_config = {0};
1760       size_t molten_config_size = sizeof(molten_config);
1761
1762       VkResult res = vk_GetMoltenVKConfigurationMVK(screen->instance, &molten_config, &molten_config_size);
1763       if (res == VK_SUCCESS || res == VK_INCOMPLETE) {
1764          // Needed to allow MoltenVK to accept VkImageView swizzles.
1765          // Encountered when using VK_FORMAT_R8G8_UNORM
1766          molten_config.fullImageViewSwizzle = VK_TRUE;
1767          vk_SetMoltenVKConfigurationMVK(screen->instance, &molten_config, &molten_config_size);
1768       }
1769    }
1770 #endif // MVK_VERSION
1771
1772    return true;
1773 }
1774
1775 static void
1776 check_vertex_formats(struct zink_screen *screen)
1777 {
1778    /* from vbuf */
1779    enum pipe_format format_list[] = {
1780       /* not supported by vk
1781       PIPE_FORMAT_R32_FIXED,
1782       PIPE_FORMAT_R32G32_FIXED,
1783       PIPE_FORMAT_R32G32B32_FIXED,
1784       PIPE_FORMAT_R32G32B32A32_FIXED,
1785       */
1786       PIPE_FORMAT_R16_FLOAT,
1787       PIPE_FORMAT_R16G16_FLOAT,
1788       PIPE_FORMAT_R16G16B16_FLOAT,
1789       PIPE_FORMAT_R16G16B16A16_FLOAT,
1790       /* not supported by vk
1791       PIPE_FORMAT_R64_FLOAT,
1792       PIPE_FORMAT_R64G64_FLOAT,
1793       PIPE_FORMAT_R64G64B64_FLOAT,
1794       PIPE_FORMAT_R64G64B64A64_FLOAT,
1795       PIPE_FORMAT_R32_UNORM,
1796       PIPE_FORMAT_R32G32_UNORM,
1797       PIPE_FORMAT_R32G32B32_UNORM,
1798       PIPE_FORMAT_R32G32B32A32_UNORM,
1799       PIPE_FORMAT_R32_SNORM,
1800       PIPE_FORMAT_R32G32_SNORM,
1801       PIPE_FORMAT_R32G32B32_SNORM,
1802       PIPE_FORMAT_R32G32B32A32_SNORM,
1803       PIPE_FORMAT_R32_USCALED,
1804       PIPE_FORMAT_R32G32_USCALED,
1805       PIPE_FORMAT_R32G32B32_USCALED,
1806       PIPE_FORMAT_R32G32B32A32_USCALED,
1807       PIPE_FORMAT_R32_SSCALED,
1808       PIPE_FORMAT_R32G32_SSCALED,
1809       PIPE_FORMAT_R32G32B32_SSCALED,
1810       PIPE_FORMAT_R32G32B32A32_SSCALED,
1811       */
1812       PIPE_FORMAT_R16_UNORM,
1813       PIPE_FORMAT_R16G16_UNORM,
1814       PIPE_FORMAT_R16G16B16_UNORM,
1815       PIPE_FORMAT_R16G16B16A16_UNORM,
1816       PIPE_FORMAT_R16_SNORM,
1817       PIPE_FORMAT_R16G16_SNORM,
1818       PIPE_FORMAT_R16G16B16_SNORM,
1819       PIPE_FORMAT_R16G16B16_SINT,
1820       PIPE_FORMAT_R16G16B16_UINT,
1821       PIPE_FORMAT_R16G16B16A16_SNORM,
1822       PIPE_FORMAT_R16_USCALED,
1823       PIPE_FORMAT_R16G16_USCALED,
1824       PIPE_FORMAT_R16G16B16_USCALED,
1825       PIPE_FORMAT_R16G16B16A16_USCALED,
1826       PIPE_FORMAT_R16_SSCALED,
1827       PIPE_FORMAT_R16G16_SSCALED,
1828       PIPE_FORMAT_R16G16B16_SSCALED,
1829       PIPE_FORMAT_R16G16B16A16_SSCALED,
1830       PIPE_FORMAT_R8_UNORM,
1831       PIPE_FORMAT_R8G8_UNORM,
1832       PIPE_FORMAT_R8G8B8_UNORM,
1833       PIPE_FORMAT_R8G8B8A8_UNORM,
1834       PIPE_FORMAT_R8_SNORM,
1835       PIPE_FORMAT_R8G8_SNORM,
1836       PIPE_FORMAT_R8G8B8_SNORM,
1837       PIPE_FORMAT_R8G8B8A8_SNORM,
1838       PIPE_FORMAT_R8_USCALED,
1839       PIPE_FORMAT_R8G8_USCALED,
1840       PIPE_FORMAT_R8G8B8_USCALED,
1841       PIPE_FORMAT_R8G8B8A8_USCALED,
1842       PIPE_FORMAT_R8_SSCALED,
1843       PIPE_FORMAT_R8G8_SSCALED,
1844       PIPE_FORMAT_R8G8B8_SSCALED,
1845       PIPE_FORMAT_R8G8B8A8_SSCALED,
1846    };
1847    for (unsigned i = 0; i < ARRAY_SIZE(format_list); i++) {
1848       if (zink_is_format_supported(&screen->base, format_list[i], PIPE_BUFFER, 0, 0, PIPE_BIND_VERTEX_BUFFER))
1849          continue;
1850       if (util_format_get_nr_components(format_list[i]) == 1)
1851          continue;
1852       enum pipe_format decomposed = zink_decompose_vertex_format(format_list[i]);
1853       if (zink_is_format_supported(&screen->base, decomposed, PIPE_BUFFER, 0, 0, PIPE_BIND_VERTEX_BUFFER)) {
1854          screen->need_decompose_attrs = true;
1855          mesa_logw("zink: this application would be much faster if %s supported vertex format %s", screen->info.props.deviceName, util_format_name(format_list[i]));
1856       }
1857    }
1858 }
1859
1860 static void
1861 populate_format_props(struct zink_screen *screen)
1862 {
1863    for (unsigned i = 0; i < PIPE_FORMAT_COUNT; i++) {
1864       VkFormat format = zink_get_format(screen, i);
1865       if (!format)
1866          continue;
1867       if (VKSCR(GetPhysicalDeviceFormatProperties2)) {
1868          VkFormatProperties2 props = {0};
1869          props.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2;
1870
1871          VkDrmFormatModifierPropertiesListEXT mod_props;
1872          VkDrmFormatModifierPropertiesEXT mods[128];
1873          if (screen->info.have_EXT_image_drm_format_modifier) {
1874             mod_props.sType = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT;
1875             mod_props.pNext = NULL;
1876             mod_props.drmFormatModifierCount = ARRAY_SIZE(mods);
1877             mod_props.pDrmFormatModifierProperties = mods;
1878             props.pNext = &mod_props;
1879          }
1880          VkFormatProperties3 props3 = {0};
1881          props3.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3;
1882          props3.pNext = props.pNext;
1883          props.pNext = &props3;
1884          VKSCR(GetPhysicalDeviceFormatProperties2)(screen->pdev, format, &props);
1885          screen->format_props[i] = props.formatProperties;
1886          if (props3.linearTilingFeatures & VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV)
1887             screen->format_props[i].linearTilingFeatures |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT;
1888          if (screen->info.have_EXT_image_drm_format_modifier && mod_props.drmFormatModifierCount) {
1889             screen->modifier_props[i].drmFormatModifierCount = mod_props.drmFormatModifierCount;
1890             screen->modifier_props[i].pDrmFormatModifierProperties = ralloc_array(screen, VkDrmFormatModifierPropertiesEXT, mod_props.drmFormatModifierCount);
1891             if (mod_props.pDrmFormatModifierProperties) {
1892                for (unsigned j = 0; j < mod_props.drmFormatModifierCount; j++)
1893                   screen->modifier_props[i].pDrmFormatModifierProperties[j] = mod_props.pDrmFormatModifierProperties[j];
1894             }
1895          }
1896       } else
1897          VKSCR(GetPhysicalDeviceFormatProperties)(screen->pdev, format, &screen->format_props[i]);
1898       if (zink_format_is_emulated_alpha(i)) {
1899          VkFormatFeatureFlags blocked = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT;
1900          screen->format_props[i].linearTilingFeatures &= ~blocked;
1901          screen->format_props[i].optimalTilingFeatures &= ~blocked;
1902          screen->format_props[i].bufferFeatures = 0;
1903       }
1904    }
1905    check_vertex_formats(screen);
1906    VkImageFormatProperties image_props;
1907    VkResult ret = VKSCR(GetPhysicalDeviceImageFormatProperties)(screen->pdev, VK_FORMAT_D32_SFLOAT,
1908                                                                 VK_IMAGE_TYPE_1D,
1909                                                                 VK_IMAGE_TILING_OPTIMAL,
1910                                                                 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
1911                                                                 0, &image_props);
1912    if (ret != VK_SUCCESS && ret != VK_ERROR_FORMAT_NOT_SUPPORTED) {
1913       mesa_loge("ZINK: vkGetPhysicalDeviceImageFormatProperties failed (%s)", vk_Result_to_str(ret));
1914    }
1915    screen->need_2D_zs = ret != VK_SUCCESS;
1916
1917    if (screen->info.feats.features.sparseResidencyImage2D)
1918       screen->need_2D_sparse = !screen->base.get_sparse_texture_virtual_page_size(&screen->base, PIPE_TEXTURE_1D, false, PIPE_FORMAT_R32_FLOAT, 0, 16, NULL, NULL, NULL);
1919 }
1920
1921 bool
1922 zink_screen_init_semaphore(struct zink_screen *screen)
1923 {
1924    VkSemaphoreCreateInfo sci = {0};
1925    VkSemaphoreTypeCreateInfo tci = {0};
1926    sci.pNext = &tci;
1927    sci.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
1928    tci.sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO;
1929    tci.semaphoreType = VK_SEMAPHORE_TYPE_TIMELINE;
1930
1931    return VKSCR(CreateSemaphore)(screen->dev, &sci, NULL, &screen->sem) == VK_SUCCESS;
1932 }
1933
1934 bool
1935 zink_screen_timeline_wait(struct zink_screen *screen, uint64_t batch_id, uint64_t timeout)
1936 {
1937    VkSemaphoreWaitInfo wi = {0};
1938
1939    if (zink_screen_check_last_finished(screen, batch_id))
1940       return true;
1941
1942    wi.sType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO;
1943    wi.semaphoreCount = 1;
1944    wi.pSemaphores = &screen->sem;
1945    wi.pValues = &batch_id;
1946    bool success = false;
1947    if (screen->device_lost)
1948       return true;
1949    VkResult ret = VKSCR(WaitSemaphores)(screen->dev, &wi, timeout);
1950    success = zink_screen_handle_vkresult(screen, ret);
1951
1952    if (success)
1953       zink_screen_update_last_finished(screen, batch_id);
1954
1955    return success;
1956 }
1957
1958 static uint32_t
1959 zink_get_loader_version(struct zink_screen *screen)
1960 {
1961
1962    uint32_t loader_version = VK_API_VERSION_1_0;
1963
1964    // Get the Loader version
1965    GET_PROC_ADDR_INSTANCE_LOCAL(screen, NULL, EnumerateInstanceVersion);
1966    if (vk_EnumerateInstanceVersion) {
1967       uint32_t loader_version_temp = VK_API_VERSION_1_0;
1968       VkResult result = (*vk_EnumerateInstanceVersion)(&loader_version_temp);
1969       if (VK_SUCCESS == result) {
1970          loader_version = loader_version_temp;
1971       } else {
1972          mesa_loge("ZINK: vkEnumerateInstanceVersion failed (%s)", vk_Result_to_str(result));
1973       }
1974    }
1975
1976    return loader_version;
1977 }
1978
1979 static void
1980 zink_query_memory_info(struct pipe_screen *pscreen, struct pipe_memory_info *info)
1981 {
1982    struct zink_screen *screen = zink_screen(pscreen);
1983    memset(info, 0, sizeof(struct pipe_memory_info));
1984    if (screen->info.have_EXT_memory_budget && VKSCR(GetPhysicalDeviceMemoryProperties2)) {
1985       VkPhysicalDeviceMemoryProperties2 mem = {0};
1986       mem.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
1987
1988       VkPhysicalDeviceMemoryBudgetPropertiesEXT budget = {0};
1989       budget.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
1990       mem.pNext = &budget;
1991       VKSCR(GetPhysicalDeviceMemoryProperties2)(screen->pdev, &mem);
1992
1993       for (unsigned i = 0; i < mem.memoryProperties.memoryHeapCount; i++) {
1994          if (mem.memoryProperties.memoryHeaps[i].flags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) {
1995             /* VRAM */
1996             info->total_device_memory += mem.memoryProperties.memoryHeaps[i].size / 1024;
1997             info->avail_device_memory += (mem.memoryProperties.memoryHeaps[i].size - budget.heapUsage[i]) / 1024;
1998          } else {
1999             /* GART */
2000             info->total_staging_memory += mem.memoryProperties.memoryHeaps[i].size / 1024;
2001             info->avail_staging_memory += (mem.memoryProperties.memoryHeaps[i].size - budget.heapUsage[i]) / 1024;
2002          }
2003       }
2004       /* evictions not yet supported in vulkan */
2005    } else {
2006       for (unsigned i = 0; i < screen->info.mem_props.memoryHeapCount; i++) {
2007          if (screen->info.mem_props.memoryHeaps[i].flags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) {
2008             /* VRAM */
2009             info->total_device_memory += screen->info.mem_props.memoryHeaps[i].size / 1024;
2010             /* free real estate! */
2011             info->avail_device_memory += info->total_device_memory;
2012          } else {
2013             /* GART */
2014             info->total_staging_memory += screen->info.mem_props.memoryHeaps[i].size / 1024;
2015             /* free real estate! */
2016             info->avail_staging_memory += info->total_staging_memory;
2017          }
2018       }
2019    }
2020 }
2021
2022 static void
2023 zink_query_dmabuf_modifiers(struct pipe_screen *pscreen, enum pipe_format format, int max, uint64_t *modifiers, unsigned int *external_only, int *count)
2024 {
2025    struct zink_screen *screen = zink_screen(pscreen);
2026    *count = screen->modifier_props[format].drmFormatModifierCount;
2027    for (int i = 0; i < MIN2(max, *count); i++)
2028       modifiers[i] = screen->modifier_props[format].pDrmFormatModifierProperties[i].drmFormatModifier;
2029 }
2030
2031 static bool
2032 zink_is_dmabuf_modifier_supported(struct pipe_screen *pscreen, uint64_t modifier, enum pipe_format format, bool *external_only)
2033 {
2034    struct zink_screen *screen = zink_screen(pscreen);
2035    for (unsigned i = 0; i < screen->modifier_props[format].drmFormatModifierCount; i++)
2036       if (screen->modifier_props[format].pDrmFormatModifierProperties[i].drmFormatModifier == modifier)
2037          return true;
2038    return false;
2039 }
2040
2041 static unsigned
2042 zink_get_dmabuf_modifier_planes(struct pipe_screen *pscreen, uint64_t modifier, enum pipe_format format)
2043 {
2044    struct zink_screen *screen = zink_screen(pscreen);
2045    for (unsigned i = 0; i < screen->modifier_props[format].drmFormatModifierCount; i++)
2046       if (screen->modifier_props[format].pDrmFormatModifierProperties[i].drmFormatModifier == modifier)
2047          return screen->modifier_props[format].pDrmFormatModifierProperties[i].drmFormatModifierPlaneCount;
2048    return 0;
2049 }
2050
2051 static int
2052 zink_get_sparse_texture_virtual_page_size(struct pipe_screen *pscreen,
2053                                           enum pipe_texture_target target,
2054                                           bool multi_sample,
2055                                           enum pipe_format pformat,
2056                                           unsigned offset, unsigned size,
2057                                           int *x, int *y, int *z)
2058 {
2059    struct zink_screen *screen = zink_screen(pscreen);
2060    static const int page_size_2d[][3] = {
2061       { 256, 256, 1 }, /* 8bpp   */
2062       { 256, 128, 1 }, /* 16bpp  */
2063       { 128, 128, 1 }, /* 32bpp  */
2064       { 128, 64,  1 }, /* 64bpp  */
2065       { 64,  64,  1 }, /* 128bpp */
2066    };
2067    static const int page_size_3d[][3] = {
2068       { 64,  32,  32 }, /* 8bpp   */
2069       { 32,  32,  32 }, /* 16bpp  */
2070       { 32,  32,  16 }, /* 32bpp  */
2071       { 32,  16,  16 }, /* 64bpp  */
2072       { 16,  16,  16 }, /* 128bpp */
2073    };
2074    /* Only support one type of page size. */
2075    if (offset != 0)
2076       return 0;
2077
2078    /* reject multisample if 2x isn't supported; assume none are */
2079    if (multi_sample && !screen->info.feats.features.sparseResidency2Samples)
2080       return 0;
2081
2082    VkFormat format = zink_get_format(screen, pformat);
2083    bool is_zs = util_format_is_depth_or_stencil(pformat);
2084    VkImageType type;
2085    switch (target) {
2086    case PIPE_TEXTURE_1D:
2087    case PIPE_TEXTURE_1D_ARRAY:
2088       type = (screen->need_2D_sparse || (screen->need_2D_zs && is_zs)) ? VK_IMAGE_TYPE_2D : VK_IMAGE_TYPE_1D;
2089       break;
2090
2091    case PIPE_TEXTURE_2D:
2092    case PIPE_TEXTURE_CUBE:
2093    case PIPE_TEXTURE_RECT:
2094    case PIPE_TEXTURE_2D_ARRAY:
2095    case PIPE_TEXTURE_CUBE_ARRAY:
2096       type = VK_IMAGE_TYPE_2D;
2097       break;
2098
2099    case PIPE_TEXTURE_3D:
2100       type = VK_IMAGE_TYPE_3D;
2101       break;
2102
2103    case PIPE_BUFFER:
2104       goto hack_it_up;
2105
2106    default:
2107       return 0;
2108    }
2109    VkImageUsageFlags flags = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
2110                              VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
2111    flags |= is_zs ? VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT : VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
2112    VkSparseImageFormatProperties props[4]; //planar?
2113    unsigned prop_count = ARRAY_SIZE(props);
2114    VKSCR(GetPhysicalDeviceSparseImageFormatProperties)(screen->pdev, format, type,
2115                                                        multi_sample ? VK_SAMPLE_COUNT_2_BIT : VK_SAMPLE_COUNT_1_BIT,
2116                                                        flags,
2117                                                        VK_IMAGE_TILING_OPTIMAL,
2118                                                        &prop_count, props);
2119    if (!prop_count) {
2120       if (pformat == PIPE_FORMAT_R9G9B9E5_FLOAT) {
2121          screen->faked_e5sparse = true;
2122          goto hack_it_up;
2123       }
2124       return 0;
2125    }
2126
2127    if (size) {
2128       if (x)
2129          *x = props[0].imageGranularity.width;
2130       if (y)
2131          *y = props[0].imageGranularity.height;
2132       if (z)
2133          *z = props[0].imageGranularity.depth;
2134    }
2135
2136    return 1;
2137 hack_it_up:
2138    {
2139       const int (*page_sizes)[3] = target == PIPE_TEXTURE_3D ? page_size_3d : page_size_2d;
2140       int blk_size = util_format_get_blocksize(pformat);
2141
2142       if (size) {
2143          unsigned index = util_logbase2(blk_size);
2144          if (x) *x = page_sizes[index][0];
2145          if (y) *y = page_sizes[index][1];
2146          if (z) *z = page_sizes[index][2];
2147       }
2148    }
2149    return 1;
2150 }
2151
2152 static VkDevice
2153 zink_create_logical_device(struct zink_screen *screen)
2154 {
2155    VkDevice dev = VK_NULL_HANDLE;
2156
2157    VkDeviceQueueCreateInfo qci[2] = {0};
2158    uint32_t queues[3] = {
2159       screen->gfx_queue,
2160       screen->sparse_queue,
2161    };
2162    float dummy = 0.0f;
2163    for (unsigned i = 0; i < ARRAY_SIZE(qci); i++) {
2164       qci[i].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
2165       qci[i].queueFamilyIndex = queues[i];
2166       qci[i].queueCount = 1;
2167       qci[i].pQueuePriorities = &dummy;
2168    }
2169
2170    unsigned num_queues = 1;
2171    if (screen->sparse_queue != screen->gfx_queue)
2172       num_queues++;
2173
2174    VkDeviceCreateInfo dci = {0};
2175    dci.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
2176    dci.queueCreateInfoCount = num_queues;
2177    dci.pQueueCreateInfos = qci;
2178    /* extensions don't have bool members in pEnabledFeatures.
2179     * this requires us to pass the whole VkPhysicalDeviceFeatures2 struct
2180     */
2181    if (screen->info.feats.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2) {
2182       dci.pNext = &screen->info.feats;
2183    } else {
2184       dci.pEnabledFeatures = &screen->info.feats.features;
2185    }
2186
2187    dci.ppEnabledExtensionNames = screen->info.extensions;
2188    dci.enabledExtensionCount = screen->info.num_extensions;
2189
2190    VkResult result = VKSCR(CreateDevice)(screen->pdev, &dci, NULL, &dev);
2191    if (result != VK_SUCCESS)
2192       mesa_loge("ZINK: vkCreateDevice failed (%s)", vk_Result_to_str(result));
2193
2194    return dev;
2195 }
2196
2197 static void
2198 check_base_requirements(struct zink_screen *screen)
2199 {
2200    if (!screen->info.feats.features.logicOp ||
2201        !screen->info.feats.features.fillModeNonSolid ||
2202        !screen->info.feats.features.shaderClipDistance ||
2203        !(screen->info.feats12.scalarBlockLayout ||
2204          screen->info.have_EXT_scalar_block_layout) ||
2205        !screen->info.have_KHR_maintenance1 ||
2206        !screen->info.have_EXT_custom_border_color ||
2207        !screen->info.have_EXT_line_rasterization) {
2208       fprintf(stderr, "WARNING: Some incorrect rendering "
2209               "might occur because the selected Vulkan device (%s) doesn't support "
2210               "base Zink requirements: ", screen->info.props.deviceName);
2211 #define CHECK_OR_PRINT(X) \
2212       if (!screen->info.X) \
2213          fprintf(stderr, "%s ", #X)
2214       CHECK_OR_PRINT(feats.features.logicOp);
2215       CHECK_OR_PRINT(feats.features.fillModeNonSolid);
2216       CHECK_OR_PRINT(feats.features.shaderClipDistance);
2217       if (!screen->info.feats12.scalarBlockLayout && !screen->info.have_EXT_scalar_block_layout)
2218          printf("scalarBlockLayout OR EXT_scalar_block_layout ");
2219       CHECK_OR_PRINT(have_KHR_maintenance1);
2220       CHECK_OR_PRINT(have_EXT_custom_border_color);
2221       CHECK_OR_PRINT(have_EXT_line_rasterization);
2222       fprintf(stderr, "\n");
2223    }
2224 }
2225
2226 static void
2227 zink_get_sample_pixel_grid(struct pipe_screen *pscreen, unsigned sample_count,
2228                            unsigned *width, unsigned *height)
2229 {
2230    struct zink_screen *screen = zink_screen(pscreen);
2231    unsigned idx = util_logbase2_ceil(MAX2(sample_count, 1));
2232    assert(idx < ARRAY_SIZE(screen->maxSampleLocationGridSize));
2233    *width = screen->maxSampleLocationGridSize[idx].width;
2234    *height = screen->maxSampleLocationGridSize[idx].height;
2235 }
2236
2237 static void
2238 init_driver_workarounds(struct zink_screen *screen)
2239 {
2240    /* enable implicit sync for all non-mesa drivers */
2241    screen->driver_workarounds.implicit_sync = true;
2242    switch (screen->info.driver_props.driverID) {
2243    case VK_DRIVER_ID_MESA_RADV:
2244    case VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA:
2245    case VK_DRIVER_ID_MESA_LLVMPIPE:
2246    case VK_DRIVER_ID_MESA_TURNIP:
2247    case VK_DRIVER_ID_MESA_V3DV:
2248    case VK_DRIVER_ID_MESA_PANVK:
2249    case VK_DRIVER_ID_MESA_VENUS:
2250       screen->driver_workarounds.implicit_sync = false;
2251       break;
2252    default:
2253       break;
2254    }
2255    if (screen->info.line_rast_feats.stippledRectangularLines &&
2256        screen->info.line_rast_feats.stippledBresenhamLines &&
2257        screen->info.line_rast_feats.stippledSmoothLines &&
2258        !screen->info.dynamic_state3_feats.extendedDynamicState3LineStippleEnable)
2259       screen->info.have_EXT_extended_dynamic_state3 = false;
2260    if (!screen->info.dynamic_state3_feats.extendedDynamicState3PolygonMode ||
2261        !screen->info.dynamic_state3_feats.extendedDynamicState3DepthClampEnable ||
2262        !screen->info.dynamic_state3_feats.extendedDynamicState3DepthClipEnable ||
2263        !screen->info.dynamic_state3_feats.extendedDynamicState3ProvokingVertexMode ||
2264        !screen->info.dynamic_state3_feats.extendedDynamicState3LineRasterizationMode)
2265       screen->info.have_EXT_extended_dynamic_state3 = false;
2266    else if (screen->info.dynamic_state3_feats.extendedDynamicState3SampleMask &&
2267             screen->info.dynamic_state3_feats.extendedDynamicState3AlphaToCoverageEnable &&
2268             (!screen->info.feats.features.alphaToOne || screen->info.dynamic_state3_feats.extendedDynamicState3AlphaToOneEnable) &&
2269             screen->info.dynamic_state3_feats.extendedDynamicState3ColorBlendEnable &&
2270             screen->info.dynamic_state3_feats.extendedDynamicState3RasterizationSamples &&
2271             screen->info.dynamic_state3_feats.extendedDynamicState3ColorWriteMask &&
2272             screen->info.dynamic_state3_feats.extendedDynamicState3LogicOpEnable &&
2273             screen->info.dynamic_state2_feats.extendedDynamicState2LogicOp)
2274       screen->have_full_ds3 = true;
2275    if (screen->info.have_EXT_graphics_pipeline_library)
2276       screen->info.have_EXT_graphics_pipeline_library = screen->info.have_EXT_extended_dynamic_state &&
2277                                                         screen->info.have_EXT_extended_dynamic_state2 &&
2278                                                         ((zink_debug & ZINK_DEBUG_GPL) ||
2279                                                          screen->info.dynamic_state2_feats.extendedDynamicState2PatchControlPoints) &&
2280                                                         screen->info.have_EXT_extended_dynamic_state3 &&
2281                                                         screen->info.have_KHR_dynamic_rendering &&
2282                                                         screen->info.have_EXT_non_seamless_cube_map &&
2283                                                         (!(zink_debug & ZINK_DEBUG_GPL) ||
2284                                                          screen->info.gpl_props.graphicsPipelineLibraryFastLinking ||
2285                                                          screen->is_cpu);
2286    screen->driver_workarounds.broken_l4a4 = screen->info.driver_props.driverID == VK_DRIVER_ID_NVIDIA_PROPRIETARY;
2287    screen->driver_workarounds.depth_clip_control_missing = !screen->info.have_EXT_depth_clip_control;
2288    if (screen->info.driver_props.driverID == VK_DRIVER_ID_AMD_PROPRIETARY)
2289       /* this completely breaks xfb somehow */
2290       screen->info.have_EXT_extended_dynamic_state2 = false;
2291    if (screen->info.driver_props.driverID == VK_DRIVER_ID_MESA_TURNIP) {
2292       /* performance */
2293       screen->info.border_color_feats.customBorderColorWithoutFormat = VK_FALSE;
2294    }
2295    if (screen->info.driver_props.driverID == VK_DRIVER_ID_AMD_OPEN_SOURCE ||
2296        screen->info.driver_props.driverID == VK_DRIVER_ID_AMD_PROPRIETARY ||
2297        screen->info.driver_props.driverID == VK_DRIVER_ID_NVIDIA_PROPRIETARY ||
2298        screen->info.driver_props.driverID == VK_DRIVER_ID_MESA_RADV)
2299       screen->driver_workarounds.z24_unscaled_bias = 1<<23;
2300    else
2301       screen->driver_workarounds.z24_unscaled_bias = 1<<24;
2302    if (screen->info.driver_props.driverID == VK_DRIVER_ID_NVIDIA_PROPRIETARY)
2303       screen->driver_workarounds.z16_unscaled_bias = 1<<15;
2304    else
2305       screen->driver_workarounds.z16_unscaled_bias = 1<<16;
2306    /* these drivers don't use VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT, so it can always be set */
2307    switch (screen->info.driver_props.driverID) {
2308    case VK_DRIVER_ID_MESA_RADV:
2309    case VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA:
2310    case VK_DRIVER_ID_MESA_LLVMPIPE:
2311    case VK_DRIVER_ID_MESA_VENUS:
2312    case VK_DRIVER_ID_NVIDIA_PROPRIETARY:
2313    case VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS:
2314    case VK_DRIVER_ID_IMAGINATION_PROPRIETARY:
2315       screen->driver_workarounds.always_feedback_loop = screen->info.have_EXT_attachment_feedback_loop_layout;
2316       break;
2317    default:
2318       break;
2319    }
2320    /* these drivers don't use VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT, so it can always be set */
2321    switch (screen->info.driver_props.driverID) {
2322    case VK_DRIVER_ID_MESA_RADV:
2323    case VK_DRIVER_ID_MESA_LLVMPIPE:
2324    case VK_DRIVER_ID_MESA_VENUS:
2325    case VK_DRIVER_ID_NVIDIA_PROPRIETARY:
2326    case VK_DRIVER_ID_IMAGINATION_PROPRIETARY:
2327       screen->driver_workarounds.always_feedback_loop_zs = screen->info.have_EXT_attachment_feedback_loop_layout;
2328       break;
2329    default:
2330       break;
2331    }
2332 }
2333
2334 static struct zink_screen *
2335 zink_internal_create_screen(const struct pipe_screen_config *config)
2336 {
2337    if (getenv("ZINK_USE_LAVAPIPE")) {
2338       mesa_loge("ZINK_USE_LAVAPIPE is obsolete. Use LIBGL_ALWAYS_SOFTWARE\n");
2339       return NULL;
2340    }
2341
2342    struct zink_screen *screen = rzalloc(NULL, struct zink_screen);
2343    if (!screen)
2344       return NULL;
2345
2346    screen->threaded = util_get_cpu_caps()->nr_cpus > 1 && debug_get_bool_option("GALLIUM_THREAD", util_get_cpu_caps()->nr_cpus > 1);
2347    screen->abort_on_hang = debug_get_bool_option("ZINK_HANG_ABORT", false);
2348
2349    zink_debug = debug_get_option_zink_debug();
2350    zink_descriptor_mode = debug_get_option_zink_descriptor_mode();
2351
2352    screen->loader_lib = util_dl_open(VK_LIBNAME);
2353    if (!screen->loader_lib)
2354       goto fail;
2355
2356    screen->vk_GetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)util_dl_get_proc_address(screen->loader_lib, "vkGetInstanceProcAddr");
2357    screen->vk_GetDeviceProcAddr = (PFN_vkGetDeviceProcAddr)util_dl_get_proc_address(screen->loader_lib, "vkGetDeviceProcAddr");
2358    if (!screen->vk_GetInstanceProcAddr ||
2359        !screen->vk_GetDeviceProcAddr)
2360       goto fail;
2361
2362    screen->instance_info.loader_version = zink_get_loader_version(screen);
2363 #if WITH_XMLCONFIG
2364    if (config) {
2365       driParseConfigFiles(config->options, config->options_info, 0, "zink",
2366                           NULL, NULL, NULL, 0, NULL, 0);
2367       screen->driconf.dual_color_blend_by_location = driQueryOptionb(config->options, "dual_color_blend_by_location");
2368       screen->driconf.glsl_correct_derivatives_after_discard = driQueryOptionb(config->options, "glsl_correct_derivatives_after_discard");
2369       //screen->driconf.inline_uniforms = driQueryOptionb(config->options, "radeonsi_inline_uniforms");
2370       screen->instance_info.disable_xcb_surface = driQueryOptionb(config->options, "disable_xcb_surface");
2371    }
2372 #endif
2373
2374    if (!zink_create_instance(screen))
2375       goto fail;
2376
2377    vk_instance_dispatch_table_load(&screen->vk.instance,
2378                                    screen->vk_GetInstanceProcAddr,
2379                                    screen->instance);
2380    vk_physical_device_dispatch_table_load(&screen->vk.physical_device,
2381                                           screen->vk_GetInstanceProcAddr,
2382                                           screen->instance);
2383
2384    zink_verify_instance_extensions(screen);
2385
2386    if (screen->instance_info.have_EXT_debug_utils &&
2387       (zink_debug & ZINK_DEBUG_VALIDATION) && !create_debug(screen))
2388       debug_printf("ZINK: failed to setup debug utils\n");
2389
2390    screen->is_cpu = choose_pdev(screen);
2391    if (screen->pdev == VK_NULL_HANDLE)
2392       goto fail;
2393
2394    update_queue_props(screen);
2395
2396    screen->have_X8_D24_UNORM_PACK32 = zink_is_depth_format_supported(screen,
2397                                               VK_FORMAT_X8_D24_UNORM_PACK32);
2398    screen->have_D24_UNORM_S8_UINT = zink_is_depth_format_supported(screen,
2399                                               VK_FORMAT_D24_UNORM_S8_UINT);
2400    screen->have_D32_SFLOAT_S8_UINT = zink_is_depth_format_supported(screen,
2401                                               VK_FORMAT_D32_SFLOAT_S8_UINT);
2402
2403    if (!zink_get_physical_device_info(screen)) {
2404       debug_printf("ZINK: failed to detect features\n");
2405       goto fail;
2406    }
2407
2408    if (screen->threaded && !util_queue_init(&screen->flush_queue, "zfq", 8, 1, UTIL_QUEUE_INIT_RESIZE_IF_FULL, screen)) {
2409       mesa_loge("zink: Failed to create flush queue.\n");
2410       goto fail;
2411    }
2412
2413    zink_internal_setup_moltenvk(screen);
2414    if (!screen->info.have_KHR_timeline_semaphore) {
2415       mesa_loge("zink: KHR_timeline_semaphore is required");
2416       goto fail;
2417    }
2418
2419    init_driver_workarounds(screen);
2420
2421    screen->dev = zink_create_logical_device(screen);
2422    if (!screen->dev)
2423       goto fail;
2424
2425    vk_device_dispatch_table_load(&screen->vk.device,
2426                                  screen->vk_GetDeviceProcAddr,
2427                                  screen->dev);
2428
2429    init_queue(screen);
2430    if (screen->info.driver_props.driverID == VK_DRIVER_ID_MESA_RADV ||
2431        screen->info.driver_props.driverID == VK_DRIVER_ID_AMD_OPEN_SOURCE ||
2432        screen->info.driver_props.driverID == VK_DRIVER_ID_AMD_PROPRIETARY)
2433       /* this has bad perf on AMD */
2434       screen->info.have_KHR_push_descriptor = false;
2435
2436    zink_verify_device_extensions(screen);
2437
2438    if ((zink_debug & ZINK_DEBUG_COMPACT) ||
2439        screen->info.props.limits.maxBoundDescriptorSets < ZINK_MAX_DESCRIPTOR_SETS) {
2440       screen->desc_set_id[ZINK_DESCRIPTOR_TYPES] = 0;
2441       screen->desc_set_id[ZINK_DESCRIPTOR_TYPE_UBO] = 1;
2442       screen->desc_set_id[ZINK_DESCRIPTOR_TYPE_SSBO] = 1;
2443       screen->desc_set_id[ZINK_DESCRIPTOR_TYPE_SAMPLER_VIEW] = 2;
2444       screen->desc_set_id[ZINK_DESCRIPTOR_TYPE_IMAGE] = 2;
2445       screen->desc_set_id[ZINK_DESCRIPTOR_BINDLESS] = 3;
2446       screen->compact_descriptors = true;
2447    } else {
2448       screen->desc_set_id[ZINK_DESCRIPTOR_TYPES] = 0;
2449       screen->desc_set_id[ZINK_DESCRIPTOR_TYPE_UBO] = 1;
2450       screen->desc_set_id[ZINK_DESCRIPTOR_TYPE_SAMPLER_VIEW] = 2;
2451       screen->desc_set_id[ZINK_DESCRIPTOR_TYPE_SSBO] = 3;
2452       screen->desc_set_id[ZINK_DESCRIPTOR_TYPE_IMAGE] = 4;
2453       screen->desc_set_id[ZINK_DESCRIPTOR_BINDLESS] = 5;
2454    }
2455    if (zink_descriptor_mode == ZINK_DESCRIPTOR_MODE_AUTO) {
2456       zink_descriptor_mode = ZINK_DESCRIPTOR_MODE_LAZY;
2457    }
2458
2459    if (screen->info.have_EXT_calibrated_timestamps && !check_have_device_time(screen))
2460       goto fail;
2461
2462    screen->have_triangle_fans = true;
2463 #if defined(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME)
2464    if (screen->info.have_KHR_portability_subset) {
2465       screen->have_triangle_fans = (VK_TRUE == screen->info.portability_subset_feats.triangleFans);
2466    }
2467 #endif // VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME
2468
2469    check_base_requirements(screen);
2470    util_live_shader_cache_init(&screen->shaders, zink_create_gfx_shader_state, zink_delete_shader_state);
2471
2472    screen->base.get_name = zink_get_name;
2473    if (screen->instance_info.have_KHR_external_memory_capabilities) {
2474       screen->base.get_device_uuid = zink_get_device_uuid;
2475       screen->base.get_driver_uuid = zink_get_driver_uuid;
2476    }
2477    if (screen->info.have_KHR_external_memory_win32) {
2478       screen->base.get_device_luid = zink_get_device_luid;
2479       screen->base.get_device_node_mask = zink_get_device_node_mask;
2480    }
2481    screen->base.set_max_shader_compiler_threads = zink_set_max_shader_compiler_threads;
2482    screen->base.is_parallel_shader_compilation_finished = zink_is_parallel_shader_compilation_finished;
2483    screen->base.get_vendor = zink_get_vendor;
2484    screen->base.get_device_vendor = zink_get_device_vendor;
2485    screen->base.get_compute_param = zink_get_compute_param;
2486    screen->base.get_timestamp = zink_get_timestamp;
2487    screen->base.query_memory_info = zink_query_memory_info;
2488    screen->base.get_param = zink_get_param;
2489    screen->base.get_paramf = zink_get_paramf;
2490    screen->base.get_shader_param = zink_get_shader_param;
2491    screen->base.get_compiler_options = zink_get_compiler_options;
2492    screen->base.get_sample_pixel_grid = zink_get_sample_pixel_grid;
2493    screen->base.is_compute_copy_faster = zink_is_compute_copy_faster;
2494    screen->base.is_format_supported = zink_is_format_supported;
2495    screen->base.driver_thread_add_job = zink_driver_thread_add_job;
2496    if (screen->info.have_EXT_image_drm_format_modifier && screen->info.have_EXT_external_memory_dma_buf) {
2497       screen->base.query_dmabuf_modifiers = zink_query_dmabuf_modifiers;
2498       screen->base.is_dmabuf_modifier_supported = zink_is_dmabuf_modifier_supported;
2499       screen->base.get_dmabuf_modifier_planes = zink_get_dmabuf_modifier_planes;
2500    }
2501 #if defined(_WIN32)
2502    if (screen->info.have_KHR_external_memory_win32)
2503       screen->base.create_fence_win32 = zink_create_fence_win32;
2504 #endif
2505    screen->base.context_create = zink_context_create;
2506    screen->base.flush_frontbuffer = zink_flush_frontbuffer;
2507    screen->base.destroy = zink_destroy_screen;
2508    screen->base.finalize_nir = zink_shader_finalize;
2509    screen->base.get_sparse_texture_virtual_page_size = zink_get_sparse_texture_virtual_page_size;
2510
2511    if (screen->info.have_EXT_sample_locations) {
2512       VkMultisamplePropertiesEXT prop;
2513       prop.sType = VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT;
2514       prop.pNext = NULL;
2515       for (unsigned i = 0; i < ARRAY_SIZE(screen->maxSampleLocationGridSize); i++) {
2516          if (screen->info.sample_locations_props.sampleLocationSampleCounts & (1 << i)) {
2517             VKSCR(GetPhysicalDeviceMultisamplePropertiesEXT)(screen->pdev, 1 << i, &prop);
2518             screen->maxSampleLocationGridSize[i] = prop.maxSampleLocationGridSize;
2519          }
2520       }
2521    }
2522
2523    if (!zink_screen_resource_init(&screen->base))
2524       goto fail;
2525    zink_bo_init(screen);
2526    zink_screen_fence_init(&screen->base);
2527
2528    zink_screen_init_compiler(screen);
2529    if (!disk_cache_init(screen))
2530       goto fail;
2531    if (!util_queue_init(&screen->cache_get_thread, "zcfq", 8, 4,
2532                         UTIL_QUEUE_INIT_RESIZE_IF_FULL | UTIL_QUEUE_INIT_SCALE_THREADS, screen))
2533       goto fail;
2534    populate_format_props(screen);
2535
2536    slab_create_parent(&screen->transfer_pool, sizeof(struct zink_transfer), 16);
2537
2538    screen->driconf.inline_uniforms = debug_get_bool_option("ZINK_INLINE_UNIFORMS", screen->is_cpu);
2539
2540    screen->total_video_mem = get_video_mem(screen);
2541    screen->clamp_video_mem = screen->total_video_mem * 0.8;
2542    if (!os_get_total_physical_memory(&screen->total_mem))
2543       goto fail;
2544
2545    if (!zink_screen_init_semaphore(screen)) {
2546       mesa_loge("zink: failed to create timeline semaphore");
2547       goto fail;
2548    }
2549
2550    memset(&screen->heap_map, UINT8_MAX, sizeof(screen->heap_map));
2551    for (enum zink_heap i = 0; i < ZINK_HEAP_MAX; i++) {
2552       for (unsigned j = 0; j < screen->info.mem_props.memoryTypeCount; j++) {
2553          VkMemoryPropertyFlags domains = vk_domain_from_heap(i);
2554          if ((screen->info.mem_props.memoryTypes[j].propertyFlags & domains) == domains) {
2555             assert(screen->heap_map[i] == UINT8_MAX);
2556             screen->heap_map[i] = j;
2557             break;
2558          }
2559       }
2560
2561       /* not found: use compatible heap */
2562       if (screen->heap_map[i] == UINT8_MAX) {
2563          /* only cached mem has a failure case for now */
2564          assert(i == ZINK_HEAP_HOST_VISIBLE_CACHED || i == ZINK_HEAP_DEVICE_LOCAL_LAZY ||
2565                 i == ZINK_HEAP_DEVICE_LOCAL_VISIBLE);
2566          if (i == ZINK_HEAP_HOST_VISIBLE_CACHED)
2567             screen->heap_map[i] = screen->heap_map[ZINK_HEAP_HOST_VISIBLE_COHERENT];
2568          else
2569             screen->heap_map[i] = screen->heap_map[ZINK_HEAP_DEVICE_LOCAL];
2570       }
2571       screen->heap_flags[i] = screen->info.mem_props.memoryTypes[screen->heap_map[i]].propertyFlags;
2572    }
2573    {
2574       unsigned vis_vram = screen->heap_map[ZINK_HEAP_DEVICE_LOCAL_VISIBLE];
2575       unsigned vram = screen->heap_map[ZINK_HEAP_DEVICE_LOCAL];
2576       /* determine if vis vram is roughly equal to total vram */
2577       if (screen->info.mem_props.memoryHeaps[screen->info.mem_props.memoryTypes[vis_vram].heapIndex].size >
2578           screen->info.mem_props.memoryHeaps[screen->info.mem_props.memoryTypes[vram].heapIndex].size * 0.9)
2579          screen->resizable_bar = true;
2580    }
2581
2582    simple_mtx_init(&screen->dt_lock, mtx_plain);
2583
2584    util_idalloc_mt_init_tc(&screen->buffer_ids);
2585
2586    util_vertex_state_cache_init(&screen->vertex_state_cache,
2587                                 zink_create_vertex_state, zink_vertex_state_destroy);
2588    screen->base.create_vertex_state = zink_cache_create_vertex_state;
2589    screen->base.vertex_state_destroy = zink_cache_vertex_state_destroy;
2590    glsl_type_singleton_init_or_ref();
2591
2592    if (screen->info.have_vulkan13 || screen->info.have_KHR_synchronization2) {
2593       screen->image_barrier = zink_resource_image_barrier2;
2594       screen->buffer_barrier = zink_resource_buffer_barrier2;
2595    } else {
2596       screen->image_barrier = zink_resource_image_barrier;
2597       screen->buffer_barrier = zink_resource_buffer_barrier;
2598    }
2599
2600    if (!zink_descriptor_layouts_init(screen))
2601       goto fail;
2602
2603
2604    screen->copy_context = zink_context(screen->base.context_create(&screen->base, NULL, ZINK_CONTEXT_COPY_ONLY));
2605    if (!screen->copy_context) {
2606       mesa_loge("zink: failed to create copy context");
2607       goto fail;
2608    }
2609
2610    screen->optimal_keys = !screen->need_decompose_attrs && screen->info.have_EXT_non_seamless_cube_map && !screen->driconf.inline_uniforms;
2611    if (!screen->optimal_keys)
2612       screen->info.have_EXT_graphics_pipeline_library = false;
2613
2614    return screen;
2615
2616 fail:
2617    if (screen->loader_lib)
2618       util_dl_close(screen->loader_lib);
2619    if (screen->threaded)
2620       util_queue_destroy(&screen->flush_queue);
2621
2622    ralloc_free(screen);
2623    return NULL;
2624 }
2625
2626 struct pipe_screen *
2627 zink_create_screen(struct sw_winsys *winsys, const struct pipe_screen_config *config)
2628 {
2629    struct zink_screen *ret = zink_internal_create_screen(config);
2630    if (ret) {
2631       ret->drm_fd = -1;
2632    }
2633
2634    return &ret->base;
2635 }
2636
2637 struct pipe_screen *
2638 zink_drm_create_screen(int fd, const struct pipe_screen_config *config)
2639 {
2640    struct zink_screen *ret = zink_internal_create_screen(config);
2641
2642    if (ret)
2643       ret->drm_fd = os_dupfd_cloexec(fd);
2644    if (ret && !ret->info.have_KHR_external_memory_fd) {
2645       debug_printf("ZINK: KHR_external_memory_fd required!\n");
2646       zink_destroy_screen(&ret->base);
2647       return NULL;
2648    }
2649
2650    return &ret->base;
2651 }
2652
2653 void zink_stub_function_not_loaded()
2654 {
2655    /* this will be used by the zink_verify_*_extensions() functions on a
2656     * release build
2657     */
2658    mesa_loge("ZINK: a Vulkan function was called without being loaded");
2659    abort();
2660 }