pan_screen.c 23.9 KB
Newer Older
1 2 3 4 5
/*
 * Copyright (C) 2008 VMware, Inc.
 * Copyright (C) 2014 Broadcom
 * Copyright (C) 2018 Alyssa Rosenzweig
 * Copyright (C) 2019 Collabora, Ltd.
6
 * Copyright (C) 2012 Rob Clark <robclark@freedesktop.org>
7 8
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
9 10 11 12 13
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
14
 *
15 16 17
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
18
 *
19 20 21 22 23 24 25
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
26
 *
27
 */
28

29
#include "util/u_debug.h"
30
#include "util/u_memory.h"
31 32
#include "util/format/u_format.h"
#include "util/format/u_format_s3tc.h"
33
#include "util/u_video.h"
34
#include "util/u_screen.h"
35
#include "util/os_time.h"
36
#include "util/u_process.h"
37 38 39 40 41 42
#include "pipe/p_defines.h"
#include "pipe/p_screen.h"
#include "draw/draw_context.h"

#include <fcntl.h>

43
#include "drm-uapi/drm_fourcc.h"
44
#include "drm-uapi/panfrost_drm.h"
45

46
#include "pan_bo.h"
47 48 49
#include "pan_screen.h"
#include "pan_resource.h"
#include "pan_public.h"
50
#include "pan_util.h"
51
#include "pandecode/decode.h"
52 53

#include "pan_context.h"
54
#include "midgard/midgard_compile.h"
55
#include "bifrost/bifrost_compile.h"
56
#include "panfrost-quirks.h"
57

58
static const struct debug_named_value debug_options[] = {
59 60 61
        {"msgs",      PAN_DBG_MSGS,	"Print debug messages"},
        {"trace",     PAN_DBG_TRACE,    "Trace the command stream"},
        {"deqp",      PAN_DBG_DEQP,     "Hacks for dEQP"},
62
        {"afbc",      PAN_DBG_AFBC,     "Enable non-conformant AFBC impl"},
63
        {"sync",      PAN_DBG_SYNC,     "Wait for each job's completion and check for any GPU fault"},
64
        {"precompile", PAN_DBG_PRECOMPILE, "Precompile shaders for shader-db"},
65
        {"gles3",     PAN_DBG_GLES3,    "Enable experimental GLES3 implementation"},
66
        {"fp16",     PAN_DBG_FP16,     "Enable buggy experimental (don't use!) fp16"},
67
        {"bifrost",   PAN_DBG_BIFROST, "Enable experimental Mali G31 and G52 support"},
68
        DEBUG_NAMED_VALUE_END
69 70 71 72 73 74
};

DEBUG_GET_ONCE_FLAGS_OPTION(pan_debug, "PAN_MESA_DEBUG", debug_options, 0)

int pan_debug = 0;

75 76 77
static const char *
panfrost_get_name(struct pipe_screen *screen)
{
78
        return panfrost_model_name(pan_device(screen)->gpu_id);
79 80 81 82 83
}

static const char *
panfrost_get_vendor(struct pipe_screen *screen)
{
84
        return "Panfrost";
85 86 87 88 89 90 91 92 93 94 95
}

static const char *
panfrost_get_device_vendor(struct pipe_screen *screen)
{
        return "Arm";
}

