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