#include <sys/sysinfo.h>
+#include "common/v3d_device_info.h"
#include "util/os_misc.h"
#include "pipe/p_defines.h"
#include "pipe/p_screen.h"
#include "util/u_screen.h"
#include "util/u_transfer_helper.h"
#include "util/ralloc.h"
+#include "util/xmlconfig.h"
#include <xf86drm.h>
#include "v3d_screen.h"
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_OCCLUSION_QUERY:
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:
return 0;
case PIPE_CAP_PREFER_BLIT_BASED_TEXTURE_TRANSFER:
- return 0;
+ /* 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;
return 4;
case PIPE_CAP_SHADER_BUFFER_OFFSET_ALIGNMENT:
- return 4;
+ if (screen->has_cache_flush)
+ return 4;
+ else
+ return 0; /* Disables shader storage */
case PIPE_CAP_GLSL_FEATURE_LEVEL:
return 330;
+ case PIPE_CAP_ESSL_FEATURE_LEVEL:
+ return 310;
+
case PIPE_CAP_GLSL_FEATURE_LEVEL_COMPATIBILITY:
return 140;
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:
if (screen->devinfo.ver < 40)
case PIPE_CAP_UMA:
return 1;
+ case PIPE_CAP_ALPHA_TEST:
+ return 0;
+
default:
return u_pipe_screen_get_param_defaults(pscreen, param);
}
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:
case PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTERS:
case PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTER_BUFFERS:
return 0;
- case PIPE_SHADER_CAP_SCALAR_ISA:
- return 1;
case PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS:
case PIPE_SHADER_CAP_MAX_SAMPLER_VIEWS:
return V3D_MAX_TEXTURE_SAMPLERS;
case PIPE_SHADER_CAP_MAX_SHADER_BUFFERS:
- return PIPE_MAX_SHADER_BUFFERS;
+ if (screen->has_cache_flush) {
+ if (shader == PIPE_SHADER_VERTEX)
+ return 0;
+
+ return PIPE_MAX_SHADER_BUFFERS;
+ } else {
+ return 0;
+ }
case PIPE_SHADER_CAP_MAX_SHADER_IMAGES:
- if (screen->devinfo.ver < 41)
+ if (screen->has_cache_flush) {
+ if (screen->devinfo.ver < 41)
+ return 0;
+ else
+ return PIPE_MAX_SHADER_IMAGES;
+ } else {
return 0;
- else
- return PIPE_MAX_SHADER_IMAGES;
+ }
case PIPE_SHADER_CAP_PREFERRED_IR:
return PIPE_SHADER_IR_NIR;
return 0;
}
-static boolean
+static bool
v3d_screen_is_format_supported(struct pipe_screen *pscreen,
enum pipe_format format,
enum pipe_texture_target target,
return false;
if (sample_count > 1 && sample_count != V3D_MAX_SAMPLES)
- return FALSE;
+ return false;
if (target >= PIPE_MAX_TEXTURE_TYPES) {
- return FALSE;
+ return false;
}
if (usage & PIPE_BIND_VERTEX_BUFFER) {
case PIPE_FORMAT_B10G10R10A2_SSCALED:
break;
default:
- return FALSE;
+ return false;
}
}
if ((usage & PIPE_BIND_RENDER_TARGET) &&
format != PIPE_FORMAT_NONE &&
!v3d_rt_format_supported(&screen->devinfo, format)) {
- return FALSE;
+ return false;
}
if ((usage & PIPE_BIND_SAMPLER_VIEW) &&
!v3d_tex_format_supported(&screen->devinfo, format)) {
- return FALSE;
+ return false;
}
if ((usage & PIPE_BIND_DEPTH_STENCIL) &&
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)))
return PTR_TO_UINT(key1) != PTR_TO_UINT(key2);
}
-static bool
-v3d_get_device_info(struct v3d_screen *screen)
-{
- 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 = v3d_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 = v3d_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;
- }
-
- uint32_t major = (ident0.value >> 24) & 0xff;
- uint32_t minor = (ident1.value >> 0) & 0xf;
- screen->devinfo.ver = major * 10 + minor;
-
- screen->devinfo.vpm_size = (ident1.value >> 28 & 0xf) * 8192;
-
- int nslc = (ident1.value >> 4) & 0xf;
- int qups = (ident1.value >> 8) & 0xf;
- screen->devinfo.qpu_count = nslc * qups;
-
- 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;
- }
-
- return true;
-}
-
static const void *
v3d_screen_get_compiler_options(struct pipe_screen *pscreen,
enum pipe_shader_ir ir, unsigned shader)
}
struct pipe_screen *
-v3d_screen_create(int fd, struct renderonly *ro)
+v3d_screen_create(int fd, const struct pipe_screen_config *config,
+ struct renderonly *ro)
{
struct v3d_screen *screen = rzalloc(NULL, struct v3d_screen);
struct pipe_screen *pscreen;
v3d_simulator_init(screen);
#endif
- if (!v3d_get_device_info(screen))
+ if (!v3d_get_device_info(screen->fd, &screen->devinfo, &v3d_ioctl))
goto fail;
+ /* 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. */
+ screen->has_csd = v3d_has_feature(screen, DRM_V3D_PARAM_SUPPORTS_CSD);
+ screen->has_cache_flush =
+ v3d_has_feature(screen, DRM_V3D_PARAM_SUPPORTS_CACHE_FLUSH);
v3d_fence_init(screen);
projects / mesa.git / blobdiff