static int
panfrost_get_param(struct pipe_screen *screen, enum pipe_cap param)
{
96 97
        /* We expose in-dev stuff for dEQP that we don't want apps to use yet */
        bool is_deqp = pan_debug & PAN_DBG_DEQP;
98
        struct panfrost_device *dev = pan_device(screen);
99

100 101 102 103
        /* Our GLES3 implementation is WIP */
        bool is_gles3 = pan_debug & PAN_DBG_GLES3;
        is_gles3 |= is_deqp;

104 105 106 107
        switch (param) {
        case PIPE_CAP_NPOT_TEXTURES:
        case PIPE_CAP_MIXED_FRAMEBUFFER_SIZES:
        case PIPE_CAP_MIXED_COLOR_DEPTH_BITS:
108 109
        case PIPE_CAP_FRAGMENT_SHADER_TEXTURE_LOD:
        case PIPE_CAP_VERTEX_SHADER_SATURATE:
110
        case PIPE_CAP_VERTEX_COLOR_UNCLAMPED:
111
        case PIPE_CAP_POINT_SPRITE:
112 113
        case PIPE_CAP_DEPTH_CLIP_DISABLE:
        case PIPE_CAP_DEPTH_CLIP_DISABLE_SEPARATE:
114 115 116
                return 1;

        case PIPE_CAP_MAX_RENDER_TARGETS:
117
                return is_gles3 ? 4 : 1;
118

119 120 121
        /* Throttling frames breaks pipelining */
        case PIPE_CAP_THROTTLE:
                return 0;
122

123
        case PIPE_CAP_OCCLUSION_QUERY:
124
                return 1;
125 126
        case PIPE_CAP_QUERY_TIME_ELAPSED:
        case PIPE_CAP_QUERY_PIPELINE_STATISTICS:
127 128 129
        case PIPE_CAP_QUERY_TIMESTAMP:
        case PIPE_CAP_QUERY_SO_OVERFLOW:
                return 0;
130 131 132 133

        case PIPE_CAP_TEXTURE_SWIZZLE:
                return 1;

134 135 136 137
        case PIPE_CAP_TEXTURE_MIRROR_CLAMP:
        case PIPE_CAP_TEXTURE_MIRROR_CLAMP_TO_EDGE:
                return 1;

138 139
        case PIPE_CAP_TGSI_INSTANCEID:
        case PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR:
140
        case PIPE_CAP_PRIMITIVE_RESTART:
141
        case PIPE_CAP_PRIMITIVE_RESTART_FIXED_INDEX:
142
                return 1;
143 144

        case PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS:
145
                return is_gles3 ? 4 : 0;
146 147
        case PIPE_CAP_MAX_STREAM_OUTPUT_SEPARATE_COMPONENTS:
        case PIPE_CAP_MAX_STREAM_OUTPUT_INTERLEAVED_COMPONENTS:
148
                return is_gles3 ? 64 : 0;
149 150
        case PIPE_CAP_STREAM_OUTPUT_INTERLEAVE_BUFFERS:
                return 1;
151 152

        case PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS:
153
                return 256;
154 155 156

        case PIPE_CAP_GLSL_FEATURE_LEVEL:
        case PIPE_CAP_GLSL_FEATURE_LEVEL_COMPATIBILITY:
157
                return is_gles3 ? 140 : 120;
158
        case PIPE_CAP_ESSL_FEATURE_LEVEL:
159
                return is_gles3 ? 300 : 120;
160 161

        case PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT:
162
                return 16;
163

164
        case PIPE_CAP_TEXTURE_MULTISAMPLE:
165 166 167
                return is_gles3;

        /* For faking GLES 3.1 for dEQP-GLES31 */
168 169 170
        case PIPE_CAP_MAX_COMBINED_HW_ATOMIC_COUNTERS:
        case PIPE_CAP_MAX_COMBINED_HW_ATOMIC_COUNTER_BUFFERS:
        case PIPE_CAP_IMAGE_LOAD_FORMATTED:
171
        case PIPE_CAP_CUBE_MAP_ARRAY:
172 173
                return is_deqp;

174 175 176 177
        /* For faking compute shaders */
        case PIPE_CAP_COMPUTE:
                return is_deqp;

178 179
        case PIPE_CAP_MAX_TEXTURE_2D_SIZE:
                return 4096;
180 181 182 183 184 185 186 187 188 189
        case PIPE_CAP_MAX_TEXTURE_3D_LEVELS:
        case PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS:
                return 13;

        case PIPE_CAP_BLEND_EQUATION_SEPARATE:
        case PIPE_CAP_INDEP_BLEND_ENABLE:
        case PIPE_CAP_INDEP_BLEND_FUNC:
                return 1;

        case PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT:
190 191 192 193
                /* Hardware is natively upper left */
                return 0;

        case PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT:
194 195
        case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER:
        case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER:
196 197 198
        case PIPE_CAP_GENERATE_MIPMAP:
                return 1;

199
        /* We would prefer varyings on Midgard, but proper sysvals on Bifrost */
200 201
        case PIPE_CAP_TGSI_FS_FACE_IS_INTEGER_SYSVAL:
        case PIPE_CAP_TGSI_FS_POSITION_IS_SYSVAL:
202
        case PIPE_CAP_TGSI_FS_POINT_IS_SYSVAL:
203
                return dev->quirks & IS_BIFROST;
204

205 206 207 208 209
        /* I really don't want to set this CAP but let's not swim against the
         * tide.. */
        case PIPE_CAP_TGSI_TEXCOORD:
                return 1;

210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232
        case PIPE_CAP_SEAMLESS_CUBE_MAP:
        case PIPE_CAP_SEAMLESS_CUBE_MAP_PER_TEXTURE:
                return 1;

        case PIPE_CAP_MAX_VERTEX_ELEMENT_SRC_OFFSET:
                return 0xffff;

        case PIPE_CAP_TEXTURE_BUFFER_OBJECTS:
                return 1;

        case PIPE_CAP_MAX_TEXTURE_BUFFER_SIZE:
                return 65536;

        case PIPE_CAP_PREFER_BLIT_BASED_TEXTURE_TRANSFER:
                return 0;

        case PIPE_CAP_ENDIANNESS:
                return PIPE_ENDIAN_NATIVE;

        case PIPE_CAP_SAMPLER_VIEW_TARGET:
                return 1;

        case PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET:
233
                return -8;
234 235

        case PIPE_CAP_MAX_TEXTURE_GATHER_OFFSET:
236
                return 7;
237 238 239 240 241 242

        case PIPE_CAP_VENDOR_ID:
        case PIPE_CAP_DEVICE_ID:
                return 0xFFFFFFFF;

        case PIPE_CAP_ACCELERATED:
243 244 245 246 247
        case PIPE_CAP_UMA:
        case PIPE_CAP_TEXTURE_FLOAT_LINEAR:
        case PIPE_CAP_TEXTURE_HALF_FLOAT_LINEAR:
        case PIPE_CAP_COPY_BETWEEN_COMPRESSED_AND_PLAIN_FORMATS:
        case PIPE_CAP_TGSI_ARRAY_COMPONENTS:
248 249 250 251 252 253 254 255 256 257 258
                return 1;

        case PIPE_CAP_VIDEO_MEMORY: {
                uint64_t system_memory;

                if (!os_get_total_physical_memory(&system_memory))
                        return 0;

                return (int)(system_memory >> 20);
        }

259 260 261
        case PIPE_CAP_SHADER_STENCIL_EXPORT:
                return 1;

262 263 264
        case PIPE_CAP_SHADER_BUFFER_OFFSET_ALIGNMENT:
                return 4;

265 266 267
        case PIPE_CAP_MAX_VARYINGS:
                return 16;

268
        case PIPE_CAP_ALPHA_TEST:
269 270 271
        case PIPE_CAP_FLATSHADE:
        case PIPE_CAP_TWO_SIDED_COLOR:
        case PIPE_CAP_CLIP_PLANES:
272 273
                return 0;

274 275 276 277 278 279 280
        case PIPE_CAP_PACKED_STREAM_OUTPUT:
                return 0;

        case PIPE_CAP_VIEWPORT_TRANSFORM_LOWERED:
        case PIPE_CAP_PSIZ_CLAMPED:
                return 1;

281
        default:
282
                return u_pipe_screen_get_param_defaults(screen, param);
283 284 285 286 287 288 289 290
        }
}

