#include "util/u_inlines.h"
#include "util/u_memory.h"
+#include "drm-uapi/drm_fourcc.h"
+
+#ifndef DRM_FORMAT_MOD_INVALID
+#define DRM_FORMAT_MOD_INVALID ((1ULL<<56) - 1)
+#endif
+
+static enum etna_surface_layout modifier_to_layout(uint64_t modifier)
+{
+ switch (modifier) {
+ case DRM_FORMAT_MOD_VIVANTE_TILED:
+ return ETNA_LAYOUT_TILED;
+ case DRM_FORMAT_MOD_VIVANTE_SUPER_TILED:
+ return ETNA_LAYOUT_SUPER_TILED;
+ case DRM_FORMAT_MOD_VIVANTE_SPLIT_TILED:
+ return ETNA_LAYOUT_MULTI_TILED;
+ case DRM_FORMAT_MOD_VIVANTE_SPLIT_SUPER_TILED:
+ return ETNA_LAYOUT_MULTI_SUPERTILED;
+ case DRM_FORMAT_MOD_LINEAR:
+ default:
+ return ETNA_LAYOUT_LINEAR;
+ }
+}
+
+static uint64_t layout_to_modifier(enum etna_surface_layout layout)
+{
+ switch (layout) {
+ case ETNA_LAYOUT_TILED:
+ return DRM_FORMAT_MOD_VIVANTE_TILED;
+ case ETNA_LAYOUT_SUPER_TILED:
+ return DRM_FORMAT_MOD_VIVANTE_SUPER_TILED;
+ case ETNA_LAYOUT_MULTI_TILED:
+ return DRM_FORMAT_MOD_VIVANTE_SPLIT_TILED;
+ case ETNA_LAYOUT_MULTI_SUPERTILED:
+ return DRM_FORMAT_MOD_VIVANTE_SPLIT_SUPER_TILED;
+ case ETNA_LAYOUT_LINEAR:
+ return DRM_FORMAT_MOD_LINEAR;
+ default:
+ return DRM_FORMAT_MOD_INVALID;
+ }
+}
+
/* A tile is 4x4 pixels, having 'screen->specs.bits_per_tile' of tile status.
* So, in a buffer of N pixels, there are N / (4 * 4) tiles.
* We need N * screen->specs.bits_per_tile / (4 * 4) bits of tile status, or
return size;
}
+/* Is rs alignment needed? */
+static bool is_rs_align(struct etna_screen *screen,
+ const struct pipe_resource *tmpl)
+{
+ return screen->specs.use_blt ? false : (
+ VIV_FEATURE(screen, chipMinorFeatures1, TEXTURE_HALIGN) ||
+ !etna_resource_sampler_only(tmpl));
+}
+
/* Create a new resource object, using the given template info */
struct pipe_resource *
etna_resource_alloc(struct pipe_screen *pscreen, unsigned layout,
+ enum etna_resource_addressing_mode mode, uint64_t modifier,
const struct pipe_resource *templat)
{
struct etna_screen *screen = etna_screen(pscreen);
+ struct etna_resource *rsc;
unsigned size;
DBG_F(ETNA_DBG_RESOURCE_MSGS,
return NULL;
}
- /* If we have the TEXTURE_HALIGN feature, we can always align to the
- * resolve engine's width. If not, we must not align resources used
- * only for textures. */
- bool rs_align = VIV_FEATURE(screen, chipMinorFeatures1, TEXTURE_HALIGN) ||
- !etna_resource_sampler_only(templat);
-
/* Determine needed padding (alignment of height/width) */
unsigned paddingX = 0, paddingY = 0;
unsigned halign = TEXTURE_HALIGN_FOUR;
- etna_layout_multiple(layout, screen->specs.pixel_pipes, rs_align, &paddingX,
- &paddingY, &halign);
- assert(paddingX && paddingY);
+ if (!util_format_is_compressed(templat->format)) {
+ /* If we have the TEXTURE_HALIGN feature, we can always align to the
+ * resolve engine's width. If not, we must not align resources used
+ * only for textures. If this GPU uses the BLT engine, never do RS align.
+ */
+ etna_layout_multiple(layout, screen->specs.pixel_pipes,
+ is_rs_align (screen, templat),
+ &paddingX, &paddingY, &halign);
+ assert(paddingX && paddingY);
+ } else {
+ /* Compressed textures are padded to their block size, but we don't have
+ * to do anything special for that. */
+ paddingX = 1;
+ paddingY = 1;
+ }
- if (templat->target != PIPE_BUFFER)
+ if (!screen->specs.use_blt && templat->target != PIPE_BUFFER)
etna_adjust_rs_align(screen->specs.pixel_pipes, NULL, &paddingY);
- struct etna_resource *rsc = CALLOC_STRUCT(etna_resource);
+ if (templat->bind & PIPE_BIND_SCANOUT) {
+ struct pipe_resource scanout_templat = *templat;
+ struct renderonly_scanout *scanout;
+ struct winsys_handle handle;
+
+ /* pad scanout buffer size to be compatible with the RS */
+ if (!screen->specs.use_blt && modifier == DRM_FORMAT_MOD_LINEAR)
+ etna_adjust_rs_align(screen->specs.pixel_pipes, &paddingX, &paddingY);
+
+ scanout_templat.width0 = align(scanout_templat.width0, paddingX);
+ scanout_templat.height0 = align(scanout_templat.height0, paddingY);
+
+ scanout = renderonly_scanout_for_resource(&scanout_templat,
+ screen->ro, &handle);
+ if (!scanout)
+ return NULL;
+
+ assert(handle.type == WINSYS_HANDLE_TYPE_FD);
+ handle.modifier = modifier;
+ rsc = etna_resource(pscreen->resource_from_handle(pscreen, templat,
+ &handle,
+ PIPE_HANDLE_USAGE_FRAMEBUFFER_WRITE));
+ close(handle.handle);
+ if (!rsc)
+ return NULL;
+ rsc->scanout = scanout;
+
+ return &rsc->base;
+ }
+
+ rsc = CALLOC_STRUCT(etna_resource);
if (!rsc)
return NULL;
rsc->base.nr_samples = nr_samples;
rsc->layout = layout;
rsc->halign = halign;
+ rsc->addressing_mode = mode;
pipe_reference_init(&rsc->base.reference, 1);
list_inithead(&rsc->list);
rsc->bo = bo;
rsc->ts_bo = 0; /* TS is only created when first bound to surface */
- if (templat->bind & PIPE_BIND_SCANOUT) {
- struct pipe_resource scanout_templat = *templat;
- struct winsys_handle handle;
-
- /* pad scanout buffer size to be compatible with the RS */
- etna_adjust_rs_align(screen->specs.pixel_pipes,
- &scanout_templat.width0, &scanout_templat.height0);
-
- rsc->scanout = renderonly_scanout_for_resource(&scanout_templat,
- screen->ro, &handle);
- if (!rsc->scanout)
- goto free_rsc;
-
- rsc->external = pscreen->resource_from_handle(pscreen, &rsc->base,
- &handle,
- PIPE_HANDLE_USAGE_WRITE);
- close(handle.handle);
- if (!rsc->external)
- goto free_rsc;
- }
-
if (DBG_ENABLED(ETNA_DBG_ZERO)) {
void *map = etna_bo_map(bo);
memset(map, 0, size);
{
struct etna_screen *screen = etna_screen(pscreen);
- /* Figure out what tiling to use -- for now, assume that texture cannot be linear.
- * there is a capability LINEAR_TEXTURE_SUPPORT (supported on gc880 and
- * gc2000 at least), but not sure how it works.
+ /* Figure out what tiling and address mode to use -- for now, assume that
+ * texture cannot be linear. there is a capability LINEAR_TEXTURE_SUPPORT
+ * (supported on gc880 and gc2000 at least), but not sure how it works.
* Buffers always have LINEAR layout.
*/
unsigned layout = ETNA_LAYOUT_LINEAR;
+ enum etna_resource_addressing_mode mode = ETNA_ADDRESSING_MODE_TILED;
+
if (etna_resource_sampler_only(templat)) {
/* The buffer is only used for texturing, so create something
* directly compatible with the sampler. Such a buffer can
if (templat->target == PIPE_TEXTURE_3D)
layout = ETNA_LAYOUT_LINEAR;
- return etna_resource_alloc(pscreen, layout, templat);
+ /* modifier is only used for scanout surfaces, so safe to use LINEAR here */
+ return etna_resource_alloc(pscreen, layout, mode, DRM_FORMAT_MOD_LINEAR, templat);
+}
+
+enum modifier_priority {
+ MODIFIER_PRIORITY_INVALID = 0,
+ MODIFIER_PRIORITY_LINEAR,
+ MODIFIER_PRIORITY_SPLIT_TILED,
+ MODIFIER_PRIORITY_SPLIT_SUPER_TILED,
+ MODIFIER_PRIORITY_TILED,
+ MODIFIER_PRIORITY_SUPER_TILED,
+};
+
+const uint64_t priority_to_modifier[] = {
+ [MODIFIER_PRIORITY_INVALID] = DRM_FORMAT_MOD_INVALID,
+ [MODIFIER_PRIORITY_LINEAR] = DRM_FORMAT_MOD_LINEAR,
+ [MODIFIER_PRIORITY_SPLIT_TILED] = DRM_FORMAT_MOD_VIVANTE_SPLIT_TILED,
+ [MODIFIER_PRIORITY_SPLIT_SUPER_TILED] = DRM_FORMAT_MOD_VIVANTE_SPLIT_SUPER_TILED,
+ [MODIFIER_PRIORITY_TILED] = DRM_FORMAT_MOD_VIVANTE_TILED,
+ [MODIFIER_PRIORITY_SUPER_TILED] = DRM_FORMAT_MOD_VIVANTE_SUPER_TILED,
+};
+
+static uint64_t
+select_best_modifier(const struct etna_screen * screen,
+ const uint64_t *modifiers, const unsigned count)
+{
+ enum modifier_priority prio = MODIFIER_PRIORITY_INVALID;
+
+ for (int i = 0; i < count; i++) {
+ switch (modifiers[i]) {
+ case DRM_FORMAT_MOD_VIVANTE_SUPER_TILED:
+ if ((screen->specs.pixel_pipes > 1 && !screen->specs.single_buffer) ||
+ !screen->specs.can_supertile)
+ break;
+ prio = MAX2(prio, MODIFIER_PRIORITY_SUPER_TILED);
+ break;
+ case DRM_FORMAT_MOD_VIVANTE_TILED:
+ if (screen->specs.pixel_pipes > 1 && !screen->specs.single_buffer)
+ break;
+ prio = MAX2(prio, MODIFIER_PRIORITY_TILED);
+ break;
+ case DRM_FORMAT_MOD_VIVANTE_SPLIT_SUPER_TILED:
+ if ((screen->specs.pixel_pipes < 2) || !screen->specs.can_supertile)
+ break;
+ prio = MAX2(prio, MODIFIER_PRIORITY_SPLIT_SUPER_TILED);
+ break;
+ case DRM_FORMAT_MOD_VIVANTE_SPLIT_TILED:
+ if (screen->specs.pixel_pipes < 2)
+ break;
+ prio = MAX2(prio, MODIFIER_PRIORITY_SPLIT_TILED);
+ break;
+ case DRM_FORMAT_MOD_LINEAR:
+ prio = MAX2(prio, MODIFIER_PRIORITY_LINEAR);
+ break;
+ case DRM_FORMAT_MOD_INVALID:
+ default:
+ break;
+ }
+ }
+
+ return priority_to_modifier[prio];
+}
+
+static struct pipe_resource *
+etna_resource_create_modifiers(struct pipe_screen *pscreen,
+ const struct pipe_resource *templat,
+ const uint64_t *modifiers, int count)
+{
+ struct etna_screen *screen = etna_screen(pscreen);
+ struct pipe_resource tmpl = *templat;
+ uint64_t modifier = select_best_modifier(screen, modifiers, count);
+
+ if (modifier == DRM_FORMAT_MOD_INVALID)
+ return NULL;
+
+ /*
+ * We currently assume that all buffers allocated through this interface
+ * should be scanout enabled.
+ */
+ tmpl.bind |= PIPE_BIND_SCANOUT;
+
+ return etna_resource_alloc(pscreen, modifier_to_layout(modifier),
+ ETNA_ADDRESSING_MODE_TILED, modifier, &tmpl);
}
static void
{
struct etna_resource *res = etna_resource(prsc);
- res->seqno++;
+ if (res->external)
+ etna_resource(res->external)->seqno++;
+ else
+ res->seqno++;
}
static void
goto fail;
rsc->seqno = 1;
+ rsc->layout = modifier_to_layout(handle->modifier);
+ rsc->halign = TEXTURE_HALIGN_FOUR;
+ rsc->addressing_mode = ETNA_ADDRESSING_MODE_TILED;
+
level->width = tmpl->width0;
level->height = tmpl->height0;
- /* We will be using the RS to copy with this resource, so we must
- * ensure that it is appropriately aligned for the RS requirements. */
- level->padded_width = level->width;
- level->padded_height = level->height;
- etna_adjust_rs_align(&level->padded_width, &level->padded_height);
+ /* Determine padding of the imported resource. */
+ unsigned paddingX = 0, paddingY = 0;
+ etna_layout_multiple(rsc->layout, screen->specs.pixel_pipes,
+ is_rs_align(screen, tmpl),
+ &paddingX, &paddingY, &rsc->halign);
+
+ if (!screen->specs.use_blt)
+ etna_adjust_rs_align(screen->specs.pixel_pipes, NULL, &paddingY);
+ level->padded_width = align(level->width, paddingX);
+ level->padded_height = align(level->height, paddingY);
level->layer_stride = level->stride * util_format_get_nblocksy(prsc->format,
level->padded_height);
+ level->size = level->layer_stride;
/* The DDX must give us a BO which conforms to our padding size.
* The stride of the BO must be greater or equal to our padded
* stride. The size of the BO must accomodate the padded height. */
if (level->stride < util_format_get_stride(tmpl->format, level->padded_width)) {
- BUG("BO stride is too small for RS engine width padding");
+ BUG("BO stride %u is too small for RS engine width padding (%zu, format %s)",
+ level->stride, util_format_get_stride(tmpl->format, level->padded_width),
+ util_format_name(tmpl->format));
goto fail;
}
if (etna_bo_size(rsc->bo) < level->stride * level->padded_height) {
- BUG("BO size is too small for RS engine height padding");
+ BUG("BO size %u is too small for RS engine height padding (%u, format %s)",
+ etna_bo_size(rsc->bo), level->stride * level->padded_height,
+ util_format_name(tmpl->format));
goto fail;
}
- if (handle->type == DRM_API_HANDLE_TYPE_SHARED && tmpl->bind & PIPE_BIND_RENDER_TARGET) {
- /* Render targets are linear in Xorg but must be tiled
- * here. It would be nice if dri_drawable_get_format()
- * set scanout for these buffers too. */
+ if (rsc->layout == ETNA_LAYOUT_LINEAR) {
+ /*
+ * Both sampler and pixel pipes can't handle linear, create a compatible
+ * base resource, where we can attach the imported buffer as an external
+ * resource.
+ */
+ struct pipe_resource tiled_templat = *tmpl;
+
+ /*
+ * Remove BIND_SCANOUT to avoid recursion, as etna_resource_create uses
+ * this function to import the scanout buffer and get a tiled resource.
+ */
+ tiled_templat.bind &= ~PIPE_BIND_SCANOUT;
- ptiled = etna_resource_create(pscreen, tmpl);
+ ptiled = etna_resource_create(pscreen, &tiled_templat);
if (!ptiled)
goto fail;
if (rsc->external)
rsc = etna_resource(rsc->external);
- if (handle->type == DRM_API_HANDLE_TYPE_KMS &&
- renderonly_get_handle(scanout, handle))
+ handle->stride = rsc->levels[0].stride;
+ handle->modifier = layout_to_modifier(rsc->layout);
+
+ if (handle->type == WINSYS_HANDLE_TYPE_SHARED) {
+ return etna_bo_get_name(rsc->bo, &handle->handle) == 0;
+ } else if (handle->type == WINSYS_HANDLE_TYPE_KMS) {
+ if (renderonly_get_handle(scanout, handle)) {
+ return TRUE;
+ } else {
+ handle->handle = etna_bo_handle(rsc->bo);
+ return TRUE;
+ }
+ } else if (handle->type == WINSYS_HANDLE_TYPE_FD) {
+ handle->handle = etna_bo_dmabuf(rsc->bo);
return TRUE;
-
- return etna_screen_bo_get_handle(pscreen, rsc->bo, rsc->levels[0].stride,
- handle);
+ } else {
+ return FALSE;
+ }
}
void
rsc->pending_ctx = ctx;
}
+bool
+etna_resource_has_valid_ts(struct etna_resource *rsc)
+{
+ if (!rsc->ts_bo)
+ return false;
+
+ for (int level = 0; level <= rsc->base.last_level; level++)
+ if (rsc->levels[level].ts_valid)
+ return true;
+
+ return false;
+}
+
void
etna_resource_screen_init(struct pipe_screen *pscreen)
{
pscreen->can_create_resource = etna_screen_can_create_resource;
pscreen->resource_create = etna_resource_create;
+ pscreen->resource_create_with_modifiers = etna_resource_create_modifiers;
pscreen->resource_from_handle = etna_resource_from_handle;
pscreen->resource_get_handle = etna_resource_get_handle;
pscreen->resource_changed = etna_resource_changed;