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