#include "pipe/p_defines.h"
#include "util/u_blit.h"
#include "util/u_memory.h"
-#include "util/u_format.h"
+#include "util/format/u_format.h"
#include "util/u_inlines.h"
#include "util/u_surface.h"
+#include "util/u_transfer_helper.h"
#include "util/u_upload_mgr.h"
+#include "util/u_drm.h"
-#include "drm_fourcc.h"
-#include "vc4_drm.h"
+#include "drm-uapi/drm_fourcc.h"
+#include "drm-uapi/vc4_drm.h"
#include "vc4_screen.h"
#include "vc4_context.h"
#include "vc4_resource.h"
struct vc4_transfer *trans = vc4_transfer(ptrans);
if (trans->map) {
- struct vc4_resource *rsc;
- struct vc4_resource_slice *slice;
- if (trans->ss_resource) {
- rsc = vc4_resource(trans->ss_resource);
- slice = &rsc->slices[0];
- } else {
- rsc = vc4_resource(ptrans->resource);
- slice = &rsc->slices[ptrans->level];
- }
+ struct vc4_resource *rsc = vc4_resource(ptrans->resource);
+ struct vc4_resource_slice *slice = &rsc->slices[ptrans->level];
if (ptrans->usage & PIPE_TRANSFER_WRITE) {
vc4_store_tiled_image(rsc->bo->map + slice->offset +
free(trans->map);
}
- if (trans->ss_resource && (ptrans->usage & PIPE_TRANSFER_WRITE)) {
- struct pipe_blit_info blit;
- memset(&blit, 0, sizeof(blit));
-
- blit.src.resource = trans->ss_resource;
- blit.src.format = trans->ss_resource->format;
- blit.src.box.width = trans->ss_box.width;
- blit.src.box.height = trans->ss_box.height;
- blit.src.box.depth = 1;
-
- blit.dst.resource = ptrans->resource;
- blit.dst.format = ptrans->resource->format;
- blit.dst.level = ptrans->level;
- blit.dst.box = trans->ss_box;
-
- blit.mask = util_format_get_mask(ptrans->resource->format);
- blit.filter = PIPE_TEX_FILTER_NEAREST;
-
- pctx->blit(pctx, &blit);
-
- pipe_resource_reference(&trans->ss_resource, NULL);
- }
-
pipe_resource_reference(&ptrans->resource, NULL);
slab_free(&vc4->transfer_pool, ptrans);
}
-static struct pipe_resource *
-vc4_get_temp_resource(struct pipe_context *pctx,
- struct pipe_resource *prsc,
- const struct pipe_box *box)
-{
- struct pipe_resource temp_setup;
-
- memset(&temp_setup, 0, sizeof(temp_setup));
- temp_setup.target = prsc->target;
- temp_setup.format = prsc->format;
- temp_setup.width0 = box->width;
- temp_setup.height0 = box->height;
- temp_setup.depth0 = 1;
- temp_setup.array_size = 1;
-
- return pctx->screen->resource_create(pctx->screen, &temp_setup);
-}
-
static void *
vc4_resource_transfer_map(struct pipe_context *pctx,
struct pipe_resource *prsc,
*/
if ((usage & PIPE_TRANSFER_DISCARD_RANGE) &&
!(usage & PIPE_TRANSFER_UNSYNCHRONIZED) &&
- !(prsc->flags & PIPE_RESOURCE_FLAG_MAP_COHERENT) &&
+ !(prsc->flags & PIPE_RESOURCE_FLAG_MAP_PERSISTENT) &&
prsc->last_level == 0 &&
prsc->width0 == box->width &&
prsc->height0 == box->height &&
ptrans->usage = usage;
ptrans->box = *box;
- /* If the resource is multisampled, we need to resolve to single
- * sample. This seems like it should be handled at a higher layer.
- */
- if (prsc->nr_samples > 1) {
- trans->ss_resource = vc4_get_temp_resource(pctx, prsc, box);
- if (!trans->ss_resource)
- goto fail;
- assert(!trans->ss_resource->nr_samples);
-
- /* The ptrans->box gets modified for tile alignment, so save
- * the original box for unmap time.
- */
- trans->ss_box = *box;
-
- if (usage & PIPE_TRANSFER_READ) {
- struct pipe_blit_info blit;
- memset(&blit, 0, sizeof(blit));
-
- blit.src.resource = ptrans->resource;
- blit.src.format = ptrans->resource->format;
- blit.src.level = ptrans->level;
- blit.src.box = trans->ss_box;
-
- blit.dst.resource = trans->ss_resource;
- blit.dst.format = trans->ss_resource->format;
- blit.dst.box.width = trans->ss_box.width;
- blit.dst.box.height = trans->ss_box.height;
- blit.dst.box.depth = 1;
-
- blit.mask = util_format_get_mask(prsc->format);
- blit.filter = PIPE_TEX_FILTER_NEAREST;
-
- pctx->blit(pctx, &blit);
- vc4_flush_jobs_writing_resource(vc4, blit.dst.resource);
- }
-
- /* The rest of the mapping process should use our temporary. */
- prsc = trans->ss_resource;
- rsc = vc4_resource(prsc);
- ptrans->box.x = 0;
- ptrans->box.y = 0;
- ptrans->box.z = 0;
- }
-
if (usage & PIPE_TRANSFER_UNSYNCHRONIZED)
buf = vc4_bo_map_unsynchronized(rsc->bo);
else
struct vc4_resource_slice *slice = &rsc->slices[level];
if (rsc->tiled) {
- uint32_t utile_w = vc4_utile_width(rsc->cpp);
- uint32_t utile_h = vc4_utile_height(rsc->cpp);
-
/* No direct mappings of tiled, since we need to manually
* tile/untile.
*/
ptrans->box.height = (ptrans->box.height + 3) >> 2;
}
- /* We need to align the box to utile boundaries, since that's
- * what load/store operates on. This may cause us to need to
- * read out the original contents in that border area. Right
- * now we just read out the entire contents, including the
- * middle area that will just get overwritten.
- */
- uint32_t box_start_x = ptrans->box.x & (utile_w - 1);
- uint32_t box_start_y = ptrans->box.y & (utile_h - 1);
- bool needs_load = (usage & PIPE_TRANSFER_READ) != 0;
-
- if (box_start_x) {
- ptrans->box.width += box_start_x;
- ptrans->box.x -= box_start_x;
- needs_load = true;
- }
- if (box_start_y) {
- ptrans->box.height += box_start_y;
- ptrans->box.y -= box_start_y;
- needs_load = true;
- }
- if (ptrans->box.width & (utile_w - 1)) {
- /* We only need to force a load if our border region
- * we're extending into is actually part of the
- * texture.
- */
- uint32_t slice_width = u_minify(prsc->width0, level);
- if (ptrans->box.x + ptrans->box.width != slice_width)
- needs_load = true;
- ptrans->box.width = align(ptrans->box.width, utile_w);
- }
- if (ptrans->box.height & (utile_h - 1)) {
- uint32_t slice_height = u_minify(prsc->height0, level);
- if (ptrans->box.y + ptrans->box.height != slice_height)
- needs_load = true;
- ptrans->box.height = align(ptrans->box.height, utile_h);
- }
-
ptrans->stride = ptrans->box.width * rsc->cpp;
ptrans->layer_stride = ptrans->stride * ptrans->box.height;
trans->map = malloc(ptrans->layer_stride * ptrans->box.depth);
- if (needs_load) {
+ if (usage & PIPE_TRANSFER_READ) {
vc4_load_tiled_image(trans->map, ptrans->stride,
buf + slice->offset +
ptrans->box.z * rsc->cube_map_stride,
slice->tiling, rsc->cpp,
&ptrans->box);
}
- return (trans->map +
- box_start_x * rsc->cpp +
- box_start_y * ptrans->stride);
+ return trans->map;
} else {
ptrans->stride = slice->stride;
ptrans->layer_stride = ptrans->stride;
return NULL;
}
+static void
+vc4_texture_subdata(struct pipe_context *pctx,
+ struct pipe_resource *prsc,
+ unsigned level,
+ unsigned usage,
+ const struct pipe_box *box,
+ const void *data,
+ unsigned stride,
+ unsigned layer_stride)
+{
+ struct vc4_resource *rsc = vc4_resource(prsc);
+ struct vc4_resource_slice *slice = &rsc->slices[level];
+
+ /* For a direct mapping, we can just take the u_transfer path. */
+ if (!rsc->tiled ||
+ box->depth != 1 ||
+ (usage & PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE)) {
+ return u_default_texture_subdata(pctx, prsc, level, usage, box,
+ data, stride, layer_stride);
+ }
+
+ /* Otherwise, map and store the texture data directly into the tiled
+ * texture.
+ */
+ void *buf;
+ if (usage & PIPE_TRANSFER_UNSYNCHRONIZED)
+ buf = vc4_bo_map_unsynchronized(rsc->bo);
+ else
+ buf = vc4_bo_map(rsc->bo);
+
+ vc4_store_tiled_image(buf + slice->offset +
+ box->z * rsc->cube_map_stride,
+ slice->stride,
+ (void *)data, stride,
+ slice->tiling, rsc->cpp,
+ box);
+}
+
static void
vc4_resource_destroy(struct pipe_screen *pscreen,
struct pipe_resource *prsc)
free(rsc);
}
-static boolean
+static bool
vc4_resource_get_handle(struct pipe_screen *pscreen,
struct pipe_context *pctx,
struct pipe_resource *prsc,
whandle->modifier = DRM_FORMAT_MOD_LINEAR;
switch (whandle->type) {
- case DRM_API_HANDLE_TYPE_SHARED:
+ case WINSYS_HANDLE_TYPE_SHARED:
if (screen->ro) {
/* This could probably be supported, assuming that a
* control node was used for pl111.
*/
fprintf(stderr, "flink unsupported with pl111\n");
- return FALSE;
+ return false;
}
return vc4_bo_flink(rsc->bo, &whandle->handle);
- case DRM_API_HANDLE_TYPE_KMS:
- if (screen->ro && renderonly_get_handle(rsc->scanout, whandle))
- return TRUE;
+ case WINSYS_HANDLE_TYPE_KMS:
+ if (screen->ro) {
+ assert(rsc->scanout);
+ return renderonly_get_handle(rsc->scanout, whandle);
+ }
whandle->handle = rsc->bo->handle;
- return TRUE;
- case DRM_API_HANDLE_TYPE_FD:
+ return true;
+ case WINSYS_HANDLE_TYPE_FD:
/* FDs are cross-device, so we can export directly from vc4.
*/
whandle->handle = vc4_bo_get_dmabuf(rsc->bo);
return whandle->handle != -1;
}
- return FALSE;
+ return false;
}
static void
return format;
}
-static bool
-find_modifier(uint64_t needle, const uint64_t *haystack, int count)
-{
- int i;
-
- for (i = 0; i < count; i++) {
- if (haystack[i] == needle)
- return true;
- }
-
- return false;
-}
-
static struct pipe_resource *
vc4_resource_create_with_modifiers(struct pipe_screen *pscreen,
const struct pipe_resource *tmpl,
struct vc4_screen *screen = vc4_screen(pscreen);
struct vc4_resource *rsc = vc4_resource_setup(pscreen, tmpl);
struct pipe_resource *prsc = &rsc->base;
- bool linear_ok = find_modifier(DRM_FORMAT_MOD_LINEAR, modifiers, count);
+ bool linear_ok = drm_find_modifier(DRM_FORMAT_MOD_LINEAR, modifiers, count);
/* Use a tiled layout if we can, for better 3D performance. */
bool should_tile = true;
linear_ok = true;
rsc->tiled = should_tile;
} else if (should_tile &&
- find_modifier(DRM_FORMAT_MOD_BROADCOM_VC4_T_TILED,
+ drm_find_modifier(DRM_FORMAT_MOD_BROADCOM_VC4_T_TILED,
modifiers, count)) {
rsc->tiled = true;
} else if (linear_ok) {
goto fail;
}
- if (screen->ro && tmpl->bind & PIPE_BIND_SCANOUT) {
+ /* Set up the "scanout resource" (the dmabuf export of our buffer to
+ * the KMS handle) if the buffer might ever have
+ * resource_get_handle(WINSYS_HANDLE_TYPE_KMS) called on it.
+ * create_with_modifiers() doesn't give us usage flags, so we have to
+ * assume that all calls with modifiers are scanout-possible.
+ */
+ if (screen->ro &&
+ ((tmpl->bind & PIPE_BIND_SCANOUT) ||
+ !(count == 1 && modifiers[0] == DRM_FORMAT_MOD_INVALID))) {
rsc->scanout =
renderonly_scanout_for_resource(prsc, screen->ro, NULL);
if (!rsc->scanout)
return NULL;
switch (whandle->type) {
- case DRM_API_HANDLE_TYPE_SHARED:
- rsc->bo = vc4_bo_open_name(screen,
- whandle->handle, whandle->stride);
+ case WINSYS_HANDLE_TYPE_SHARED:
+ rsc->bo = vc4_bo_open_name(screen, whandle->handle);
break;
- case DRM_API_HANDLE_TYPE_FD:
- rsc->bo = vc4_bo_open_dmabuf(screen,
- whandle->handle, whandle->stride);
+ case WINSYS_HANDLE_TYPE_FD:
+ rsc->bo = vc4_bo_open_dmabuf(screen, whandle->handle);
break;
default:
fprintf(stderr,
vc4_update_shadow_baselevel_texture(struct pipe_context *pctx,
struct pipe_sampler_view *pview)
{
+ struct vc4_context *vc4 = vc4_context(pctx);
struct vc4_sampler_view *view = vc4_sampler_view(pview);
struct vc4_resource *shadow = vc4_resource(view->texture);
struct vc4_resource *orig = vc4_resource(pview->texture);
return shadow_rsc;
}
+static const struct u_transfer_vtbl transfer_vtbl = {
+ .resource_create = vc4_resource_create,
+ .resource_destroy = vc4_resource_destroy,
+ .transfer_map = vc4_resource_transfer_map,
+ .transfer_unmap = vc4_resource_transfer_unmap,
+ .transfer_flush_region = u_default_transfer_flush_region,
+};
+
void
vc4_resource_screen_init(struct pipe_screen *pscreen)
{
pscreen->resource_destroy = u_resource_destroy_vtbl;
pscreen->resource_get_handle = vc4_resource_get_handle;
pscreen->resource_destroy = vc4_resource_destroy;
+ pscreen->transfer_helper = u_transfer_helper_create(&transfer_vtbl,
+ false, false,
+ false, true);
/* Test if the kernel has GET_TILING; it will return -EINVAL if the
* ioctl does not exist, but -ENOENT if we pass an impossible handle.
void
vc4_resource_context_init(struct pipe_context *pctx)
{
- pctx->transfer_map = vc4_resource_transfer_map;
- pctx->transfer_flush_region = u_default_transfer_flush_region;
- pctx->transfer_unmap = vc4_resource_transfer_unmap;
+ pctx->transfer_map = u_transfer_helper_transfer_map;
+ pctx->transfer_flush_region = u_transfer_helper_transfer_flush_region;
+ pctx->transfer_unmap = u_transfer_helper_transfer_unmap;
pctx->buffer_subdata = u_default_buffer_subdata;
- pctx->texture_subdata = u_default_texture_subdata;
+ pctx->texture_subdata = vc4_texture_subdata;
pctx->create_surface = vc4_create_surface;
pctx->surface_destroy = vc4_surface_destroy;
pctx->resource_copy_region = util_resource_copy_region;