static int
panfrost_get_shader_param(struct pipe_screen *screen,
                          enum pipe_shader_type shader,
                          enum pipe_shader_cap param)
{
291
        bool is_deqp = pan_debug & PAN_DBG_DEQP;
292
        bool is_fp16 = pan_debug & PAN_DBG_FP16;
293
        struct panfrost_device *dev = pan_device(screen);
294

295
        if (shader != PIPE_SHADER_VERTEX &&
296 297
            shader != PIPE_SHADER_FRAGMENT &&
            !(shader == PIPE_SHADER_COMPUTE && is_deqp))
298
                return 0;
299

300 301 302 303 304 305 306 307 308 309 310 311 312 313 314
        /* this is probably not totally correct.. but it's a start: */
        switch (param) {
        case PIPE_SHADER_CAP_MAX_INSTRUCTIONS:
        case PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS:
        case PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS:
        case PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS:
                return 16384;

        case PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH:
                return 1024;

        case PIPE_SHADER_CAP_MAX_INPUTS:
                return 16;

        case PIPE_SHADER_CAP_MAX_OUTPUTS:
315
                return shader == PIPE_SHADER_FRAGMENT ? 4 : 16;
316 317 318 319 320 321 322 323

        case PIPE_SHADER_CAP_MAX_TEMPS:
                return 256; /* GL_MAX_PROGRAM_TEMPORARIES_ARB */

        case PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE:
                return 16 * 1024 * sizeof(float);

        case PIPE_SHADER_CAP_MAX_CONST_BUFFERS:
324
                return PAN_MAX_CONST_BUFFERS;
325 326 327 328 329

        case PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED:
                return 0;

        case PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR:
330
                return 1;
331 332
        case PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR:
                return 0;
333

334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349
        case PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR:
                return 0;

        case PIPE_SHADER_CAP_INDIRECT_CONST_ADDR:
                return 1;

        case PIPE_SHADER_CAP_SUBROUTINES:
                return 0;

        case PIPE_SHADER_CAP_TGSI_SQRT_SUPPORTED:
                return 0;

        case PIPE_SHADER_CAP_INTEGERS:
                return 1;

        case PIPE_SHADER_CAP_FP16:
350
                return !(dev->quirks & MIDGARD_BROKEN_FP16) || is_fp16;
351

352 353
        case PIPE_SHADER_CAP_FP16_DERIVATIVES:
        case PIPE_SHADER_CAP_INT16:
354
        case PIPE_SHADER_CAP_INT64_ATOMICS:
355 356 357 358 359 360 361 362 363 364 365 366 367 368 369
        case PIPE_SHADER_CAP_TGSI_DROUND_SUPPORTED:
        case PIPE_SHADER_CAP_TGSI_DFRACEXP_DLDEXP_SUPPORTED:
        case PIPE_SHADER_CAP_TGSI_LDEXP_SUPPORTED:
        case PIPE_SHADER_CAP_TGSI_FMA_SUPPORTED:
        case PIPE_SHADER_CAP_TGSI_ANY_INOUT_DECL_RANGE:
                return 0;

        case PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS:
        case PIPE_SHADER_CAP_MAX_SAMPLER_VIEWS:
                return 16; /* XXX: How many? */

        case PIPE_SHADER_CAP_PREFERRED_IR:
                return PIPE_SHADER_IR_NIR;

        case PIPE_SHADER_CAP_SUPPORTED_IRS:
370
                return (1 << PIPE_SHADER_IR_NIR) | (1 << PIPE_SHADER_IR_NIR_SERIALIZED);
371 372 373 374 375 376

        case PIPE_SHADER_CAP_MAX_UNROLL_ITERATIONS_HINT:
                return 32;

        case PIPE_SHADER_CAP_MAX_SHADER_BUFFERS:
        case PIPE_SHADER_CAP_MAX_SHADER_IMAGES:
377
                return is_deqp ? 8 : 0;
378 379
        case PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTERS:
        case PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTER_BUFFERS:
380
                return 0;
381 382 383

        case PIPE_SHADER_CAP_TGSI_SKIP_MERGE_REGISTERS:
        case PIPE_SHADER_CAP_LOWER_IF_THRESHOLD:
384 385 386
                return 0;

        default:
387
                DBG("unknown shader param %d\n", param);
388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407
                return 0;
        }

