X-Git-Url: https://git.libre-soc.org/?p=mesa.git;a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Fv3d%2Fv3d_screen.c;h=9e30268e858010f782c00ec3fc76729d9c39708d;hp=95e6a6907f49eea76336820379e5328aaa8f692c;hb=9d0523b569bb7208c6e74cafc0f3945415d94336;hpb=8c47ebbd232704ab048eab2572e2b2a44f38957a diff --git a/src/gallium/drivers/v3d/v3d_screen.c b/src/gallium/drivers/v3d/v3d_screen.c index 95e6a6907f4..9e30268e858 100644 --- a/src/gallium/drivers/v3d/v3d_screen.c +++ b/src/gallium/drivers/v3d/v3d_screen.c @@ -22,7 +22,10 @@ * IN THE SOFTWARE. */ -#include "os/os_misc.h" +#include + +#include "common/v3d_device_info.h" +#include "util/os_misc.h" #include "pipe/p_defines.h" #include "pipe/p_screen.h" #include "pipe/p_state.h" @@ -31,22 +34,26 @@ #include "util/u_memory.h" #include "util/u_format.h" #include "util/u_hash_table.h" +#include "util/u_screen.h" +#include "util/u_transfer_helper.h" #include "util/ralloc.h" +#include "util/xmlconfig.h" #include #include "v3d_screen.h" #include "v3d_context.h" #include "v3d_resource.h" #include "compiler/v3d_compiler.h" +#include "drm-uapi/drm_fourcc.h" static const char * -vc5_screen_get_name(struct pipe_screen *pscreen) +v3d_screen_get_name(struct pipe_screen *pscreen) { - struct vc5_screen *screen = vc5_screen(pscreen); + struct v3d_screen *screen = v3d_screen(pscreen); if (!screen->name) { screen->name = ralloc_asprintf(screen, - "VC5 V3D %d.%d", + "V3D %d.%d", screen->devinfo.ver / 10, screen->devinfo.ver % 10); } @@ -55,33 +62,49 @@ vc5_screen_get_name(struct pipe_screen *pscreen) } static const char * -vc5_screen_get_vendor(struct pipe_screen *pscreen) +v3d_screen_get_vendor(struct pipe_screen *pscreen) { return "Broadcom"; } static void -vc5_screen_destroy(struct pipe_screen *pscreen) +v3d_screen_destroy(struct pipe_screen *pscreen) { - struct vc5_screen *screen = vc5_screen(pscreen); + struct v3d_screen *screen = v3d_screen(pscreen); util_hash_table_destroy(screen->bo_handles); - vc5_bufmgr_destroy(pscreen); + v3d_bufmgr_destroy(pscreen); slab_destroy_parent(&screen->transfer_pool); + free(screen->ro); - if (using_vc5_simulator) - vc5_simulator_destroy(screen); + if (using_v3d_simulator) + v3d_simulator_destroy(screen); v3d_compiler_free(screen->compiler); + u_transfer_helper_destroy(pscreen->transfer_helper); close(screen->fd); ralloc_free(pscreen); } +static bool +v3d_has_feature(struct v3d_screen *screen, enum drm_v3d_param feature) +{ + struct drm_v3d_get_param p = { + .param = feature, + }; + int ret = v3d_ioctl(screen->fd, DRM_IOCTL_V3D_GET_PARAM, &p); + + if (ret != 0) + return false; + + return p.value; +} + static int -vc5_screen_get_param(struct pipe_screen *pscreen, enum pipe_cap param) +v3d_screen_get_param(struct pipe_screen *pscreen, enum pipe_cap param) { - struct vc5_screen *screen = vc5_screen(pscreen); + struct v3d_screen *screen = v3d_screen(pscreen); switch (param) { /* Supported features (boolean caps). */ @@ -97,34 +120,68 @@ vc5_screen_get_param(struct pipe_screen *pscreen, enum pipe_cap param) case PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR: case PIPE_CAP_START_INSTANCE: case PIPE_CAP_TGSI_INSTANCEID: - case PIPE_CAP_SM3: + case PIPE_CAP_FRAGMENT_SHADER_TEXTURE_LOD: + case PIPE_CAP_FRAGMENT_SHADER_DERIVATIVES: + case PIPE_CAP_VERTEX_SHADER_SATURATE: case PIPE_CAP_TEXTURE_QUERY_LOD: case PIPE_CAP_PRIMITIVE_RESTART: - case PIPE_CAP_GLSL_OPTIMIZE_CONSERVATIVELY: case PIPE_CAP_OCCLUSION_QUERY: case PIPE_CAP_POINT_SPRITE: case PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME: - case PIPE_CAP_ALLOW_MAPPED_BUFFERS_DURING_EXECUTION: - case PIPE_CAP_COMPUTE: case PIPE_CAP_DRAW_INDIRECT: + case PIPE_CAP_MULTI_DRAW_INDIRECT: case PIPE_CAP_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION: case PIPE_CAP_SIGNED_VERTEX_BUFFER_OFFSET: + case PIPE_CAP_TGSI_CAN_READ_OUTPUTS: + case PIPE_CAP_TGSI_PACK_HALF_FLOAT: + case PIPE_CAP_TEXTURE_HALF_FLOAT_LINEAR: + case PIPE_CAP_FRAMEBUFFER_NO_ATTACHMENT: + case PIPE_CAP_TGSI_FS_FACE_IS_INTEGER_SYSVAL: return 1; + case PIPE_CAP_PACKED_UNIFORMS: + /* We can't enable this flag, because it results in load_ubo + * intrinsics across a 16b boundary, but v3d's TMU general + * memory accesses wrap on 16b boundaries. + */ + return 0; + + case PIPE_CAP_PREFER_BLIT_BASED_TEXTURE_TRANSFER: + /* XXX perf: we don't want to emit these extra blits for + * glReadPixels(), since we still have to do an uncached read + * from the GPU of the result after waiting for the TFU blit + * to happen. However, disabling this introduces instability + * in + * dEQP-GLES31.functional.image_load_store.early_fragment_tests.* + * and corruption in chromium's rendering. + */ + return 1; + + case PIPE_CAP_COMPUTE: + return screen->has_csd && screen->devinfo.ver >= 41; + + case PIPE_CAP_GENERATE_MIPMAP: + return v3d_has_feature(screen, DRM_V3D_PARAM_SUPPORTS_TFU); + case PIPE_CAP_INDEP_BLEND_ENABLE: return screen->devinfo.ver >= 40; case PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT: return 256; + case PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS: + if (screen->devinfo.ver < 40) + return 0; + return 4; + case PIPE_CAP_SHADER_BUFFER_OFFSET_ALIGNMENT: return 4; case PIPE_CAP_GLSL_FEATURE_LEVEL: - return 400; + return 330; - case PIPE_CAP_MAX_VIEWPORTS: - return 1; + case PIPE_CAP_GLSL_FEATURE_LEVEL_COMPATIBILITY: + return 140; case PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT: return 1; @@ -146,138 +203,26 @@ vc5_screen_get_param(struct pipe_screen *pscreen, enum pipe_cap param) case PIPE_CAP_MIXED_COLOR_DEPTH_BITS: return 1; - - /* Stream output. */ case PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS: return 4; - case PIPE_CAP_MAX_STREAM_OUTPUT_SEPARATE_COMPONENTS: - case PIPE_CAP_MAX_STREAM_OUTPUT_INTERLEAVED_COMPONENTS: - return 64; - - case PIPE_CAP_MIN_TEXEL_OFFSET: - case PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET: - return -8; - case PIPE_CAP_MAX_TEXEL_OFFSET: - case PIPE_CAP_MAX_TEXTURE_GATHER_OFFSET: - return 7; - - /* Unsupported features. */ - case PIPE_CAP_ANISOTROPIC_FILTER: - case PIPE_CAP_TEXTURE_BUFFER_OBJECTS: - case PIPE_CAP_BUFFER_SAMPLER_VIEW_RGBA_ONLY: - case PIPE_CAP_CUBE_MAP_ARRAY: - case PIPE_CAP_TEXTURE_MIRROR_CLAMP: - case PIPE_CAP_SEAMLESS_CUBE_MAP: - case PIPE_CAP_VERTEX_BUFFER_OFFSET_4BYTE_ALIGNED_ONLY: - case PIPE_CAP_VERTEX_BUFFER_STRIDE_4BYTE_ALIGNED_ONLY: - case PIPE_CAP_VERTEX_ELEMENT_SRC_OFFSET_4BYTE_ALIGNED_ONLY: - case PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS: - case PIPE_CAP_SHADER_STENCIL_EXPORT: - case PIPE_CAP_TGSI_TEXCOORD: - case PIPE_CAP_PREFER_BLIT_BASED_TEXTURE_TRANSFER: - case PIPE_CAP_CONDITIONAL_RENDER: - case PIPE_CAP_TEXTURE_BARRIER: - case PIPE_CAP_INDEP_BLEND_FUNC: - case PIPE_CAP_DEPTH_CLIP_DISABLE: - case PIPE_CAP_SEAMLESS_CUBE_MAP_PER_TEXTURE: - case PIPE_CAP_TGSI_CAN_COMPACT_CONSTANTS: - case PIPE_CAP_USER_VERTEX_BUFFERS: - case PIPE_CAP_QUERY_PIPELINE_STATISTICS: - case PIPE_CAP_TEXTURE_BORDER_COLOR_QUIRK: - case PIPE_CAP_TGSI_VS_LAYER_VIEWPORT: - case PIPE_CAP_TGSI_TES_LAYER_VIEWPORT: - case PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS: - case PIPE_CAP_TEXTURE_GATHER_SM5: - case PIPE_CAP_FAKE_SW_MSAA: - case PIPE_CAP_SAMPLE_SHADING: - case PIPE_CAP_TEXTURE_GATHER_OFFSETS: - case PIPE_CAP_TGSI_VS_WINDOW_SPACE_POSITION: - case PIPE_CAP_MAX_VERTEX_STREAMS: - case PIPE_CAP_MULTI_DRAW_INDIRECT: - case PIPE_CAP_MULTI_DRAW_INDIRECT_PARAMS: - case PIPE_CAP_TGSI_FS_FINE_DERIVATIVE: - case PIPE_CAP_CONDITIONAL_RENDER_INVERTED: - case PIPE_CAP_SAMPLER_VIEW_TARGET: - case PIPE_CAP_CLIP_HALFZ: - case PIPE_CAP_VERTEXID_NOBASE: - case PIPE_CAP_POLYGON_OFFSET_CLAMP: - case PIPE_CAP_MULTISAMPLE_Z_RESOLVE: - case PIPE_CAP_RESOURCE_FROM_USER_MEMORY: - case PIPE_CAP_DEVICE_RESET_STATUS_QUERY: - case PIPE_CAP_MAX_SHADER_PATCH_VARYINGS: - case PIPE_CAP_TEXTURE_FLOAT_LINEAR: - case PIPE_CAP_TEXTURE_HALF_FLOAT_LINEAR: - case PIPE_CAP_DEPTH_BOUNDS_TEST: - case PIPE_CAP_TGSI_TXQS: - case PIPE_CAP_FORCE_PERSAMPLE_INTERP: - case PIPE_CAP_COPY_BETWEEN_COMPRESSED_AND_PLAIN_FORMATS: - case PIPE_CAP_CLEAR_TEXTURE: - case PIPE_CAP_DRAW_PARAMETERS: - case PIPE_CAP_TGSI_PACK_HALF_FLOAT: - case PIPE_CAP_TGSI_FS_POSITION_IS_SYSVAL: - case PIPE_CAP_TGSI_FS_FACE_IS_INTEGER_SYSVAL: - case PIPE_CAP_INVALIDATE_BUFFER: - case PIPE_CAP_GENERATE_MIPMAP: - case PIPE_CAP_STRING_MARKER: - case PIPE_CAP_SURFACE_REINTERPRET_BLOCKS: - case PIPE_CAP_QUERY_BUFFER_OBJECT: - case PIPE_CAP_QUERY_MEMORY_INFO: - case PIPE_CAP_PCI_GROUP: - case PIPE_CAP_PCI_BUS: - case PIPE_CAP_PCI_DEVICE: - case PIPE_CAP_PCI_FUNCTION: - case PIPE_CAP_FRAMEBUFFER_NO_ATTACHMENT: - case PIPE_CAP_ROBUST_BUFFER_ACCESS_BEHAVIOR: - case PIPE_CAP_CULL_DISTANCE: - case PIPE_CAP_PRIMITIVE_RESTART_FOR_PATCHES: - case PIPE_CAP_TGSI_VOTE: - case PIPE_CAP_MAX_WINDOW_RECTANGLES: - case PIPE_CAP_POLYGON_OFFSET_UNITS_UNSCALED: - case PIPE_CAP_VIEWPORT_SUBPIXEL_BITS: - case PIPE_CAP_TGSI_ARRAY_COMPONENTS: - case PIPE_CAP_TGSI_FS_FBFETCH: - case PIPE_CAP_INT64: - case PIPE_CAP_INT64_DIVMOD: - case PIPE_CAP_DOUBLES: - case PIPE_CAP_BINDLESS_TEXTURE: - case PIPE_CAP_POST_DEPTH_COVERAGE: - case PIPE_CAP_CAN_BIND_CONST_BUFFER_AS_VERTEX: - case PIPE_CAP_TGSI_BALLOT: - case PIPE_CAP_SPARSE_BUFFER_PAGE_SIZE: - case PIPE_CAP_POLYGON_MODE_FILL_RECTANGLE: - case PIPE_CAP_TGSI_CLOCK: - case PIPE_CAP_TGSI_TEX_TXF_LZ: - case PIPE_CAP_NATIVE_FENCE_FD: - case PIPE_CAP_FENCE_SIGNAL: - case PIPE_CAP_TGSI_MUL_ZERO_WINS: - case PIPE_CAP_NIR_SAMPLERS_AS_DEREF: - case PIPE_CAP_QUERY_SO_OVERFLOW: - case PIPE_CAP_MEMOBJ: - case PIPE_CAP_LOAD_CONSTBUF: - case PIPE_CAP_TILE_RASTER_ORDER: - case PIPE_CAP_STREAM_OUTPUT_INTERLEAVE_BUFFERS: - case PIPE_CAP_MAX_COMBINED_SHADER_OUTPUT_RESOURCES: - case PIPE_CAP_CONTEXT_PRIORITY_MASK: - case PIPE_CAP_CONSTBUF0_FLAGS: - case PIPE_CAP_CONSERVATIVE_RASTER_POST_SNAP_TRIANGLES: - case PIPE_CAP_CONSERVATIVE_RASTER_POST_SNAP_POINTS_LINES: - case PIPE_CAP_CONSERVATIVE_RASTER_PRE_SNAP_TRIANGLES: - case PIPE_CAP_CONSERVATIVE_RASTER_PRE_SNAP_POINTS_LINES: - case PIPE_CAP_CONSERVATIVE_RASTER_POST_DEPTH_COVERAGE: - case PIPE_CAP_MAX_CONSERVATIVE_RASTER_SUBPIXEL_PRECISION_BIAS: - case PIPE_CAP_PACKED_UNIFORMS: - return 0; - /* Geometry shader output, unsupported. */ - case PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES: - case PIPE_CAP_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS: - return 0; + case PIPE_CAP_MAX_VARYINGS: + return V3D_MAX_FS_INPUTS / 4; /* Texturing. */ - case PIPE_CAP_MAX_TEXTURE_2D_LEVELS: + case PIPE_CAP_MAX_TEXTURE_2D_SIZE: + if (screen->devinfo.ver < 40) + return 2048; + else if (screen->nonmsaa_texture_size_limit) + return 7680; + else + return 4096; case PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS: case PIPE_CAP_MAX_TEXTURE_3D_LEVELS: - return VC5_MAX_MIP_LEVELS; + if (screen->devinfo.ver < 40) + return 12; + else + return V3D_MAX_MIP_LEVELS; case PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS: return 2048; @@ -285,24 +230,8 @@ vc5_screen_get_param(struct pipe_screen *pscreen, enum pipe_cap param) case PIPE_CAP_MAX_RENDER_TARGETS: return 4; - /* Queries. */ - case PIPE_CAP_QUERY_TIME_ELAPSED: - case PIPE_CAP_QUERY_TIMESTAMP: - return 0; - - case PIPE_CAP_MAX_VERTEX_ATTRIB_STRIDE: - return 2048; - - case PIPE_CAP_ENDIANNESS: - return PIPE_ENDIAN_LITTLE; - - case PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT: - return 64; - case PIPE_CAP_VENDOR_ID: return 0x14E4; - case PIPE_CAP_DEVICE_ID: - return 0xFFFFFFFF; case PIPE_CAP_ACCELERATED: return 1; case PIPE_CAP_VIDEO_MEMORY: { @@ -316,14 +245,16 @@ vc5_screen_get_param(struct pipe_screen *pscreen, enum pipe_cap param) case PIPE_CAP_UMA: return 1; - default: - fprintf(stderr, "unknown param %d\n", param); + case PIPE_CAP_ALPHA_TEST: return 0; + + default: + return u_pipe_screen_get_param_defaults(pscreen, param); } } static float -vc5_screen_get_paramf(struct pipe_screen *pscreen, enum pipe_capf param) +v3d_screen_get_paramf(struct pipe_screen *pscreen, enum pipe_capf param) { switch (param) { case PIPE_CAPF_MAX_LINE_WIDTH: @@ -350,11 +281,20 @@ vc5_screen_get_paramf(struct pipe_screen *pscreen, enum pipe_capf param) } static int -vc5_screen_get_shader_param(struct pipe_screen *pscreen, unsigned shader, +v3d_screen_get_shader_param(struct pipe_screen *pscreen, unsigned shader, enum pipe_shader_cap param) { - if (shader != PIPE_SHADER_VERTEX && - shader != PIPE_SHADER_FRAGMENT) { + struct v3d_screen *screen = v3d_screen(pscreen); + + switch (shader) { + case PIPE_SHADER_VERTEX: + case PIPE_SHADER_FRAGMENT: + break; + case PIPE_SHADER_COMPUTE: + if (!screen->has_csd) + return 0; + break; + default: return 0; } @@ -371,17 +311,20 @@ vc5_screen_get_shader_param(struct pipe_screen *pscreen, unsigned shader, case PIPE_SHADER_CAP_MAX_INPUTS: if (shader == PIPE_SHADER_FRAGMENT) - return VC5_MAX_FS_INPUTS / 4; + return V3D_MAX_FS_INPUTS / 4; else - return 16; + return V3D_MAX_VS_INPUTS / 4; case PIPE_SHADER_CAP_MAX_OUTPUTS: if (shader == PIPE_SHADER_FRAGMENT) return 4; else - return VC5_MAX_FS_INPUTS / 4; + return V3D_MAX_FS_INPUTS / 4; case PIPE_SHADER_CAP_MAX_TEMPS: return 256; /* GL_MAX_PROGRAM_TEMPORARIES_ARB */ case PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE: + /* Note: Limited by the offset size in + * v3d_unit_data_create(). + */ return 16 * 1024 * sizeof(float); case PIPE_SHADER_CAP_MAX_CONST_BUFFERS: return 16; @@ -389,8 +332,9 @@ vc5_screen_get_shader_param(struct pipe_screen *pscreen, unsigned shader, return 0; case PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR: case PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR: - case PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR: return 0; + case PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR: + return 1; case PIPE_SHADER_CAP_INDIRECT_CONST_ADDR: return 1; case PIPE_SHADER_CAP_SUBROUTINES: @@ -409,13 +353,24 @@ vc5_screen_get_shader_param(struct pipe_screen *pscreen, unsigned shader, return 0; case PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS: case PIPE_SHADER_CAP_MAX_SAMPLER_VIEWS: - case PIPE_SHADER_CAP_MAX_SHADER_IMAGES: + return V3D_MAX_TEXTURE_SAMPLERS; + case PIPE_SHADER_CAP_MAX_SHADER_BUFFERS: - return VC5_MAX_TEXTURE_SAMPLERS; + if (shader == PIPE_SHADER_VERTEX) + return 0; + + return PIPE_MAX_SHADER_BUFFERS; + + case PIPE_SHADER_CAP_MAX_SHADER_IMAGES: + if (screen->devinfo.ver < 41) + return 0; + else + return PIPE_MAX_SHADER_IMAGES; + case PIPE_SHADER_CAP_PREFERRED_IR: return PIPE_SHADER_IR_NIR; case PIPE_SHADER_CAP_SUPPORTED_IRS: - return 0; + return 1 << PIPE_SHADER_IR_NIR; case PIPE_SHADER_CAP_MAX_UNROLL_ITERATIONS_HINT: return 32; case PIPE_SHADER_CAP_LOWER_IF_THRESHOLD: @@ -428,21 +383,104 @@ vc5_screen_get_shader_param(struct pipe_screen *pscreen, unsigned shader, return 0; } -static boolean -vc5_screen_is_format_supported(struct pipe_screen *pscreen, +static int +v3d_get_compute_param(struct pipe_screen *pscreen, enum pipe_shader_ir ir_type, + enum pipe_compute_cap param, void *ret) +{ + struct v3d_screen *screen = v3d_screen(pscreen); + + if (!screen->has_csd) + 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: + RET((uint32_t []) { 32 }); + break; + + case PIPE_COMPUTE_CAP_IR_TARGET: + sprintf(ret, "v3d"); + return strlen(ret); + + case PIPE_COMPUTE_CAP_GRID_DIMENSION: + RET((uint64_t []) { 3 }); + + case PIPE_COMPUTE_CAP_MAX_GRID_SIZE: + /* GL_MAX_COMPUTE_SHADER_WORK_GROUP_COUNT: The CSD has a + * 16-bit field for the number of workgroups in each + * dimension. + */ + RET(((uint64_t []) { 65535, 65535, 65535 })); + + case PIPE_COMPUTE_CAP_MAX_BLOCK_SIZE: + /* GL_MAX_COMPUTE_WORK_GROUP_SIZE */ + RET(((uint64_t []) { 256, 256, 256 })); + + case PIPE_COMPUTE_CAP_MAX_THREADS_PER_BLOCK: + case PIPE_COMPUTE_CAP_MAX_VARIABLE_THREADS_PER_BLOCK: + /* GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS: This is + * limited by WG_SIZE in the CSD. + */ + RET((uint64_t []) { 256 }); + + case PIPE_COMPUTE_CAP_MAX_GLOBAL_SIZE: + RET((uint64_t []) { 1024 * 1024 * 1024 }); + + case PIPE_COMPUTE_CAP_MAX_LOCAL_SIZE: + /* GL_MAX_COMPUTE_SHARED_MEMORY_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: { + struct sysinfo si; + sysinfo(&si); + RET((uint64_t []) { si.totalram }); + } + + case PIPE_COMPUTE_CAP_MAX_CLOCK_FREQUENCY: + /* OpenCL only */ + RET((uint32_t []) { 0 }); + + case PIPE_COMPUTE_CAP_MAX_COMPUTE_UNITS: + RET((uint32_t []) { 1 }); + + case PIPE_COMPUTE_CAP_IMAGES_SUPPORTED: + RET((uint32_t []) { 1 }); + + case PIPE_COMPUTE_CAP_SUBGROUP_SIZE: + RET((uint32_t []) { 16 }); + + } + + return 0; +} + +static bool +v3d_screen_is_format_supported(struct pipe_screen *pscreen, enum pipe_format format, enum pipe_texture_target target, unsigned sample_count, + unsigned storage_sample_count, unsigned usage) { - struct vc5_screen *screen = vc5_screen(pscreen); + struct v3d_screen *screen = v3d_screen(pscreen); + + if (MAX2(1, sample_count) != MAX2(1, storage_sample_count)) + return false; - if (sample_count > 1 && sample_count != VC5_MAX_SAMPLES) - return FALSE; + if (sample_count > 1 && sample_count != V3D_MAX_SAMPLES) + return false; - if ((target >= PIPE_MAX_TEXTURE_TYPES) || - !util_format_is_supported(format, usage)) { - return FALSE; + if (target >= PIPE_MAX_TEXTURE_TYPES) { + return false; } if (usage & PIPE_BIND_VERTEX_BUFFER) { @@ -501,18 +539,22 @@ vc5_screen_is_format_supported(struct pipe_screen *pscreen, case PIPE_FORMAT_B10G10R10A2_SSCALED: break; default: - return FALSE; + return false; } } + /* FORMAT_NONE gets allowed for ARB_framebuffer_no_attachments's probe + * of FRAMEBUFFER_MAX_SAMPLES + */ if ((usage & PIPE_BIND_RENDER_TARGET) && - !vc5_rt_format_supported(&screen->devinfo, format)) { - return FALSE; + format != PIPE_FORMAT_NONE && + !v3d_rt_format_supported(&screen->devinfo, format)) { + return false; } if ((usage & PIPE_BIND_SAMPLER_VIEW) && - !vc5_tex_format_supported(&screen->devinfo, format)) { - return FALSE; + !v3d_tex_format_supported(&screen->devinfo, format)) { + return false; } if ((usage & PIPE_BIND_DEPTH_STENCIL) && @@ -521,17 +563,17 @@ vc5_screen_is_format_supported(struct pipe_screen *pscreen, format == PIPE_FORMAT_Z16_UNORM || format == PIPE_FORMAT_Z32_FLOAT || format == PIPE_FORMAT_Z32_FLOAT_S8X24_UINT)) { - return FALSE; + return false; } if ((usage & PIPE_BIND_INDEX_BUFFER) && !(format == PIPE_FORMAT_I8_UINT || format == PIPE_FORMAT_I16_UINT || format == PIPE_FORMAT_I32_UINT)) { - return FALSE; + return false; } - return TRUE; + return true; } #define PTR_TO_UINT(x) ((unsigned)((intptr_t)(x))) @@ -546,98 +588,102 @@ static int handle_compare(void *key1, void *key2) return PTR_TO_UINT(key1) != PTR_TO_UINT(key2); } -static bool -vc5_get_device_info(struct vc5_screen *screen) +static const void * +v3d_screen_get_compiler_options(struct pipe_screen *pscreen, + enum pipe_shader_ir ir, unsigned shader) { - struct drm_v3d_get_param ident0 = { - .param = DRM_V3D_PARAM_V3D_CORE0_IDENT0, - }; - struct drm_v3d_get_param ident1 = { - .param = DRM_V3D_PARAM_V3D_CORE0_IDENT1, - }; - int ret; - - ret = vc5_ioctl(screen->fd, DRM_IOCTL_V3D_GET_PARAM, &ident0); - if (ret != 0) { - fprintf(stderr, "Couldn't get V3D core IDENT0: %s\n", - strerror(errno)); - return false; - } - ret = vc5_ioctl(screen->fd, DRM_IOCTL_V3D_GET_PARAM, &ident1); - if (ret != 0) { - fprintf(stderr, "Couldn't get V3D core IDENT1: %s\n", - strerror(errno)); - return false; - } + return &v3d_nir_options; +} - uint32_t major = (ident0.value >> 24) & 0xff; - uint32_t minor = (ident1.value >> 0) & 0xf; - screen->devinfo.ver = major * 10 + minor; +static void +v3d_screen_query_dmabuf_modifiers(struct pipe_screen *pscreen, + enum pipe_format format, int max, + uint64_t *modifiers, + unsigned int *external_only, + int *count) +{ + int i; + uint64_t available_modifiers[] = { + DRM_FORMAT_MOD_BROADCOM_UIF, + DRM_FORMAT_MOD_LINEAR, + }; + int num_modifiers = ARRAY_SIZE(available_modifiers); - switch (screen->devinfo.ver) { - case 33: - case 41: - case 42: - break; - default: - fprintf(stderr, - "V3D %d.%d not supported by this version of Mesa.\n", - screen->devinfo.ver / 10, - screen->devinfo.ver % 10); - return false; + if (!modifiers) { + *count = num_modifiers; + return; } - return true; -} - -static const void * -vc5_screen_get_compiler_options(struct pipe_screen *pscreen, - enum pipe_shader_ir ir, unsigned shader) -{ - return &v3d_nir_options; + *count = MIN2(max, num_modifiers); + for (i = 0; i < *count; i++) { + modifiers[i] = available_modifiers[i]; + if (external_only) + external_only[i] = false; + } } struct pipe_screen * -v3d_screen_create(int fd) +v3d_screen_create(int fd, const struct pipe_screen_config *config, + struct renderonly *ro) { - struct vc5_screen *screen = rzalloc(NULL, struct vc5_screen); + struct v3d_screen *screen = rzalloc(NULL, struct v3d_screen); struct pipe_screen *pscreen; pscreen = &screen->base; - pscreen->destroy = vc5_screen_destroy; - pscreen->get_param = vc5_screen_get_param; - pscreen->get_paramf = vc5_screen_get_paramf; - pscreen->get_shader_param = vc5_screen_get_shader_param; - pscreen->context_create = vc5_context_create; - pscreen->is_format_supported = vc5_screen_is_format_supported; + pscreen->destroy = v3d_screen_destroy; + pscreen->get_param = v3d_screen_get_param; + pscreen->get_paramf = v3d_screen_get_paramf; + pscreen->get_shader_param = v3d_screen_get_shader_param; + pscreen->get_compute_param = v3d_get_compute_param; + pscreen->context_create = v3d_context_create; + pscreen->is_format_supported = v3d_screen_is_format_supported; screen->fd = fd; + if (ro) { + screen->ro = renderonly_dup(ro); + if (!screen->ro) { + fprintf(stderr, "Failed to dup renderonly object\n"); + ralloc_free(screen); + return NULL; + } + } list_inithead(&screen->bo_cache.time_list); (void)mtx_init(&screen->bo_handles_mutex, mtx_plain); screen->bo_handles = util_hash_table_create(handle_hash, handle_compare); #if defined(USE_V3D_SIMULATOR) - vc5_simulator_init(screen); + v3d_simulator_init(screen); #endif - if (!vc5_get_device_info(screen)) + if (!v3d_get_device_info(screen->fd, &screen->devinfo, &v3d_ioctl)) goto fail; - slab_create_parent(&screen->transfer_pool, sizeof(struct vc5_transfer), 16); + /* We have to driCheckOption for the simulator mode to not assertion + * fail on not having our XML config. + */ + const char *nonmsaa_name = "v3d_nonmsaa_texture_size_limit"; + screen->nonmsaa_texture_size_limit = + driCheckOption(config->options, nonmsaa_name, DRI_BOOL) && + driQueryOptionb(config->options, nonmsaa_name); + + slab_create_parent(&screen->transfer_pool, sizeof(struct v3d_transfer), 16); + + screen->has_csd = false; /* until the UABI is enabled. */ - vc5_fence_init(screen); + v3d_fence_init(screen); v3d_process_debug_variable(); - vc5_resource_screen_init(pscreen); + v3d_resource_screen_init(pscreen); screen->compiler = v3d_compiler_init(&screen->devinfo); - pscreen->get_name = vc5_screen_get_name; - pscreen->get_vendor = vc5_screen_get_vendor; - pscreen->get_device_vendor = vc5_screen_get_vendor; - pscreen->get_compiler_options = vc5_screen_get_compiler_options; + pscreen->get_name = v3d_screen_get_name; + pscreen->get_vendor = v3d_screen_get_vendor; + pscreen->get_device_vendor = v3d_screen_get_vendor; + pscreen->get_compiler_options = v3d_screen_get_compiler_options; + pscreen->query_dmabuf_modifiers = v3d_screen_query_dmabuf_modifiers; return pscreen;