0e7455839401e46b59ed7b3e595114da3837ea98
[mesa.git] / src / gallium / drivers / panfrost / pan_screen.c
1 /**************************************************************************
2 *
3 * Copyright 2008 VMware, Inc.
4 * Copyright 2014 Broadcom
5 * Copyright 2018 Alyssa Rosenzweig
6 * All Rights Reserved.
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the
10 * "Software"), to deal in the Software without restriction, including
11 * without limitation the rights to use, copy, modify, merge, publish,
12 * distribute, sub license, and/or sell copies of the Software, and to
13 * permit persons to whom the Software is furnished to do so, subject to
14 * the following conditions:
15 *
16 * The above copyright notice and this permission notice (including the
17 * next paragraph) shall be included in all copies or substantial portions
18 * of the Software.
19 *
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
21 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
23 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
24 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
25 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
26 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 *
28 **************************************************************************/
29
30
31 #include "util/u_memory.h"
32 #include "util/u_format.h"
33 #include "util/u_format_s3tc.h"
34 #include "util/u_video.h"
35 #include "util/os_time.h"
36 #include "pipe/p_defines.h"
37 #include "pipe/p_screen.h"
38 #include "draw/draw_context.h"
39 #include <xf86drm.h>
40
41 #include <fcntl.h>
42
43 #include "drm_fourcc.h"
44
45 #include "pan_screen.h"
46 #include "pan_resource.h"
47 #include "pan_public.h"
48
49 #include "pan_context.h"
50
51 static const char *
52 panfrost_get_name(struct pipe_screen *screen)
53 {
54 return "panfrost";
55 }
56
57 static const char *
58 panfrost_get_vendor(struct pipe_screen *screen)
59 {
60 return "panfrost";
61 }
62
63 static const char *
64 panfrost_get_device_vendor(struct pipe_screen *screen)
65 {
66 return "Arm";
67 }
68
69 static int
70 panfrost_get_param(struct pipe_screen *screen, enum pipe_cap param)
71 {
72 switch (param) {
73 case PIPE_CAP_NPOT_TEXTURES:
74 case PIPE_CAP_MIXED_FRAMEBUFFER_SIZES:
75 case PIPE_CAP_MIXED_COLOR_DEPTH_BITS:
76 return 1;
77
78 case PIPE_CAP_SM3:
79 return 1;
80
81 case PIPE_CAP_POINT_SPRITE:
82 return 1;
83
84 case PIPE_CAP_MAX_RENDER_TARGETS:
85 return PIPE_MAX_COLOR_BUFS;
86
87 case PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS:
88 return 1;
89
90 case PIPE_CAP_OCCLUSION_QUERY:
91 case PIPE_CAP_QUERY_TIME_ELAPSED:
92 case PIPE_CAP_QUERY_PIPELINE_STATISTICS:
93 return 1; /* TODO: Queries */
94
95 case PIPE_CAP_TEXTURE_MIRROR_CLAMP:
96 return 1;
97
98 case PIPE_CAP_TEXTURE_SWIZZLE:
99 return 1;
100
101 case PIPE_CAP_TEXTURE_BORDER_COLOR_QUIRK:
102 return 0;
103
104 case PIPE_CAP_MAX_TEXTURE_2D_LEVELS:
105 case PIPE_CAP_MAX_TEXTURE_3D_LEVELS:
106 case PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS:
107 return 13;
108
109 case PIPE_CAP_BLEND_EQUATION_SEPARATE:
110 return 1;
111
112 case PIPE_CAP_INDEP_BLEND_ENABLE:
113 return 1;
114
115 case PIPE_CAP_INDEP_BLEND_FUNC:
116 return 1;
117
118 case PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT:
119 case PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT:
120 case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER:
121 case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER:
122 return 1;
123
124 case PIPE_CAP_DEPTH_CLIP_DISABLE:
125 return 1;
126
127 case PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS:
128 return 0; /* no streamout */
129
130 case PIPE_CAP_MAX_STREAM_OUTPUT_SEPARATE_COMPONENTS:
131 case PIPE_CAP_MAX_STREAM_OUTPUT_INTERLEAVED_COMPONENTS:
132 return 16 * 4;
133
134 case PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES:
135 case PIPE_CAP_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS:
136 return 1024;
137
138 case PIPE_CAP_MAX_VERTEX_STREAMS:
139 return 1;
140
141 case PIPE_CAP_PRIMITIVE_RESTART:
142 return 0; /* We don't understand this yet */
143
144 case PIPE_CAP_SHADER_STENCIL_EXPORT:
145 return 1;
146
147 case PIPE_CAP_TGSI_INSTANCEID:
148 case PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR:
149 case PIPE_CAP_START_INSTANCE:
150 return 0; /* TODO: Instances */
151
152 case PIPE_CAP_SEAMLESS_CUBE_MAP:
153 case PIPE_CAP_SEAMLESS_CUBE_MAP_PER_TEXTURE:
154 return 1;
155
156 case PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS:
157 return 256; /* for GL3 */
158
159 case PIPE_CAP_MIN_TEXEL_OFFSET:
160 return -8;
161
162 case PIPE_CAP_MAX_TEXEL_OFFSET:
163 return 7;
164
165 case PIPE_CAP_CONDITIONAL_RENDER:
166 return 1;
167
168 case PIPE_CAP_TEXTURE_BARRIER:
169 return 0;
170
171 case PIPE_CAP_FRAGMENT_COLOR_CLAMPED:
172 case PIPE_CAP_VERTEX_COLOR_UNCLAMPED: /* draw module */
173 case PIPE_CAP_VERTEX_COLOR_CLAMPED: /* draw module */
174 return 1;
175
176 case PIPE_CAP_MIXED_COLORBUFFER_FORMATS:
177 return 0;
178
179 case PIPE_CAP_GLSL_FEATURE_LEVEL:
180 return 330;
181
182 case PIPE_CAP_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION:
183 case PIPE_CAP_TGSI_TEX_TXF_LZ:
184 return 0;
185
186 case PIPE_CAP_COMPUTE:
187 return 0;
188
189 case PIPE_CAP_USER_VERTEX_BUFFERS: /* XXX XXX */
190 case PIPE_CAP_RESOURCE_FROM_USER_MEMORY:
191 return 0;
192
193 case PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME:
194 case PIPE_CAP_STREAM_OUTPUT_INTERLEAVE_BUFFERS:
195 case PIPE_CAP_TGSI_VS_LAYER_VIEWPORT:
196 case PIPE_CAP_DOUBLES:
197 case PIPE_CAP_INT64:
198 case PIPE_CAP_INT64_DIVMOD:
199 return 1;
200
201 case PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT:
202 return 16;
203
204 case PIPE_CAP_TGSI_CAN_COMPACT_CONSTANTS:
205 case PIPE_CAP_VERTEX_BUFFER_OFFSET_4BYTE_ALIGNED_ONLY:
206 case PIPE_CAP_VERTEX_BUFFER_STRIDE_4BYTE_ALIGNED_ONLY:
207 case PIPE_CAP_VERTEX_ELEMENT_SRC_OFFSET_4BYTE_ALIGNED_ONLY:
208 case PIPE_CAP_TEXTURE_MULTISAMPLE:
209 return 0;
210
211 case PIPE_CAP_MAX_VERTEX_ELEMENT_SRC_OFFSET:
212 return 0xffff;
213
214 case PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT:
215 return 64;
216
217 case PIPE_CAP_QUERY_TIMESTAMP:
218 case PIPE_CAP_CUBE_MAP_ARRAY:
219 return 1;
220
221 case PIPE_CAP_TEXTURE_BUFFER_OBJECTS:
222 return 1;
223
224 case PIPE_CAP_BUFFER_SAMPLER_VIEW_RGBA_ONLY:
225 return 0;
226
227 case PIPE_CAP_MAX_TEXTURE_BUFFER_SIZE:
228 return 65536;
229
230 case PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT:
231 return 0;
232
233 case PIPE_CAP_TGSI_TEXCOORD:
234 return 1; /* XXX: What should this me exactly? */
235
236 case PIPE_CAP_PREFER_BLIT_BASED_TEXTURE_TRANSFER:
237 return 0;
238
239 case PIPE_CAP_MAX_VIEWPORTS:
240 return PIPE_MAX_VIEWPORTS;
241
242 case PIPE_CAP_ENDIANNESS:
243 return PIPE_ENDIAN_NATIVE;
244
245 case PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS:
246 return 4;
247
248 case PIPE_CAP_TEXTURE_GATHER_SM5:
249 case PIPE_CAP_TEXTURE_QUERY_LOD:
250 return 1;
251
252 case PIPE_CAP_BUFFER_MAP_PERSISTENT_COHERENT:
253 case PIPE_CAP_SAMPLE_SHADING:
254 case PIPE_CAP_TEXTURE_GATHER_OFFSETS:
255 return 0;
256
257 case PIPE_CAP_TGSI_VS_WINDOW_SPACE_POSITION:
258 return 1;
259
260 case PIPE_CAP_TGSI_FS_FINE_DERIVATIVE:
261 return 0;
262
263 case PIPE_CAP_SAMPLER_VIEW_TARGET:
264 return 1;
265
266 case PIPE_CAP_FAKE_SW_MSAA:
267 return 1;
268
269 case PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET:
270 return -32;
271
272 case PIPE_CAP_MAX_TEXTURE_GATHER_OFFSET:
273 return 31;
274
275 case PIPE_CAP_DRAW_INDIRECT:
276 return 1;
277
278 case PIPE_CAP_QUERY_SO_OVERFLOW:
279 return 1;
280
281 case PIPE_CAP_VENDOR_ID:
282 return 0xFFFFFFFF;
283
284 case PIPE_CAP_DEVICE_ID:
285 return 0xFFFFFFFF;
286
287 case PIPE_CAP_ACCELERATED:
288 return 1;
289
290 case PIPE_CAP_VIDEO_MEMORY: {
291 /* XXX: Do we want to return the full amount fo system memory ? */
292 uint64_t system_memory;
293
294 if (!os_get_total_physical_memory(&system_memory))
295 return 0;
296
297 if (sizeof(void *) == 4)
298 /* Cap to 2 GB on 32 bits system. We do this because panfrost does
299 * eat application memory, which is quite limited on 32 bits. App
300 * shouldn't expect too much available memory. */
301 system_memory = MIN2(system_memory, 2048 << 20);
302
303 return (int)(system_memory >> 20);
304 }
305
306 case PIPE_CAP_UMA:
307 return 0;
308
309 case PIPE_CAP_CONDITIONAL_RENDER_INVERTED:
310 return 1;
311
312 case PIPE_CAP_CLIP_HALFZ:
313 case PIPE_CAP_TEXTURE_FLOAT_LINEAR:
314 case PIPE_CAP_TEXTURE_HALF_FLOAT_LINEAR:
315 return 1;
316
317 case PIPE_CAP_FRAMEBUFFER_NO_ATTACHMENT:
318 case PIPE_CAP_CULL_DISTANCE:
319 return 1;
320
321 case PIPE_CAP_VERTEXID_NOBASE:
322 return 0;
323
324 case PIPE_CAP_POLYGON_OFFSET_CLAMP:
325 return 0;
326
327 case PIPE_CAP_COPY_BETWEEN_COMPRESSED_AND_PLAIN_FORMATS:
328 case PIPE_CAP_TGSI_ARRAY_COMPONENTS:
329 return 1;
330
331 case PIPE_CAP_CLEAR_TEXTURE:
332 return 1;
333
334 case PIPE_CAP_ANISOTROPIC_FILTER:
335 case PIPE_CAP_MULTISAMPLE_Z_RESOLVE:
336 case PIPE_CAP_DEVICE_RESET_STATUS_QUERY:
337 case PIPE_CAP_MAX_SHADER_PATCH_VARYINGS:
338 case PIPE_CAP_DEPTH_BOUNDS_TEST:
339 case PIPE_CAP_TGSI_TXQS:
340 case PIPE_CAP_FORCE_PERSAMPLE_INTERP:
341 case PIPE_CAP_SHAREABLE_SHADERS:
342 case PIPE_CAP_DRAW_PARAMETERS:
343 case PIPE_CAP_TGSI_PACK_HALF_FLOAT:
344 case PIPE_CAP_MULTI_DRAW_INDIRECT:
345 case PIPE_CAP_MULTI_DRAW_INDIRECT_PARAMS:
346 case PIPE_CAP_TGSI_FS_POSITION_IS_SYSVAL:
347 case PIPE_CAP_TGSI_FS_FACE_IS_INTEGER_SYSVAL:
348 case PIPE_CAP_INVALIDATE_BUFFER:
349 case PIPE_CAP_GENERATE_MIPMAP:
350 case PIPE_CAP_STRING_MARKER:
351 case PIPE_CAP_SURFACE_REINTERPRET_BLOCKS:
352 case PIPE_CAP_QUERY_BUFFER_OBJECT:
353 case PIPE_CAP_QUERY_MEMORY_INFO:
354 case PIPE_CAP_PCI_GROUP:
355 case PIPE_CAP_PCI_BUS:
356 case PIPE_CAP_PCI_DEVICE:
357 case PIPE_CAP_PCI_FUNCTION:
358 case PIPE_CAP_ROBUST_BUFFER_ACCESS_BEHAVIOR:
359 case PIPE_CAP_PRIMITIVE_RESTART_FOR_PATCHES:
360 case PIPE_CAP_TGSI_VOTE:
361 case PIPE_CAP_MAX_WINDOW_RECTANGLES:
362 case PIPE_CAP_POLYGON_OFFSET_UNITS_UNSCALED:
363 case PIPE_CAP_VIEWPORT_SUBPIXEL_BITS:
364 case PIPE_CAP_TGSI_CAN_READ_OUTPUTS:
365 case PIPE_CAP_NATIVE_FENCE_FD:
366 case PIPE_CAP_GLSL_OPTIMIZE_CONSERVATIVELY:
367 case PIPE_CAP_TGSI_FS_FBFETCH:
368 case PIPE_CAP_TGSI_MUL_ZERO_WINS:
369 case PIPE_CAP_TGSI_CLOCK:
370 case PIPE_CAP_POLYGON_MODE_FILL_RECTANGLE:
371 case PIPE_CAP_SPARSE_BUFFER_PAGE_SIZE:
372 case PIPE_CAP_TGSI_BALLOT:
373 case PIPE_CAP_TGSI_TES_LAYER_VIEWPORT:
374 case PIPE_CAP_CAN_BIND_CONST_BUFFER_AS_VERTEX:
375 case PIPE_CAP_ALLOW_MAPPED_BUFFERS_DURING_EXECUTION:
376 case PIPE_CAP_POST_DEPTH_COVERAGE:
377 case PIPE_CAP_BINDLESS_TEXTURE:
378 case PIPE_CAP_NIR_SAMPLERS_AS_DEREF:
379 case PIPE_CAP_MEMOBJ:
380 case PIPE_CAP_LOAD_CONSTBUF:
381 case PIPE_CAP_TGSI_ANY_REG_AS_ADDRESS:
382 case PIPE_CAP_TILE_RASTER_ORDER:
383 case PIPE_CAP_MAX_COMBINED_SHADER_OUTPUT_RESOURCES:
384 case PIPE_CAP_SIGNED_VERTEX_BUFFER_OFFSET:
385 case PIPE_CAP_CONTEXT_PRIORITY_MASK:
386 case PIPE_CAP_FENCE_SIGNAL:
387 case PIPE_CAP_CONSTBUF0_FLAGS:
388 return 0;
389
390 case PIPE_CAP_SHADER_BUFFER_OFFSET_ALIGNMENT:
391 return 4;
392
393 default:
394 debug_printf("Unexpected PIPE_CAP %d query\n", param);
395 return 0;
396 }
397 }
398
399 static int
400 panfrost_get_shader_param(struct pipe_screen *screen,
401 enum pipe_shader_type shader,
402 enum pipe_shader_cap param)
403 {
404 if (shader != PIPE_SHADER_VERTEX &&
405 shader != PIPE_SHADER_FRAGMENT) {
406 return 0;
407 }
408
409 /* this is probably not totally correct.. but it's a start: */
410 switch (param) {
411 case PIPE_SHADER_CAP_SCALAR_ISA:
412 return 0;
413
414 case PIPE_SHADER_CAP_MAX_INSTRUCTIONS:
415 case PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS:
416 case PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS:
417 case PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS:
418 return 16384;
419
420 case PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH:
421 return 1024;
422
423 case PIPE_SHADER_CAP_MAX_INPUTS:
424 return 16;
425
426 case PIPE_SHADER_CAP_MAX_OUTPUTS:
427 return shader == PIPE_SHADER_FRAGMENT ? 1 : 8;
428
429 case PIPE_SHADER_CAP_MAX_TEMPS:
430 return 256; /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
431
432 case PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE:
433 return 16 * 1024 * sizeof(float);
434
435 case PIPE_SHADER_CAP_MAX_CONST_BUFFERS:
436 return 1;
437
438 case PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED:
439 return 0;
440
441 case PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR:
442 case PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR:
443 case PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR:
444 return 0;
445
446 case PIPE_SHADER_CAP_INDIRECT_CONST_ADDR:
447 return 1;
448
449 case PIPE_SHADER_CAP_SUBROUTINES:
450 return 0;
451
452 case PIPE_SHADER_CAP_TGSI_SQRT_SUPPORTED:
453 return 0;
454
455 case PIPE_SHADER_CAP_INTEGERS:
456 return 1;
457
458 case PIPE_SHADER_CAP_INT64_ATOMICS:
459 case PIPE_SHADER_CAP_FP16:
460 case PIPE_SHADER_CAP_TGSI_DROUND_SUPPORTED:
461 case PIPE_SHADER_CAP_TGSI_DFRACEXP_DLDEXP_SUPPORTED:
462 case PIPE_SHADER_CAP_TGSI_LDEXP_SUPPORTED:
463 case PIPE_SHADER_CAP_TGSI_FMA_SUPPORTED:
464 case PIPE_SHADER_CAP_TGSI_ANY_INOUT_DECL_RANGE:
465 return 0;
466
467 case PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS:
468 case PIPE_SHADER_CAP_MAX_SAMPLER_VIEWS:
469 return 16; /* XXX: How many? */
470
471 case PIPE_SHADER_CAP_PREFERRED_IR:
472 return PIPE_SHADER_IR_NIR;
473
474 case PIPE_SHADER_CAP_SUPPORTED_IRS:
475 return 0;
476
477 case PIPE_SHADER_CAP_MAX_UNROLL_ITERATIONS_HINT:
478 return 32;
479
480 case PIPE_SHADER_CAP_MAX_SHADER_BUFFERS:
481 case PIPE_SHADER_CAP_MAX_SHADER_IMAGES:
482 case PIPE_SHADER_CAP_LOWER_IF_THRESHOLD:
483 case PIPE_SHADER_CAP_TGSI_SKIP_MERGE_REGISTERS:
484 case PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTERS:
485 case PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTER_BUFFERS:
486 return 0;
487
488 default:
489 fprintf(stderr, "unknown shader param %d\n", param);
490 return 0;
491 }
492
493 return 0;
494 }
495
496 static float
497 panfrost_get_paramf(struct pipe_screen *screen, enum pipe_capf param)
498 {
499 switch (param) {
500 case PIPE_CAPF_MAX_LINE_WIDTH:
501
502 /* fall-through */
503 case PIPE_CAPF_MAX_LINE_WIDTH_AA:
504 return 255.0; /* arbitrary */
505
506 case PIPE_CAPF_MAX_POINT_WIDTH:
507
508 /* fall-through */
509 case PIPE_CAPF_MAX_POINT_WIDTH_AA:
510 return 255.0; /* arbitrary */
511
512 case PIPE_CAPF_MAX_TEXTURE_ANISOTROPY:
513 return 16.0;
514
515 case PIPE_CAPF_MAX_TEXTURE_LOD_BIAS:
516 return 16.0; /* arbitrary */
517
518 default:
519 debug_printf("Unexpected PIPE_CAPF %d query\n", param);
520 return 0.0;
521 }
522 }
523
524 /**
525 * Query format support for creating a texture, drawing surface, etc.
526 * \param format the format to test
527 * \param type one of PIPE_TEXTURE, PIPE_SURFACE
528 */
529 static boolean
530 panfrost_is_format_supported( struct pipe_screen *screen,
531 enum pipe_format format,
532 enum pipe_texture_target target,
533 unsigned sample_count,
534 unsigned storage_sample_count,
535 unsigned bind)
536 {
537 const struct util_format_description *format_desc;
538
539 assert(target == PIPE_BUFFER ||
540 target == PIPE_TEXTURE_1D ||
541 target == PIPE_TEXTURE_1D_ARRAY ||
542 target == PIPE_TEXTURE_2D ||
543 target == PIPE_TEXTURE_2D_ARRAY ||
544 target == PIPE_TEXTURE_RECT ||
545 target == PIPE_TEXTURE_3D ||
546 target == PIPE_TEXTURE_CUBE ||
547 target == PIPE_TEXTURE_CUBE_ARRAY);
548
549 format_desc = util_format_description(format);
550
551 if (!format_desc)
552 return FALSE;
553
554 if (sample_count > 1)
555 return FALSE;
556
557 /* Format wishlist */
558 if (format == PIPE_FORMAT_Z24X8_UNORM || format == PIPE_FORMAT_X8Z24_UNORM)
559 return FALSE;
560
561 if (bind & PIPE_BIND_RENDER_TARGET) {
562 /* We don't support rendering into anything but RGBA8 yet. We
563 * need more formats for spec compliance, but for now, honesty
564 * is the best policy <3 */
565
566 if (!util_format_is_rgba8_variant(format_desc))
567 return FALSE;
568
569 if (format_desc->colorspace == UTIL_FORMAT_COLORSPACE_ZS)
570 return FALSE;
571
572 /*
573 * Although possible, it is unnatural to render into compressed or YUV
574 * surfaces. So disable these here to avoid going into weird paths
575 * inside the state trackers.
576 */
577 if (format_desc->block.width != 1 ||
578 format_desc->block.height != 1)
579 return FALSE;
580 }
581
582 if (bind & PIPE_BIND_DEPTH_STENCIL) {
583 if (format_desc->colorspace != UTIL_FORMAT_COLORSPACE_ZS)
584 return FALSE;
585 }
586
587 if (format_desc->layout == UTIL_FORMAT_LAYOUT_BPTC ||
588 format_desc->layout == UTIL_FORMAT_LAYOUT_ASTC) {
589 /* Compressed formats not yet hooked up. */
590 return FALSE;
591 }
592
593 if ((bind & (PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW)) &&
594 ((bind & PIPE_BIND_DISPLAY_TARGET) == 0) &&
595 target != PIPE_BUFFER) {
596 const struct util_format_description *desc =
597 util_format_description(format);
598
599 if (desc->nr_channels == 3 && desc->is_array) {
600 /* Don't support any 3-component formats for rendering/texturing
601 * since we don't support the corresponding 8-bit 3 channel UNORM
602 * formats. This allows us to support GL_ARB_copy_image between
603 * GL_RGB8 and GL_RGB8UI, for example. Otherwise, we may be asked to
604 * do a resource copy between PIPE_FORMAT_R8G8B8_UINT and
605 * PIPE_FORMAT_R8G8B8X8_UNORM, for example, which will not work
606 * (different bpp).
607 */
608 return FALSE;
609 }
610 }
611
612 return TRUE;
613 }
614
615
616 static void
617 panfrost_destroy_screen( struct pipe_screen *screen )
618 {
619 FREE(screen);
620 }
621
622 static void
623 panfrost_flush_frontbuffer(struct pipe_screen *_screen,
624 struct pipe_resource *resource,
625 unsigned level, unsigned layer,
626 void *context_private,
627 struct pipe_box *sub_box)
628 {
629 /* TODO: Display target integration */
630 }
631
632 static uint64_t
633 panfrost_get_timestamp(struct pipe_screen *_screen)
634 {
635 return os_time_get_nano();
636 }
637
638 static void
639 panfrost_fence_reference(struct pipe_screen *screen,
640 struct pipe_fence_handle **ptr,
641 struct pipe_fence_handle *fence)
642 {
643 *ptr = fence;
644 }
645
646 static boolean
647 panfrost_fence_finish(struct pipe_screen *screen,
648 struct pipe_context *ctx,
649 struct pipe_fence_handle *fence,
650 uint64_t timeout)
651 {
652 assert(fence);
653 return TRUE;
654 }
655
656 static const void *
657 panfrost_screen_get_compiler_options(struct pipe_screen *pscreen,
658 enum pipe_shader_ir ir,
659 enum pipe_shader_type shader)
660 {
661 return NULL;
662 }
663
664 struct pipe_screen *
665 panfrost_create_screen(int fd, struct renderonly *ro, bool is_drm)
666 {
667 struct panfrost_screen *screen = CALLOC_STRUCT(panfrost_screen);
668
669 if (!screen)
670 return NULL;
671
672 if (ro) {
673 screen->ro = renderonly_dup(ro);
674 if (!screen->ro) {
675 fprintf(stderr, "Failed to dup renderonly object\n");
676 free(screen);
677 return NULL;
678 }
679 }
680
681 screen->base.destroy = panfrost_destroy_screen;
682
683 screen->base.get_name = panfrost_get_name;
684 screen->base.get_vendor = panfrost_get_vendor;
685 screen->base.get_device_vendor = panfrost_get_device_vendor;
686 screen->base.get_param = panfrost_get_param;
687 screen->base.get_shader_param = panfrost_get_shader_param;
688 screen->base.get_paramf = panfrost_get_paramf;
689 screen->base.get_timestamp = panfrost_get_timestamp;
690 screen->base.is_format_supported = panfrost_is_format_supported;
691 //screen->base.context_create = panfrost_create_context;
692 screen->base.flush_frontbuffer = panfrost_flush_frontbuffer;
693 screen->base.get_compiler_options = panfrost_screen_get_compiler_options;
694 screen->base.fence_reference = panfrost_fence_reference;
695 screen->base.fence_finish = panfrost_fence_finish;
696
697 screen->last_fragment_id = -1;
698 screen->last_fragment_flushed = true;
699
700 fprintf(stderr, "stub: Upstream panfrost (use downstream fork)\n");
701 return NULL;
702 }