        return 0;
}

static float
panfrost_get_paramf(struct pipe_screen *screen, enum pipe_capf param)
{
        switch (param) {
        case PIPE_CAPF_MAX_LINE_WIDTH:

        /* fall-through */
        case PIPE_CAPF_MAX_LINE_WIDTH_AA:
                return 255.0; /* arbitrary */

        case PIPE_CAPF_MAX_POINT_WIDTH:

        /* fall-through */
        case PIPE_CAPF_MAX_POINT_WIDTH_AA:
Alyssa Rosenzweig's avatar
Alyssa Rosenzweig committed
408
                return 1024.0;
409 410 411 412 413 414 415

        case PIPE_CAPF_MAX_TEXTURE_ANISOTROPY:
                return 16.0;

        case PIPE_CAPF_MAX_TEXTURE_LOD_BIAS:
                return 16.0; /* arbitrary */

416 417 418 419 420
        case PIPE_CAPF_MIN_CONSERVATIVE_RASTER_DILATE:
        case PIPE_CAPF_MAX_CONSERVATIVE_RASTER_DILATE:
        case PIPE_CAPF_CONSERVATIVE_RASTER_DILATE_GRANULARITY:
                return 0.0f;

421 422 423 424 425 426 427 428 429 430 431
        default:
                debug_printf("Unexpected PIPE_CAPF %d query\n", param);
                return 0.0;
        }
}

