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_compiler.h"
  27 #include "zink_context.h"
  28 #include "zink_fence.h"
  29 #include "zink_public.h"
  30 #include "zink_resource.h"
  31
  32 #include "os/os_process.h"
  33 #include "util/u_debug.h"
  34 #include "util/format/u_format.h"
  35 #include "util/u_math.h"
  36 #include "util/u_memory.h"
  37 #include "util/u_screen.h"
  38 #include "util/u_string.h"
  39
  40 #include "frontend/sw_winsys.h"
  41
  42 static const struct debug_named_value
  43 debug_options[] = {
  44    { "nir", ZINK_DEBUG_NIR, "Dump NIR during program compile" },
  45    { "spirv", ZINK_DEBUG_SPIRV, "Dump SPIR-V during program compile" },
  46    { "tgsi", ZINK_DEBUG_TGSI, "Dump TGSI during program compile" },
  47    DEBUG_NAMED_VALUE_END
  48 };
  49
  50 DEBUG_GET_ONCE_FLAGS_OPTION(zink_debug, "ZINK_DEBUG", debug_options, 0)
  51
  52 uint32_t
  53 zink_debug;
  54
  55 static const char *
  56 zink_get_vendor(struct pipe_screen *pscreen)
  57 {
  58    return "Collabora Ltd";
  59 }
  60
  61 static const char *
  62 zink_get_device_vendor(struct pipe_screen *pscreen)
  63 {
  64    struct zink_screen *screen = zink_screen(pscreen);
  65    static char buf[1000];
  66    snprintf(buf, sizeof(buf), "Unknown (vendor-id: 0x%04x)", screen->props.vendorID);
  67    return buf;
  68 }
  69
  70 static const char *
  71 zink_get_name(struct pipe_screen *pscreen)
  72 {
  73    struct zink_screen *screen = zink_screen(pscreen);
  74    static char buf[1000];
  75    snprintf(buf, sizeof(buf), "zink (%s)", screen->props.deviceName);
  76    return buf;
  77 }
  78
  79 static int
  80 get_video_mem(struct zink_screen *screen)
  81 {
  82    VkDeviceSize size = 0;
  83    for (uint32_t i = 0; i < screen->mem_props.memoryHeapCount; ++i) {
  84       if (screen->mem_props.memoryHeaps[i].flags &
  85           VK_MEMORY_HEAP_DEVICE_LOCAL_BIT)
  86          size += screen->mem_props.memoryHeaps[i].size;
  87    }
  88    return (int)(size >> 20);
  89 }
  90
  91 static int
  92 zink_get_param(struct pipe_screen *pscreen, enum pipe_cap param)
  93 {
  94    struct zink_screen *screen = zink_screen(pscreen);
  95
  96    switch (param) {
  97    case PIPE_CAP_NPOT_TEXTURES:
  98    case PIPE_CAP_TGSI_TEXCOORD:
  99       return 1;
 100
 101    case PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS:
 102       if (!screen->feats.dualSrcBlend)
 103          return 0;
 104       return screen->props.limits.maxFragmentDualSrcAttachments;
 105
 106    case PIPE_CAP_POINT_SPRITE:
 107       return 1;
 108
 109    case PIPE_CAP_MAX_RENDER_TARGETS:
 110       return screen->props.limits.maxColorAttachments;
 111
 112    case PIPE_CAP_OCCLUSION_QUERY:
 113       return 1;
 114
 115 #if 0 /* TODO: Enable me */
 116    case PIPE_CAP_QUERY_TIME_ELAPSED:
 117       return 1;
 118 #endif
 119
 120    case PIPE_CAP_TEXTURE_MULTISAMPLE:
 121       return 1;
 122
 123    case PIPE_CAP_TEXTURE_SWIZZLE:
 124       return 1;
 125
 126    case PIPE_CAP_MAX_TEXTURE_2D_SIZE:
 127       return screen->props.limits.maxImageDimension2D;
 128    case PIPE_CAP_MAX_TEXTURE_3D_LEVELS:
 129       return 1 + util_logbase2(screen->props.limits.maxImageDimension3D);
 130    case PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS:
 131       return 1 + util_logbase2(screen->props.limits.maxImageDimensionCube);
 132
 133    case PIPE_CAP_BLEND_EQUATION_SEPARATE:
 134    case PIPE_CAP_FRAGMENT_SHADER_TEXTURE_LOD:
 135    case PIPE_CAP_FRAGMENT_SHADER_DERIVATIVES:
 136    case PIPE_CAP_VERTEX_SHADER_SATURATE:
 137       return 1;
 138
 139    case PIPE_CAP_INDEP_BLEND_ENABLE:
 140    case PIPE_CAP_INDEP_BLEND_FUNC:
 141       return 1;
 142
 143    case PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS:
 144       return screen->have_EXT_transform_feedback ? screen->tf_props.maxTransformFeedbackBuffers : 0;
 145    case PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME:
 146    case PIPE_CAP_STREAM_OUTPUT_INTERLEAVE_BUFFERS:
 147       return 1;
 148
 149    case PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS:
 150       return screen->props.limits.maxImageArrayLayers;
 151
 152    case PIPE_CAP_DEPTH_CLIP_DISABLE:
 153       return screen->feats.depthClamp;
 154
 155    case PIPE_CAP_TGSI_INSTANCEID:
 156    case PIPE_CAP_MIXED_COLORBUFFER_FORMATS:
 157    case PIPE_CAP_SEAMLESS_CUBE_MAP:
 158       return 1;
 159
 160    case PIPE_CAP_MIN_TEXEL_OFFSET:
 161       return screen->props.limits.minTexelOffset;
 162    case PIPE_CAP_MAX_TEXEL_OFFSET:
 163       return screen->props.limits.maxTexelOffset;
 164
 165    case PIPE_CAP_VERTEX_COLOR_UNCLAMPED:
 166       return 1;
 167
 168    case PIPE_CAP_CONDITIONAL_RENDER:
 169      return screen->have_EXT_conditional_rendering;
 170
 171    case PIPE_CAP_GLSL_FEATURE_LEVEL:
 172    case PIPE_CAP_GLSL_FEATURE_LEVEL_COMPATIBILITY:
 173       return 130;
 174
 175 #if 0 /* TODO: Enable me */
 176    case PIPE_CAP_COMPUTE:
 177       return 1;
 178 #endif
 179
 180    case PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT:
 181       return screen->props.limits.minUniformBufferOffsetAlignment;
 182
 183 #if 0 /* TODO: Enable me */
 184    case PIPE_CAP_QUERY_TIMESTAMP:
 185       return 1;
 186 #endif
 187
 188    case PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT:
 189       return screen->props.limits.minMemoryMapAlignment;
 190
 191    case PIPE_CAP_CUBE_MAP_ARRAY:
 192       return screen->feats.imageCubeArray;
 193
 194    case PIPE_CAP_TEXTURE_BUFFER_OBJECTS:
 195    case PIPE_CAP_PRIMITIVE_RESTART:
 196       return 1;
 197
 198    case PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT:
 199       return screen->props.limits.minTexelBufferOffsetAlignment;
 200
 201    case PIPE_CAP_PREFER_BLIT_BASED_TEXTURE_TRANSFER:
 202       return 0; /* unsure */
 203
 204    case PIPE_CAP_MAX_TEXTURE_BUFFER_SIZE:
 205       return screen->props.limits.maxTexelBufferElements;
 206
 207    case PIPE_CAP_ENDIANNESS:
 208       return PIPE_ENDIAN_NATIVE; /* unsure */
 209
 210    case PIPE_CAP_MAX_VIEWPORTS:
 211       return 1; /* TODO: When GS is supported, use screen->props.limits.maxViewports */
 212
 213    case PIPE_CAP_MIXED_FRAMEBUFFER_SIZES:
 214       return 1;
 215
 216    case PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES:
 217       return screen->props.limits.maxGeometryOutputVertices;
 218    case PIPE_CAP_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS:
 219       return screen->props.limits.maxGeometryOutputComponents;
 220
 221 #if 0 /* TODO: Enable me. Enables ARB_texture_gather */
 222    case PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS:
 223       return 4;
 224 #endif
 225
 226    case PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET:
 227       return screen->props.limits.minTexelGatherOffset;
 228    case PIPE_CAP_MAX_TEXTURE_GATHER_OFFSET:
 229       return screen->props.limits.maxTexelGatherOffset;
 230
 231    case PIPE_CAP_TGSI_FS_FINE_DERIVATIVE:
 232       return 1;
 233
 234    case PIPE_CAP_VENDOR_ID:
 235       return screen->props.vendorID;
 236    case PIPE_CAP_DEVICE_ID:
 237       return screen->props.deviceID;
 238
 239    case PIPE_CAP_ACCELERATED:
 240       return 1;
 241    case PIPE_CAP_VIDEO_MEMORY:
 242       return get_video_mem(screen);
 243    case PIPE_CAP_UMA:
 244       return screen->props.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
 245
 246    case PIPE_CAP_MAX_VERTEX_ATTRIB_STRIDE:
 247       return screen->props.limits.maxVertexInputBindingStride;
 248
 249 #if 0 /* TODO: Enable me */
 250    case PIPE_CAP_SAMPLER_VIEW_TARGET:
 251       return 1;
 252 #endif
 253
 254 #if 0 /* TODO: Enable me */
 255    case PIPE_CAP_CLIP_HALFZ:
 256       return 1;
 257 #endif
 258
 259 #if 0 /* TODO: Enable me */
 260    case PIPE_CAP_TEXTURE_FLOAT_LINEAR:
 261    case PIPE_CAP_TEXTURE_HALF_FLOAT_LINEAR:
 262       return 1;
 263 #endif
 264
 265    case PIPE_CAP_SHAREABLE_SHADERS:
 266       return 1;
 267
 268 #if 0 /* TODO: Enable me. Enables GL_ARB_shader_storage_buffer_object */
 269    case PIPE_CAP_SHADER_BUFFER_OFFSET_ALIGNMENT:
 270       return screen->props.limits.minStorageBufferOffsetAlignment;
 271 #endif
 272
 273    case PIPE_CAP_PCI_GROUP:
 274    case PIPE_CAP_PCI_BUS:
 275    case PIPE_CAP_PCI_DEVICE:
 276    case PIPE_CAP_PCI_FUNCTION:
 277       return 0; /* TODO: figure these out */
 278
 279    case PIPE_CAP_CULL_DISTANCE:
 280       return screen->feats.shaderCullDistance;
 281
 282    case PIPE_CAP_VIEWPORT_SUBPIXEL_BITS:
 283       return screen->props.limits.viewportSubPixelBits;
 284
 285    case PIPE_CAP_GLSL_OPTIMIZE_CONSERVATIVELY:
 286       return 0; /* not sure */
 287
 288    case PIPE_CAP_MAX_GS_INVOCATIONS:
 289       return 0; /* not implemented */
 290
 291    case PIPE_CAP_MAX_COMBINED_SHADER_BUFFERS:
 292       return screen->props.limits.maxDescriptorSetStorageBuffers;
 293
 294    case PIPE_CAP_MAX_SHADER_BUFFER_SIZE:
 295       return screen->props.limits.maxStorageBufferRange; /* unsure */
 296
 297    case PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT:
 298    case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER:
 299       return 1;
 300
 301    case PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT:
 302    case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER:
 303       return 0;
 304
 305    case PIPE_CAP_BUFFER_MAP_PERSISTENT_COHERENT:
 306       return 0;
 307
 308    case PIPE_CAP_NIR_COMPACT_ARRAYS:
 309       return 1;
 310
 311    case PIPE_CAP_TGSI_FS_FACE_IS_INTEGER_SYSVAL:
 312       return 1;
 313
 314    case PIPE_CAP_VIEWPORT_TRANSFORM_LOWERED:
 315       return 1;
 316
 317    case PIPE_CAP_FLATSHADE:
 318    case PIPE_CAP_ALPHA_TEST:
 319    case PIPE_CAP_CLIP_PLANES:
 320    case PIPE_CAP_POINT_SIZE_FIXED:
 321    case PIPE_CAP_TWO_SIDED_COLOR:
 322       return 0;
 323
 324    case PIPE_CAP_DMABUF:
 325       return screen->have_KHR_external_memory_fd;
 326
 327    default:
 328       return u_pipe_screen_get_param_defaults(pscreen, param);
 329    }
 330 }
 331
 332 static float
 333 zink_get_paramf(struct pipe_screen *pscreen, enum pipe_capf param)
 334 {
 335    struct zink_screen *screen = zink_screen(pscreen);
 336
 337    switch (param) {
 338    case PIPE_CAPF_MAX_LINE_WIDTH:
 339    case PIPE_CAPF_MAX_LINE_WIDTH_AA:
 340       return screen->props.limits.lineWidthRange[1];
 341
 342    case PIPE_CAPF_MAX_POINT_WIDTH:
 343    case PIPE_CAPF_MAX_POINT_WIDTH_AA:
 344       return screen->props.limits.pointSizeRange[1];
 345
 346    case PIPE_CAPF_MAX_TEXTURE_ANISOTROPY:
 347       return screen->props.limits.maxSamplerAnisotropy;
 348
 349    case PIPE_CAPF_MAX_TEXTURE_LOD_BIAS:
 350       return screen->props.limits.maxSamplerLodBias;
 351
 352    case PIPE_CAPF_MIN_CONSERVATIVE_RASTER_DILATE:
 353    case PIPE_CAPF_MAX_CONSERVATIVE_RASTER_DILATE:
 354    case PIPE_CAPF_CONSERVATIVE_RASTER_DILATE_GRANULARITY:
 355       return 0.0f; /* not implemented */
 356    }
 357
 358    /* should only get here on unhandled cases */
 359    return 0.0;
 360 }
 361
 362 static int
 363 zink_get_shader_param(struct pipe_screen *pscreen,
 364                        enum pipe_shader_type shader,
 365                        enum pipe_shader_cap param)
 366 {
 367    struct zink_screen *screen = zink_screen(pscreen);
 368
 369    switch (param) {
 370    case PIPE_SHADER_CAP_MAX_INSTRUCTIONS:
 371    case PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS:
 372    case PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS:
 373    case PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS:
 374    case PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH:
 375       if (shader == PIPE_SHADER_VERTEX ||
 376           shader == PIPE_SHADER_FRAGMENT)
 377          return INT_MAX;
 378       return 0;
 379
 380    case PIPE_SHADER_CAP_MAX_INPUTS:
 381       switch (shader) {
 382       case PIPE_SHADER_VERTEX:
 383          return MIN2(screen->props.limits.maxVertexInputAttributes,
 384                      PIPE_MAX_SHADER_INPUTS);
 385       case PIPE_SHADER_FRAGMENT:
 386          return MIN2(screen->props.limits.maxFragmentInputComponents / 4,
 387                      PIPE_MAX_SHADER_INPUTS);
 388       default:
 389          return 0; /* unsupported stage */
 390       }
 391
 392    case PIPE_SHADER_CAP_MAX_OUTPUTS:
 393       switch (shader) {
 394       case PIPE_SHADER_VERTEX:
 395          return MIN2(screen->props.limits.maxVertexOutputComponents / 4,
 396                      PIPE_MAX_SHADER_OUTPUTS);
 397       case PIPE_SHADER_FRAGMENT:
 398          return MIN2(screen->props.limits.maxColorAttachments,
 399                 PIPE_MAX_SHADER_OUTPUTS);
 400       default:
 401          return 0; /* unsupported stage */
 402       }
 403
 404    case PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS:
 405       switch (shader) {
 406       case PIPE_SHADER_VERTEX:
 407       case PIPE_SHADER_FRAGMENT:
 408          /* this might be a bit simplistic... */
 409          return MIN2(screen->props.limits.maxPerStageDescriptorSamplers,
 410                      PIPE_MAX_SAMPLERS);
 411       default:
 412          return 0; /* unsupported stage */
 413       }
 414
 415    case PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE:
 416       return MIN2(screen->props.limits.maxUniformBufferRange, INT_MAX);
 417
 418    case PIPE_SHADER_CAP_MAX_CONST_BUFFERS:
 419       return screen->props.limits.maxPerStageDescriptorUniformBuffers;
 420
 421    case PIPE_SHADER_CAP_MAX_TEMPS:
 422       return INT_MAX;
 423
 424    case PIPE_SHADER_CAP_INTEGERS:
 425       return 1;
 426
 427    case PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR:
 428    case PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR:
 429    case PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR:
 430    case PIPE_SHADER_CAP_INDIRECT_CONST_ADDR:
 431    case PIPE_SHADER_CAP_SUBROUTINES:
 432    case PIPE_SHADER_CAP_INT64_ATOMICS:
 433    case PIPE_SHADER_CAP_FP16:
 434    case PIPE_SHADER_CAP_FP16_DERIVATIVES:
 435    case PIPE_SHADER_CAP_INT16:
 436    case PIPE_SHADER_CAP_GLSL_16BIT_CONSTS:
 437       return 0; /* not implemented */
 438
 439    case PIPE_SHADER_CAP_PREFERRED_IR:
 440       return PIPE_SHADER_IR_NIR;
 441
 442    case PIPE_SHADER_CAP_TGSI_SQRT_SUPPORTED:
 443       return 0; /* not implemented */
 444
 445    case PIPE_SHADER_CAP_MAX_SAMPLER_VIEWS:
 446       return MIN2(screen->props.limits.maxPerStageDescriptorSampledImages,
 447                   PIPE_MAX_SHADER_SAMPLER_VIEWS);
 448
 449    case PIPE_SHADER_CAP_TGSI_DROUND_SUPPORTED:
 450    case PIPE_SHADER_CAP_TGSI_DFRACEXP_DLDEXP_SUPPORTED:
 451    case PIPE_SHADER_CAP_TGSI_FMA_SUPPORTED:
 452       return 0; /* not implemented */
 453
 454    case PIPE_SHADER_CAP_TGSI_ANY_INOUT_DECL_RANGE:
 455       return 0; /* no idea */
 456
 457    case PIPE_SHADER_CAP_MAX_UNROLL_ITERATIONS_HINT:
 458       return 32; /* arbitrary */
 459
 460    case PIPE_SHADER_CAP_MAX_SHADER_BUFFERS:
 461       /* TODO: this limitation is dumb, and will need some fixes in mesa */
 462       return MIN2(screen->props.limits.maxPerStageDescriptorStorageBuffers, PIPE_MAX_SHADER_BUFFERS);
 463
 464    case PIPE_SHADER_CAP_SUPPORTED_IRS:
 465       return (1 << PIPE_SHADER_IR_NIR) | (1 << PIPE_SHADER_IR_TGSI);
 466
 467    case PIPE_SHADER_CAP_MAX_SHADER_IMAGES:
 468 #if 0 /* TODO: needs compiler support */
 469       return MIN2(screen->props.limits.maxPerStageDescriptorStorageImages,
 470                   PIPE_MAX_SHADER_IMAGES);
 471 #else
 472       return 0;
 473 #endif
 474
 475    case PIPE_SHADER_CAP_LOWER_IF_THRESHOLD:
 476    case PIPE_SHADER_CAP_TGSI_SKIP_MERGE_REGISTERS:
 477       return 0; /* unsure */
 478
 479    case PIPE_SHADER_CAP_TGSI_LDEXP_SUPPORTED:
 480    case PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTERS:
 481    case PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTER_BUFFERS:
 482    case PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED:
 483       return 0; /* not implemented */
 484    }
 485
 486    /* should only get here on unhandled cases */
 487    return 0;
 488 }
 489
 490 static VkSampleCountFlagBits
 491 vk_sample_count_flags(uint32_t sample_count)
 492 {
 493    switch (sample_count) {
 494    case 1: return VK_SAMPLE_COUNT_1_BIT;
 495    case 2: return VK_SAMPLE_COUNT_2_BIT;
 496    case 4: return VK_SAMPLE_COUNT_4_BIT;
 497    case 8: return VK_SAMPLE_COUNT_8_BIT;
 498    case 16: return VK_SAMPLE_COUNT_16_BIT;
 499    case 32: return VK_SAMPLE_COUNT_32_BIT;
 500    case 64: return VK_SAMPLE_COUNT_64_BIT;
 501    default:
 502       return 0;
 503    }
 504 }
 505
 506 static bool
 507 zink_is_format_supported(struct pipe_screen *pscreen,
 508                          enum pipe_format format,
 509                          enum pipe_texture_target target,
 510                          unsigned sample_count,
 511                          unsigned storage_sample_count,
 512                          unsigned bind)
 513 {
 514    struct zink_screen *screen = zink_screen(pscreen);
 515
 516    if (format == PIPE_FORMAT_NONE)
 517       return screen->props.limits.framebufferNoAttachmentsSampleCounts &
 518              vk_sample_count_flags(sample_count);
 519
 520    VkFormat vkformat = zink_get_format(screen, format);
 521    if (vkformat == VK_FORMAT_UNDEFINED)
 522       return false;
 523
 524    if (sample_count >= 1) {
 525       VkSampleCountFlagBits sample_mask = vk_sample_count_flags(sample_count);
 526       if (!sample_mask)
 527          return false;
 528       const struct util_format_description *desc = util_format_description(format);
 529       if (util_format_is_depth_or_stencil(format)) {
 530          if (util_format_has_depth(desc)) {
 531             if (bind & PIPE_BIND_DEPTH_STENCIL &&
 532                 (screen->props.limits.framebufferDepthSampleCounts & sample_mask) != sample_mask)
 533                return false;
 534             if (bind & PIPE_BIND_SAMPLER_VIEW &&
 535                 (screen->props.limits.sampledImageDepthSampleCounts & sample_mask) != sample_mask)
 536                return false;
 537          }
 538          if (util_format_has_stencil(desc)) {
 539             if (bind & PIPE_BIND_DEPTH_STENCIL &&
 540                 (screen->props.limits.framebufferStencilSampleCounts & sample_mask) != sample_mask)
 541                return false;
 542             if (bind & PIPE_BIND_SAMPLER_VIEW &&
 543                 (screen->props.limits.sampledImageStencilSampleCounts & sample_mask) != sample_mask)
 544                return false;
 545          }
 546       } else if (util_format_is_pure_integer(format)) {
 547          if (bind & PIPE_BIND_RENDER_TARGET &&
 548              !(screen->props.limits.framebufferColorSampleCounts & sample_mask))
 549             return false;
 550          if (bind & PIPE_BIND_SAMPLER_VIEW &&
 551              !(screen->props.limits.sampledImageIntegerSampleCounts & sample_mask))
 552             return false;
 553       } else {
 554          if (bind & PIPE_BIND_RENDER_TARGET &&
 555              !(screen->props.limits.framebufferColorSampleCounts & sample_mask))
 556             return false;
 557          if (bind & PIPE_BIND_SAMPLER_VIEW &&
 558              !(screen->props.limits.sampledImageColorSampleCounts & sample_mask))
 559             return false;
 560       }
 561    }
 562
 563    VkFormatProperties props;
 564    vkGetPhysicalDeviceFormatProperties(screen->pdev, vkformat, &props);
 565
 566    if (target == PIPE_BUFFER) {
 567       if (bind & PIPE_BIND_VERTEX_BUFFER &&
 568           !(props.bufferFeatures & VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT))
 569          return false;
 570    } else {
 571       /* all other targets are texture-targets */
 572       if (bind & PIPE_BIND_RENDER_TARGET &&
 573           !(props.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT))
 574          return false;
 575
 576       if (bind & PIPE_BIND_BLENDABLE &&
 577          !(props.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT))
 578         return false;
 579
 580       if (bind & PIPE_BIND_SAMPLER_VIEW &&
 581           !(props.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT))
 582          return false;
 583
 584       if (bind & PIPE_BIND_DEPTH_STENCIL &&
 585           !(props.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT))
 586          return false;
 587    }
 588
 589    if (util_format_is_compressed(format)) {
 590       const struct util_format_description *desc = util_format_description(format);
 591       if (desc->layout == UTIL_FORMAT_LAYOUT_BPTC &&
 592           !screen->feats.textureCompressionBC)
 593          return false;
 594    }
 595
 596    return true;
 597 }
 598
 599 static void
 600 zink_destroy_screen(struct pipe_screen *pscreen)
 601 {
 602    struct zink_screen *screen = zink_screen(pscreen);
 603    slab_destroy_parent(&screen->transfer_pool);
 604    FREE(screen);
 605 }
 606
 607 static VkInstance
 608 create_instance()
 609 {
 610    VkApplicationInfo ai = {};
 611    ai.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
 612
 613    char proc_name[128];
 614    if (os_get_process_name(proc_name, ARRAY_SIZE(proc_name)))
 615       ai.pApplicationName = proc_name;
 616    else
 617       ai.pApplicationName = "unknown";
 618
 619    ai.pEngineName = "mesa zink";
 620    ai.apiVersion = VK_API_VERSION_1_0;
 621
 622    const char *extensions[] = {
 623       VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
 624       VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME,
 625    };
 626
 627    VkInstanceCreateInfo ici = {};
 628    ici.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
 629    ici.pApplicationInfo = &ai;
 630    ici.ppEnabledExtensionNames = extensions;
 631    ici.enabledExtensionCount = ARRAY_SIZE(extensions);
 632
 633    VkInstance instance = VK_NULL_HANDLE;
 634    VkResult err = vkCreateInstance(&ici, NULL, &instance);
 635    if (err != VK_SUCCESS)
 636       return VK_NULL_HANDLE;
 637
 638    return instance;
 639 }
 640
 641 static VkPhysicalDevice
 642 choose_pdev(const VkInstance instance)
 643 {
 644    uint32_t i, pdev_count;
 645    VkPhysicalDevice *pdevs, pdev;
 646    vkEnumeratePhysicalDevices(instance, &pdev_count, NULL);
 647    assert(pdev_count > 0);
 648
 649    pdevs = malloc(sizeof(*pdevs) * pdev_count);
 650    vkEnumeratePhysicalDevices(instance, &pdev_count, pdevs);
 651    assert(pdev_count > 0);
 652
 653    pdev = pdevs[0];
 654    for (i = 0; i < pdev_count; ++i) {
 655       VkPhysicalDeviceProperties props;
 656       vkGetPhysicalDeviceProperties(pdevs[i], &props);
 657       if (props.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) {
 658          pdev = pdevs[i];
 659          break;
 660       }
 661    }
 662    free(pdevs);
 663    return pdev;
 664 }
 665
 666 static void
 667 update_queue_props(struct zink_screen *screen)
 668 {
 669    uint32_t num_queues;
 670    vkGetPhysicalDeviceQueueFamilyProperties(screen->pdev, &num_queues, NULL);
 671    assert(num_queues > 0);
 672
 673    VkQueueFamilyProperties *props = malloc(sizeof(*props) * num_queues);
 674    vkGetPhysicalDeviceQueueFamilyProperties(screen->pdev, &num_queues, props);
 675
 676    for (uint32_t i = 0; i < num_queues; i++) {
 677       if (props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
 678          screen->gfx_queue = i;
 679          screen->timestamp_valid_bits = props[i].timestampValidBits;
 680          assert(screen->timestamp_valid_bits);
 681          break;
 682       }
 683    }
 684    free(props);
 685 }
 686
 687 static void
 688 zink_flush_frontbuffer(struct pipe_screen *pscreen,
 689                        struct pipe_resource *pres,
 690                        unsigned level, unsigned layer,
 691                        void *winsys_drawable_handle,
 692                        struct pipe_box *sub_box)
 693 {
 694    struct zink_screen *screen = zink_screen(pscreen);
 695    struct sw_winsys *winsys = screen->winsys;
 696    struct zink_resource *res = zink_resource(pres);
 697
 698    if (!winsys)
 699      return;
 700    void *map = winsys->displaytarget_map(winsys, res->dt, 0);
 701
 702    if (map) {
 703       VkImageSubresource isr = {};
 704       isr.aspectMask = res->aspect;
 705       isr.mipLevel = level;
 706       isr.arrayLayer = layer;
 707       VkSubresourceLayout layout;
 708       vkGetImageSubresourceLayout(screen->dev, res->image, &isr, &layout);
 709
 710       void *ptr;
 711       VkResult result = vkMapMemory(screen->dev, res->mem, res->offset, res->size, 0, &ptr);
 712       if (result != VK_SUCCESS) {
 713          debug_printf("failed to map memory for display\n");
 714          return;
 715       }
 716       for (int i = 0; i < pres->height0; ++i) {
 717          uint8_t *src = (uint8_t *)ptr + i * layout.rowPitch;
 718          uint8_t *dst = (uint8_t *)map + i * res->dt_stride;
 719          memcpy(dst, src, res->dt_stride);
 720       }
 721       vkUnmapMemory(screen->dev, res->mem);
 722    }
 723
 724    winsys->displaytarget_unmap(winsys, res->dt);
 725
 726    assert(res->dt);
 727    if (res->dt)
 728       winsys->displaytarget_display(winsys, res->dt, winsys_drawable_handle, sub_box);
 729 }
 730
 731 static bool
 732 load_device_extensions(struct zink_screen *screen)
 733 {
 734 #define GET_PROC_ADDR(x) do {                                               \
 735       screen->vk_##x = (PFN_vk##x)vkGetDeviceProcAddr(screen->dev, "vk"#x); \
 736       if (!screen->vk_##x)                                                  \
 737          return false;                                                      \
 738    } while (0)
 739
 740 #define GET_PROC_ADDR_INSTANCE(x) do {                                          \
 741       screen->vk_##x = (PFN_vk##x)vkGetInstanceProcAddr(screen->instance, "vk"#x); \
 742       if (!screen->vk_##x) {                                                \
 743          debug_printf("GetInstanceProcAddr failed: vk"#x"\n");        \
 744          return false;                                                      \
 745       } \
 746    } while (0)
 747    if (screen->have_EXT_transform_feedback) {
 748       GET_PROC_ADDR(CmdBindTransformFeedbackBuffersEXT);
 749       GET_PROC_ADDR(CmdBeginTransformFeedbackEXT);
 750       GET_PROC_ADDR(CmdEndTransformFeedbackEXT);
 751       GET_PROC_ADDR(CmdBeginQueryIndexedEXT);
 752       GET_PROC_ADDR(CmdEndQueryIndexedEXT);
 753       GET_PROC_ADDR(CmdDrawIndirectByteCountEXT);
 754    }
 755    if (screen->have_KHR_external_memory_fd)
 756       GET_PROC_ADDR(GetMemoryFdKHR);
 757
 758    if (screen->have_EXT_conditional_rendering) {
 759       GET_PROC_ADDR(CmdBeginConditionalRenderingEXT);
 760       GET_PROC_ADDR(CmdEndConditionalRenderingEXT);
 761    }
 762
 763    if (screen->have_EXT_calibrated_timestamps) {
 764       GET_PROC_ADDR_INSTANCE(GetPhysicalDeviceCalibrateableTimeDomainsEXT);
 765       GET_PROC_ADDR(GetCalibratedTimestampsEXT);
 766
 767       uint32_t num_domains = 0;
 768       screen->vk_GetPhysicalDeviceCalibrateableTimeDomainsEXT(screen->pdev, &num_domains, NULL);
 769       assert(num_domains > 0);
 770
 771       VkTimeDomainEXT *domains = malloc(sizeof(VkTimeDomainEXT) * num_domains);
 772       screen->vk_GetPhysicalDeviceCalibrateableTimeDomainsEXT(screen->pdev, &num_domains, domains);
 773
 774       /* VK_TIME_DOMAIN_DEVICE_EXT is used for the ctx->get_timestamp hook and is the only one we really need */
 775       bool have_device_time = false;
 776       for (unsigned i = 0; i < num_domains; i++) {
 777          if (domains[i] == VK_TIME_DOMAIN_DEVICE_EXT) {
 778             have_device_time = true;
 779             break;
 780          }
 781       }
 782       assert(have_device_time);
 783       free(domains);
 784    }
 785
 786 #undef GET_PROC_ADDR
 787
 788    return true;
 789 }
 790
 791 static struct pipe_screen *
 792 zink_internal_create_screen(struct sw_winsys *winsys, int fd)
 793 {
 794    struct zink_screen *screen = CALLOC_STRUCT(zink_screen);
 795    bool have_tf_ext = false, have_cond_render_ext = false, have_EXT_index_type_uint8 = false,
 796       have_EXT_robustness2_features = false, have_EXT_vertex_attribute_divisor = false,
 797       have_EXT_calibrated_timestamps = false;
 798    if (!screen)
 799       return NULL;
 800
 801    zink_debug = debug_get_option_zink_debug();
 802
 803    screen->instance = create_instance();
 804    screen->pdev = choose_pdev(screen->instance);
 805    update_queue_props(screen);
 806
 807    vkGetPhysicalDeviceMemoryProperties(screen->pdev, &screen->mem_props);
 808
 809    screen->have_X8_D24_UNORM_PACK32 = zink_is_depth_format_supported(screen,
 810                                               VK_FORMAT_X8_D24_UNORM_PACK32);
 811    screen->have_D24_UNORM_S8_UINT = zink_is_depth_format_supported(screen,
 812                                               VK_FORMAT_D24_UNORM_S8_UINT);
 813
 814    uint32_t num_extensions = 0;
 815    if (vkEnumerateDeviceExtensionProperties(screen->pdev, NULL,
 816        &num_extensions, NULL) == VK_SUCCESS && num_extensions > 0) {
 817       VkExtensionProperties *extensions = MALLOC(sizeof(VkExtensionProperties) *
 818                                                 num_extensions);
 819       if (extensions) {
 820          vkEnumerateDeviceExtensionProperties(screen->pdev, NULL,
 821                                               &num_extensions, extensions);
 822
 823          for (uint32_t  i = 0; i < num_extensions; ++i) {
 824             if (!strcmp(extensions[i].extensionName,
 825                         VK_KHR_MAINTENANCE1_EXTENSION_NAME))
 826                screen->have_KHR_maintenance1 = true;
 827             if (!strcmp(extensions[i].extensionName,
 828                         VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME))
 829                screen->have_KHR_external_memory_fd = true;
 830             if (!strcmp(extensions[i].extensionName,
 831                         VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME))
 832                have_cond_render_ext = true;
 833             if (!strcmp(extensions[i].extensionName,
 834                         VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME))
 835                have_tf_ext = true;
 836             if (!strcmp(extensions[i].extensionName,
 837                         VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME))
 838                have_EXT_index_type_uint8 = true;
 839             if (!strcmp(extensions[i].extensionName,
 840                         VK_EXT_ROBUSTNESS_2_EXTENSION_NAME))
 841                have_EXT_robustness2_features = true;
 842             if (!strcmp(extensions[i].extensionName,
 843                         VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME))
 844                have_EXT_vertex_attribute_divisor = true;
 845             if (!strcmp(extensions[i].extensionName,
 846                         VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME))
 847                have_EXT_calibrated_timestamps = true;
 848
 849          }
 850          FREE(extensions);
 851       }
 852    }
 853    VkPhysicalDeviceFeatures2 feats = {};
 854    VkPhysicalDeviceTransformFeedbackFeaturesEXT tf_feats = {};
 855    VkPhysicalDeviceConditionalRenderingFeaturesEXT cond_render_feats = {};
 856    VkPhysicalDeviceIndexTypeUint8FeaturesEXT index_uint8_feats = {};
 857
 858    feats.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
 859    if (have_tf_ext) {
 860       tf_feats.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
 861       tf_feats.pNext = feats.pNext;
 862       feats.pNext = &tf_feats;
 863    }
 864    if (have_cond_render_ext) {
 865       cond_render_feats.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
 866       cond_render_feats.pNext = feats.pNext;
 867       feats.pNext = &cond_render_feats;
 868    }
 869    if (have_EXT_index_type_uint8) {
 870       index_uint8_feats.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
 871       index_uint8_feats.pNext = feats.pNext;
 872       feats.pNext = &index_uint8_feats;
 873    }
 874    if (have_EXT_robustness2_features) {
 875       screen->rb2_feats.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
 876       screen->rb2_feats.pNext = feats.pNext;
 877       feats.pNext = &screen->rb2_feats;
 878    }
 879    if (have_EXT_vertex_attribute_divisor) {
 880       screen->vdiv_feats.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
 881       screen->vdiv_feats.pNext = feats.pNext;
 882       feats.pNext = &screen->vdiv_feats;
 883    }
 884    vkGetPhysicalDeviceFeatures2(screen->pdev, &feats);
 885    memcpy(&screen->feats, &feats.features, sizeof(screen->feats));
 886    if (have_tf_ext && tf_feats.transformFeedback)
 887       screen->have_EXT_transform_feedback = true;
 888    if (have_cond_render_ext && cond_render_feats.conditionalRendering)
 889       screen->have_EXT_conditional_rendering = true;
 890    if (have_EXT_index_type_uint8 && index_uint8_feats.indexTypeUint8)
 891       screen->have_EXT_index_type_uint8 = true;
 892    screen->have_EXT_robustness2_features = have_EXT_robustness2_features;
 893    if (have_EXT_vertex_attribute_divisor && screen->vdiv_feats.vertexAttributeInstanceRateDivisor)
 894       screen->have_EXT_vertex_attribute_divisor = true;
 895    screen->have_EXT_calibrated_timestamps = have_EXT_calibrated_timestamps;
 896
 897    VkPhysicalDeviceProperties2 props = {};
 898    VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT vdiv_props = {};
 899    props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
 900    if (screen->have_EXT_transform_feedback) {
 901       screen->tf_props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
 902       screen->tf_props.pNext = props.pNext;
 903       props.pNext = &screen->tf_props;
 904    }
 905    if (have_EXT_robustness2_features) {
 906       screen->rb2_props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT;
 907       screen->rb2_props.pNext = props.pNext;
 908       props.pNext = &screen->rb2_props;
 909    }
 910    if (have_EXT_vertex_attribute_divisor) {
 911       vdiv_props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT;
 912       vdiv_props.pNext = props.pNext;
 913       props.pNext = &vdiv_props;
 914    }
 915    vkGetPhysicalDeviceProperties2(screen->pdev, &props);
 916    memcpy(&screen->props, &props.properties, sizeof(screen->props));
 917    screen->max_vertex_attrib_divisor = vdiv_props.maxVertexAttribDivisor;
 918
 919    if (!screen->have_KHR_maintenance1) {
 920       debug_printf("ZINK: VK_KHR_maintenance1 required!\n");
 921       goto fail;
 922    }
 923
 924    VkDeviceQueueCreateInfo qci = {};
 925    float dummy = 0.0f;
 926    qci.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
 927    qci.queueFamilyIndex = screen->gfx_queue;
 928    qci.queueCount = 1;
 929    qci.pQueuePriorities = &dummy;
 930
 931    VkDeviceCreateInfo dci = {};
 932    dci.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
 933    dci.queueCreateInfoCount = 1;
 934    dci.pQueueCreateInfos = &qci;
 935    /* extensions don't have bool members in pEnabledFeatures.
 936     * this requires us to pass the whole VkPhysicalDeviceFeatures2 struct
 937     */
 938    dci.pNext = &feats;
 939    const char *extensions[9] = {
 940       VK_KHR_MAINTENANCE1_EXTENSION_NAME,
 941    };
 942    num_extensions = 1;
 943
 944    if (fd >= 0 && !screen->have_KHR_external_memory_fd) {
 945       debug_printf("ZINK: KHR_external_memory_fd required!\n");
 946       goto fail;
 947    }
 948
 949    if (screen->have_KHR_external_memory_fd) {
 950       extensions[num_extensions++] = VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME;
 951       extensions[num_extensions++] = VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME;
 952    }
 953
 954    if (screen->have_EXT_conditional_rendering)
 955       extensions[num_extensions++] = VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME;
 956
 957    if (screen->have_EXT_index_type_uint8)
 958       extensions[num_extensions++] = VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME;
 959
 960    if (screen->have_EXT_transform_feedback)
 961       extensions[num_extensions++] = VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME;
 962    if (screen->have_EXT_robustness2_features)
 963       extensions[num_extensions++] = VK_EXT_ROBUSTNESS_2_EXTENSION_NAME;
 964    if (screen->have_EXT_vertex_attribute_divisor)
 965       extensions[num_extensions++] = VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME;
 966    if (screen->have_EXT_calibrated_timestamps)
 967       extensions[num_extensions++] = VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME;
 968    assert(num_extensions <= ARRAY_SIZE(extensions));
 969
 970    dci.ppEnabledExtensionNames = extensions;
 971    dci.enabledExtensionCount = num_extensions;
 972    if (vkCreateDevice(screen->pdev, &dci, NULL, &screen->dev) != VK_SUCCESS)
 973       goto fail;
 974
 975    if (!load_device_extensions(screen))
 976       goto fail;
 977
 978    screen->winsys = winsys;
 979
 980    screen->base.get_name = zink_get_name;
 981    screen->base.get_vendor = zink_get_vendor;
 982    screen->base.get_device_vendor = zink_get_device_vendor;
 983    screen->base.get_param = zink_get_param;
 984    screen->base.get_paramf = zink_get_paramf;
 985    screen->base.get_shader_param = zink_get_shader_param;
 986    screen->base.get_compiler_options = zink_get_compiler_options;
 987    screen->base.is_format_supported = zink_is_format_supported;
 988    screen->base.context_create = zink_context_create;
 989    screen->base.flush_frontbuffer = zink_flush_frontbuffer;
 990    screen->base.destroy = zink_destroy_screen;
 991
 992    zink_screen_resource_init(&screen->base);
 993    zink_screen_fence_init(&screen->base);
 994
 995    slab_create_parent(&screen->transfer_pool, sizeof(struct zink_transfer), 16);
 996
 997    return &screen->base;
 998
 999 fail:
1000    FREE(screen);
1001    return NULL;
1002 }
1003
1004 struct pipe_screen *
1005 zink_create_screen(struct sw_winsys *winsys)
1006 {
1007    return zink_internal_create_screen(winsys, -1);
1008 }
1009
1010 struct pipe_screen *
1011 zink_drm_create_screen(int fd)
1012 {
1013    return zink_internal_create_screen(NULL, fd);
1014 }