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