/**
 * Query format support for creating a texture, drawing surface, etc.
 * \param format  the format to test
 * \param type  one of PIPE_TEXTURE, PIPE_SURFACE
 */
432
static bool
433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454
panfrost_is_format_supported( struct pipe_screen *screen,
                              enum pipe_format format,
                              enum pipe_texture_target target,
                              unsigned sample_count,
                              unsigned storage_sample_count,
                              unsigned bind)
{
        const struct util_format_description *format_desc;

        assert(target == PIPE_BUFFER ||
               target == PIPE_TEXTURE_1D ||
               target == PIPE_TEXTURE_1D_ARRAY ||
               target == PIPE_TEXTURE_2D ||
               target == PIPE_TEXTURE_2D_ARRAY ||
               target == PIPE_TEXTURE_RECT ||
               target == PIPE_TEXTURE_3D ||
               target == PIPE_TEXTURE_CUBE ||
               target == PIPE_TEXTURE_CUBE_ARRAY);

        format_desc = util_format_description(format);

        if (!format_desc)
455
                return false;
456

457 458 459 460 461 462 463 464 465 466
        /* MSAA 4x supported, but no more. Technically some revisions of the
         * hardware can go up to 16x but we don't support higher modes yet. */

        if (sample_count > 1 && !(pan_debug & PAN_DBG_DEQP))
                return false;

        if (sample_count > 4)
                return false;

        if (MAX2(sample_count, 1) != MAX2(storage_sample_count, 1))
467
                return false;
468

469 470
        /* Don't confuse poorly written apps (workaround dEQP bug) that expect
         * more alpha than they ask for */
471

472
        bool scanout = bind & (PIPE_BIND_SCANOUT | PIPE_BIND_SHARED | PIPE_BIND_DISPLAY_TARGET);
473 474 475
        bool renderable = bind & PIPE_BIND_RENDER_TARGET;

        if (scanout && renderable && !util_format_is_rgba8_variant(format_desc))
476
                return false;
477

478
        /* Check we support the format with the given bind */
479

480 481 482
        unsigned relevant_bind = bind &
                ( PIPE_BIND_DEPTH_STENCIL | PIPE_BIND_RENDER_TARGET
                | PIPE_BIND_VERTEX_BUFFER | PIPE_BIND_SAMPLER_VIEW);
483

484 485
        struct panfrost_format fmt = panfrost_pipe_format_table[format];
        return fmt.hw && ((relevant_bind & ~fmt.bind) == 0);
486 487
}

488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504
static int
panfrost_get_compute_param(struct pipe_screen *pscreen, enum pipe_shader_ir ir_type,
                enum pipe_compute_cap param, void *ret)
{
	const char * const ir = "panfrost";

	if (!(pan_debug & PAN_DBG_DEQP))
		return 0;

#define RET(x) do {                  \
   if (ret)                          \
      memcpy(ret, x, sizeof(x));     \
   return sizeof(x);                 \
} while (0)

	switch (param) {
	case PIPE_COMPUTE_CAP_ADDRESS_BITS:
505
		RET((uint32_t []){ 64 });
506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554

	case PIPE_COMPUTE_CAP_IR_TARGET:
		if (ret)
			sprintf(ret, "%s", ir);
		return strlen(ir) * sizeof(char);

	case PIPE_COMPUTE_CAP_GRID_DIMENSION:
		RET((uint64_t []) { 3 });

	case PIPE_COMPUTE_CAP_MAX_GRID_SIZE:
		RET(((uint64_t []) { 65535, 65535, 65535 }));

	case PIPE_COMPUTE_CAP_MAX_BLOCK_SIZE:
		RET(((uint64_t []) { 1024, 1024, 64 }));

	case PIPE_COMPUTE_CAP_MAX_THREADS_PER_BLOCK:
		RET((uint64_t []) { 1024 });

	case PIPE_COMPUTE_CAP_MAX_GLOBAL_SIZE:
		RET((uint64_t []) { 1024*1024*512 /* Maybe get memory */ });

	case PIPE_COMPUTE_CAP_MAX_LOCAL_SIZE:
		RET((uint64_t []) { 32768 });

	case PIPE_COMPUTE_CAP_MAX_PRIVATE_SIZE:
	case PIPE_COMPUTE_CAP_MAX_INPUT_SIZE:
		RET((uint64_t []) { 4096 });

	case PIPE_COMPUTE_CAP_MAX_MEM_ALLOC_SIZE:
		RET((uint64_t []) { 1024*1024*512 /* Maybe get memory */ });

	case PIPE_COMPUTE_CAP_MAX_CLOCK_FREQUENCY:
		RET((uint32_t []) { 800 /* MHz -- TODO */ });

	case PIPE_COMPUTE_CAP_MAX_COMPUTE_UNITS:
		RET((uint32_t []) { 9999 });  // TODO

	case PIPE_COMPUTE_CAP_IMAGES_SUPPORTED:
		RET((uint32_t []) { 1 }); // TODO

	case PIPE_COMPUTE_CAP_SUBGROUP_SIZE:
		RET((uint32_t []) { 32 });  // TODO

	case PIPE_COMPUTE_CAP_MAX_VARIABLE_THREADS_PER_BLOCK:
		RET((uint64_t []) { 1024 }); // TODO
	}

	return 0;
}
555 556

static void
557
panfrost_destroy_screen(struct pipe_screen *pscreen)
558
{
559
        panfrost_close_device(pan_device(pscreen));
560
        ralloc_free(pscreen);
561 562 563 564 565 566 567 568 569
}

static uint64_t
panfrost_get_timestamp(struct pipe_screen *_screen)
{
        return os_time_get_nano();
}

static void
570
panfrost_fence_reference(struct pipe_screen *pscreen,
571 572 573
                         struct pipe_fence_handle **ptr,
                         struct pipe_fence_handle *fence)
{
574 575 576 577 578
        struct panfrost_fence **p = (struct panfrost_fence **)ptr;
        struct panfrost_fence *f = (struct panfrost_fence *)fence;
        struct panfrost_fence *old = *p;

        if (pipe_reference(&(*p)->reference, &f->reference)) {
579 580 581
                util_dynarray_foreach(&old->syncfds, int, fd)
                        close(*fd);
                util_dynarray_fini(&old->syncfds);
582 583 584
                free(old);
        }
        *p = f;
585 586
}

587
static bool
588
panfrost_fence_finish(struct pipe_screen *pscreen,
589 590 591 592
                      struct pipe_context *ctx,
                      struct pipe_fence_handle *fence,
                      uint64_t timeout)
{
593
        struct panfrost_device *dev = pan_device(pscreen);
594
        struct panfrost_fence *f = (struct panfrost_fence *)fence;
595
        struct util_dynarray syncobjs;
596
        int ret;
597

598 599
        /* All fences were already signaled */
        if (!util_dynarray_num_elements(&f->syncfds, int))
600 601
                return true;

602 603 604
        util_dynarray_init(&syncobjs, NULL);
        util_dynarray_foreach(&f->syncfds, int, fd) {
                uint32_t syncobj;
605

606
                ret = drmSyncobjCreate(dev->fd, 0, &syncobj);
607 608
                assert(!ret);

609
                ret = drmSyncobjImportSyncFile(dev->fd, syncobj, *fd);
610 611
                assert(!ret);
                util_dynarray_append(&syncobjs, uint32_t, syncobj);
612 613 614 615 616 617
        }

        uint64_t abs_timeout = os_time_get_absolute_timeout(timeout);
        if (abs_timeout == OS_TIMEOUT_INFINITE)
                abs_timeout = INT64_MAX;

618
        ret = drmSyncobjWait(dev->fd, util_dynarray_begin(&syncobjs),
619 620 621
                             util_dynarray_num_elements(&syncobjs, uint32_t),
                             abs_timeout, DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL,
                             NULL);
622

623
        util_dynarray_foreach(&syncobjs, uint32_t, syncobj)
624
                drmSyncobjDestroy(dev->fd, *syncobj);
625 626 627 628 629

        return ret >= 0;
}

struct panfrost_fence *
630 631
panfrost_fence_create(struct panfrost_context *ctx,
                      struct util_dynarray *fences)
632
{
633
        struct panfrost_device *device = pan_device(ctx->base.screen);
634 635 636 637
        struct panfrost_fence *f = calloc(1, sizeof(*f));
        if (!f)
                return NULL;

638 639 640 641 642 643 644 645 646 647
        util_dynarray_init(&f->syncfds, NULL);

        /* Export fences from all pending batches. */
        util_dynarray_foreach(fences, struct panfrost_batch_fence *, fence) {
                int fd = -1;

                /* The fence is already signaled, no need to export it. */
                if ((*fence)->signaled)
                        continue;

648
                drmSyncobjExportSyncFile(device->fd, (*fence)->syncobj, &fd);
649 650 651 652 653
                if (fd == -1)
                        fprintf(stderr, "export failed: %m\n");

                assert(fd != -1);
                util_dynarray_append(&f->syncfds, int, fd);
654 655 656 657 658
        }

        pipe_reference_init(&f->reference, 1);

        return f;
659 660 661 662 663 664 665
}

static const void *
panfrost_screen_get_compiler_options(struct pipe_screen *pscreen,
                                     enum pipe_shader_ir ir,
                                     enum pipe_shader_type shader)
{
666 667 668 669
        if (pan_device(pscreen)->quirks & IS_BIFROST)
                return &bifrost_nir_options;
        else
                return &midgard_nir_options;
670 671 672
}

struct pipe_screen *
673
panfrost_create_screen(int fd, struct renderonly *ro)
674
{
675
        pan_debug = debug_get_option_pan_debug();
676

677 678 679 680 681 682 683 684 685 686 687 688 689 690 691
        /* Blacklist apps known to be buggy under Panfrost */
        const char *proc = util_get_process_name();
        const char *blacklist[] = {
                "chromium",
                "chrome",
        };

        for (unsigned i = 0; i < ARRAY_SIZE(blacklist); ++i) {
                if ((strcmp(blacklist[i], proc) == 0))
                        return NULL;
        }

        /* Create the screen */
        struct panfrost_screen *screen = rzalloc(NULL, struct panfrost_screen);

692 693 694
        if (!screen)
                return NULL;

695
        struct panfrost_device *dev = pan_device(&screen->base);
696
        panfrost_open_device(screen, fd, dev);
697

698
        if (ro) {
699 700
                dev->ro = renderonly_dup(ro);
                if (!dev->ro) {
701
                        DBG("Failed to dup renderonly object\n");
702 703 704 705 706
                        free(screen);
                        return NULL;
                }
        }

707
        /* Check if we're loading against a supported GPU model. */
708

709
        switch (dev->gpu_id) {
710
        case 0x720: /* T720 */
711
        case 0x750: /* T760 */
712 713 714
        case 0x820: /* T820 */
        case 0x860: /* T860 */
                break;
715 716 717 718 719 720
        case 0x7093: /* G31 */
        case 0x7212: /* G52 */
                if (pan_debug & PAN_DBG_BIFROST)
                        break;

                /* fallthrough */
721 722
        default:
                /* Fail to load against untested models */
723
                debug_printf("panfrost: Unsupported model %X", dev->gpu_id);
724
                panfrost_destroy_screen(&(screen->base));
725
                return NULL;
726 727
        }

728
        if (pan_debug & (PAN_DBG_TRACE | PAN_DBG_SYNC))
729
                pandecode_initialize(!(pan_debug & PAN_DBG_TRACE));
730

731 732 733 734 735 736 737
        screen->base.destroy = panfrost_destroy_screen;

        screen->base.get_name = panfrost_get_name;
        screen->base.get_vendor = panfrost_get_vendor;
        screen->base.get_device_vendor = panfrost_get_device_vendor;
        screen->base.get_param = panfrost_get_param;
        screen->base.get_shader_param = panfrost_get_shader_param;
738
        screen->base.get_compute_param = panfrost_get_compute_param;
739 740 741
        screen->base.get_paramf = panfrost_get_paramf;
        screen->base.get_timestamp = panfrost_get_timestamp;
        screen->base.is_format_supported = panfrost_is_format_supported;
742
        screen->base.context_create = panfrost_create_context;
743 744 745
        screen->base.get_compiler_options = panfrost_screen_get_compiler_options;
        screen->base.fence_reference = panfrost_fence_reference;
        screen->base.fence_finish = panfrost_fence_finish;
746
        screen->base.set_damage_region = panfrost_resource_set_damage_region;
747

748
        panfrost_resource_screen_init(&screen->base);
749 750

        return &screen->base;
751
}