2019-02-05 04:32:27 +00:00
|
|
|
/**************************************************************************
|
|
|
|
*
|
|
|
|
* Copyright 2008 VMware, Inc.
|
|
|
|
* Copyright 2014 Broadcom
|
|
|
|
* Copyright 2018 Alyssa Rosenzweig
|
|
|
|
* All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
* copy of this software and associated documentation files (the
|
|
|
|
* "Software"), to deal in the Software without restriction, including
|
|
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
|
|
* distribute, sub license, and/or sell copies of the Software, and to
|
|
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
|
|
* the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice (including the
|
|
|
|
* next paragraph) shall be included in all copies or substantial portions
|
|
|
|
* of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
|
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
|
|
|
* IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
|
|
|
|
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
|
|
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
|
|
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
*
|
|
|
|
**************************************************************************/
|
|
|
|
|
|
|
|
#include <xf86drm.h>
|
|
|
|
#include <fcntl.h>
|
2019-02-12 18:18:03 +00:00
|
|
|
#include "drm-uapi/drm_fourcc.h"
|
2019-02-05 04:32:27 +00:00
|
|
|
|
|
|
|
#include "state_tracker/winsys_handle.h"
|
|
|
|
#include "util/u_format.h"
|
|
|
|
#include "util/u_memory.h"
|
|
|
|
#include "util/u_surface.h"
|
|
|
|
#include "util/u_transfer.h"
|
|
|
|
#include "util/u_transfer_helper.h"
|
|
|
|
|
|
|
|
#include "pan_context.h"
|
|
|
|
#include "pan_screen.h"
|
|
|
|
#include "pan_resource.h"
|
|
|
|
#include "pan_swizzle.h"
|
2019-03-08 15:24:57 +01:00
|
|
|
#include "pan_util.h"
|
2019-02-05 04:32:27 +00:00
|
|
|
|
|
|
|
static struct pipe_resource *
|
|
|
|
panfrost_resource_from_handle(struct pipe_screen *pscreen,
|
|
|
|
const struct pipe_resource *templat,
|
|
|
|
struct winsys_handle *whandle,
|
|
|
|
unsigned usage)
|
|
|
|
{
|
|
|
|
struct panfrost_screen *screen = pan_screen(pscreen);
|
|
|
|
struct panfrost_resource *rsc;
|
|
|
|
struct pipe_resource *prsc;
|
|
|
|
|
|
|
|
assert(whandle->type == WINSYS_HANDLE_TYPE_FD);
|
|
|
|
|
|
|
|
rsc = CALLOC_STRUCT(panfrost_resource);
|
|
|
|
if (!rsc)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
prsc = &rsc->base;
|
|
|
|
|
|
|
|
*prsc = *templat;
|
|
|
|
|
|
|
|
pipe_reference_init(&prsc->reference, 1);
|
|
|
|
prsc->screen = pscreen;
|
|
|
|
|
|
|
|
rsc->bo = screen->driver->import_bo(screen, whandle);
|
2019-03-21 02:54:38 +00:00
|
|
|
rsc->bo->slices[0].stride = whandle->stride;
|
2019-02-05 04:32:27 +00:00
|
|
|
|
2019-03-08 10:27:07 +01:00
|
|
|
if (screen->ro) {
|
|
|
|
rsc->scanout =
|
|
|
|
renderonly_create_gpu_import_for_resource(prsc, screen->ro, NULL);
|
|
|
|
/* failure is expected in some cases.. */
|
|
|
|
}
|
|
|
|
|
2019-02-05 04:32:27 +00:00
|
|
|
return prsc;
|
|
|
|
}
|
|
|
|
|
|
|
|
static boolean
|
|
|
|
panfrost_resource_get_handle(struct pipe_screen *pscreen,
|
|
|
|
struct pipe_context *ctx,
|
|
|
|
struct pipe_resource *pt,
|
|
|
|
struct winsys_handle *handle,
|
|
|
|
unsigned usage)
|
|
|
|
{
|
|
|
|
struct panfrost_screen *screen = pan_screen(pscreen);
|
|
|
|
struct panfrost_resource *rsrc = (struct panfrost_resource *) pt;
|
|
|
|
struct renderonly_scanout *scanout = rsrc->scanout;
|
|
|
|
|
|
|
|
handle->modifier = DRM_FORMAT_MOD_INVALID;
|
|
|
|
|
2019-03-08 10:27:07 +01:00
|
|
|
if (handle->type == WINSYS_HANDLE_TYPE_SHARED) {
|
|
|
|
return FALSE;
|
|
|
|
} else if (handle->type == WINSYS_HANDLE_TYPE_KMS) {
|
|
|
|
if (renderonly_get_handle(scanout, handle))
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
handle->handle = rsrc->bo->gem_handle;
|
2019-03-21 02:54:38 +00:00
|
|
|
handle->stride = rsrc->bo->slices[0].stride;
|
2019-03-08 10:27:07 +01:00
|
|
|
return TRUE;
|
|
|
|
} else if (handle->type == WINSYS_HANDLE_TYPE_FD) {
|
2019-02-05 04:32:27 +00:00
|
|
|
if (scanout) {
|
|
|
|
struct drm_prime_handle args = {
|
|
|
|
.handle = scanout->handle,
|
|
|
|
.flags = DRM_CLOEXEC,
|
|
|
|
};
|
|
|
|
|
|
|
|
int ret = drmIoctl(screen->ro->kms_fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &args);
|
|
|
|
if (ret == -1)
|
|
|
|
return FALSE;
|
|
|
|
|
2019-03-18 16:07:00 +00:00
|
|
|
handle->stride = scanout->stride;
|
2019-02-05 04:32:27 +00:00
|
|
|
handle->handle = args.fd;
|
|
|
|
|
|
|
|
return TRUE;
|
2019-03-08 10:27:07 +01:00
|
|
|
} else
|
2019-03-21 02:54:38 +00:00
|
|
|
return screen->driver->export_bo(screen, rsrc->bo->gem_handle, rsrc->bo->slices[0].stride, handle);
|
2019-03-08 10:27:07 +01:00
|
|
|
}
|
2019-02-05 04:32:27 +00:00
|
|
|
|
2019-03-08 10:27:07 +01:00
|
|
|
return FALSE;
|
2019-02-05 04:32:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
panfrost_flush_resource(struct pipe_context *pctx, struct pipe_resource *prsc)
|
|
|
|
{
|
2019-03-08 15:24:57 +01:00
|
|
|
//DBG("TODO %s\n", __func__);
|
2019-02-05 04:32:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
panfrost_blit(struct pipe_context *pipe,
|
|
|
|
const struct pipe_blit_info *info)
|
|
|
|
{
|
2019-03-21 02:54:38 +00:00
|
|
|
if (util_try_blit_via_copy_region(pipe, info))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* TODO */
|
|
|
|
DBG("Unhandled blit.\n");
|
|
|
|
|
2019-02-05 04:32:27 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct pipe_surface *
|
|
|
|
panfrost_create_surface(struct pipe_context *pipe,
|
|
|
|
struct pipe_resource *pt,
|
|
|
|
const struct pipe_surface *surf_tmpl)
|
|
|
|
{
|
|
|
|
struct pipe_surface *ps = NULL;
|
|
|
|
|
|
|
|
ps = CALLOC_STRUCT(pipe_surface);
|
|
|
|
|
|
|
|
if (ps) {
|
|
|
|
pipe_reference_init(&ps->reference, 1);
|
|
|
|
pipe_resource_reference(&ps->texture, pt);
|
|
|
|
ps->context = pipe;
|
|
|
|
ps->format = surf_tmpl->format;
|
|
|
|
|
|
|
|
if (pt->target != PIPE_BUFFER) {
|
|
|
|
assert(surf_tmpl->u.tex.level <= pt->last_level);
|
|
|
|
ps->width = u_minify(pt->width0, surf_tmpl->u.tex.level);
|
|
|
|
ps->height = u_minify(pt->height0, surf_tmpl->u.tex.level);
|
|
|
|
ps->u.tex.level = surf_tmpl->u.tex.level;
|
|
|
|
ps->u.tex.first_layer = surf_tmpl->u.tex.first_layer;
|
|
|
|
ps->u.tex.last_layer = surf_tmpl->u.tex.last_layer;
|
|
|
|
} else {
|
|
|
|
/* setting width as number of elements should get us correct renderbuffer width */
|
|
|
|
ps->width = surf_tmpl->u.buf.last_element - surf_tmpl->u.buf.first_element + 1;
|
|
|
|
ps->height = pt->height0;
|
|
|
|
ps->u.buf.first_element = surf_tmpl->u.buf.first_element;
|
|
|
|
ps->u.buf.last_element = surf_tmpl->u.buf.last_element;
|
|
|
|
assert(ps->u.buf.first_element <= ps->u.buf.last_element);
|
|
|
|
assert(ps->u.buf.last_element < ps->width);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ps;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
panfrost_surface_destroy(struct pipe_context *pipe,
|
|
|
|
struct pipe_surface *surf)
|
|
|
|
{
|
|
|
|
assert(surf->texture);
|
|
|
|
pipe_resource_reference(&surf->texture, NULL);
|
|
|
|
free(surf);
|
|
|
|
}
|
|
|
|
|
2019-03-21 02:54:38 +00:00
|
|
|
static void
|
|
|
|
panfrost_setup_slices(const struct pipe_resource *tmpl, struct panfrost_bo *bo)
|
2019-02-07 06:00:11 +00:00
|
|
|
{
|
2019-03-21 02:54:38 +00:00
|
|
|
unsigned width = tmpl->width0;
|
|
|
|
unsigned height = tmpl->height0;
|
|
|
|
unsigned bytes_per_pixel = util_format_get_blocksize(tmpl->format);
|
2019-02-14 04:00:19 +00:00
|
|
|
|
2019-03-21 02:54:38 +00:00
|
|
|
unsigned offset = 0;
|
2019-02-14 04:00:19 +00:00
|
|
|
|
2019-03-21 02:54:38 +00:00
|
|
|
for (unsigned l = 0; l <= tmpl->last_level; ++l) {
|
|
|
|
struct panfrost_slice *slice = &bo->slices[l];
|
2019-02-07 06:00:11 +00:00
|
|
|
|
2019-03-21 02:54:38 +00:00
|
|
|
unsigned effective_width = width;
|
|
|
|
unsigned effective_height = height;
|
2019-02-07 06:00:11 +00:00
|
|
|
|
2019-03-21 02:54:38 +00:00
|
|
|
/* Tiled operates blockwise; linear is packed */
|
2019-03-13 00:53:34 +00:00
|
|
|
|
2019-03-21 02:54:38 +00:00
|
|
|
if (bo->layout == PAN_TILED) {
|
|
|
|
effective_width = ALIGN(effective_width, 16);
|
|
|
|
effective_height = ALIGN(effective_height, 16);
|
|
|
|
}
|
|
|
|
|
|
|
|
slice->offset = offset;
|
2019-06-07 08:58:16 -07:00
|
|
|
|
|
|
|
/* Compute the would-be stride */
|
|
|
|
unsigned stride = bytes_per_pixel * effective_width;
|
|
|
|
|
|
|
|
/* ..but cache-line align it for performance */
|
|
|
|
stride = ALIGN(stride, 64);
|
|
|
|
slice->stride = stride;
|
2019-03-21 02:54:38 +00:00
|
|
|
|
|
|
|
offset += slice->stride * effective_height;
|
|
|
|
|
|
|
|
width = u_minify(width, 1);
|
|
|
|
height = u_minify(height, 1);
|
|
|
|
}
|
|
|
|
|
2019-03-27 04:37:26 +00:00
|
|
|
assert(tmpl->array_size);
|
|
|
|
|
|
|
|
bo->cubemap_stride = ALIGN(offset, 64);
|
|
|
|
bo->size = ALIGN(bo->cubemap_stride * tmpl->array_size, 4096);
|
2019-03-21 02:54:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct panfrost_bo *
|
|
|
|
panfrost_create_bo(struct panfrost_screen *screen, const struct pipe_resource *template)
|
|
|
|
{
|
|
|
|
struct panfrost_bo *bo = CALLOC_STRUCT(panfrost_bo);
|
panfrost: Track BO lifetime with jobs and reference counts
This (fairly large) patch continues work surrounding the panfrost_job
abstraction to improve job lifetime management. In particular, we add
infrastructure to track which BOs are used by a particular job
(currently limited to the vertex buffer BOs), to reference count these
BOs, and to automatically manage the BOs memory based on the reference
count. This set of changes serves as a code cleanup, as a way of future
proofing for allowing flushing BOs, and immediately as a bugfix to
workaround the missing reference counting for vertex buffer BOs.
Meanwhile, there are a few cleanups to vertex buffer handling code
itself, so in the short-term, this allows us to remove the costly VBO
staging workaround, since this patch addresses the underlying causes.
v2: Use pipe_reference for BO reference counting, rather than managing
it ourselves. Don't duplicate hash-table key removal. Fix vertex buffer
counting.
Signed-off-by: Alyssa Rosenzweig <alyssa@rosenzweig.io>
2019-04-14 22:42:44 +00:00
|
|
|
pipe_reference_init(&bo->reference, 1);
|
2019-03-13 00:53:34 +00:00
|
|
|
|
2019-03-07 03:52:20 +00:00
|
|
|
/* Based on the usage, figure out what storing will be used. There are
|
|
|
|
* various tradeoffs:
|
|
|
|
*
|
|
|
|
* Linear: the basic format, bad for memory bandwidth, bad for cache
|
|
|
|
* use. Zero-copy, though. Renderable.
|
|
|
|
*
|
|
|
|
* Tiled: Not compressed, but cache-optimized. Expensive to write into
|
|
|
|
* (due to software tiling), but cheap to sample from. Ideal for most
|
|
|
|
* textures.
|
|
|
|
*
|
|
|
|
* AFBC: Compressed and renderable (so always desirable for non-scanout
|
|
|
|
* rendertargets). Cheap to sample from. The format is black box, so we
|
|
|
|
* can't read/write from software.
|
|
|
|
*/
|
|
|
|
|
2019-02-14 04:00:19 +00:00
|
|
|
/* Tiling textures is almost always faster, unless we only use it once */
|
2019-03-07 03:52:20 +00:00
|
|
|
bool should_tile = (template->usage != PIPE_USAGE_STREAM) && (template->bind & PIPE_BIND_SAMPLER_VIEW);
|
|
|
|
|
2019-03-13 01:31:30 +00:00
|
|
|
/* For unclear reasons, depth/stencil is faster linear than AFBC, so
|
|
|
|
* make sure it's linear */
|
|
|
|
|
|
|
|
if (template->bind & PIPE_BIND_DEPTH_STENCIL)
|
|
|
|
should_tile = false;
|
|
|
|
|
2019-03-07 03:52:20 +00:00
|
|
|
/* Set the layout appropriately */
|
|
|
|
bo->layout = should_tile ? PAN_TILED : PAN_LINEAR;
|
2019-02-07 06:00:11 +00:00
|
|
|
|
2019-03-21 02:54:38 +00:00
|
|
|
panfrost_setup_slices(template, bo);
|
2019-02-14 04:00:19 +00:00
|
|
|
|
2019-03-21 02:54:38 +00:00
|
|
|
if (bo->layout == PAN_TILED || bo->layout == PAN_LINEAR) {
|
2019-03-08 23:36:02 +00:00
|
|
|
struct panfrost_memory mem;
|
|
|
|
|
2019-03-21 02:54:38 +00:00
|
|
|
screen->driver->allocate_slab(screen, &mem, bo->size / 4096, true, 0, 0, 0);
|
2019-03-08 23:36:02 +00:00
|
|
|
|
2019-03-21 02:54:38 +00:00
|
|
|
bo->cpu = mem.cpu;
|
|
|
|
bo->gpu = mem.gpu;
|
2019-03-11 13:35:27 +01:00
|
|
|
bo->gem_handle = mem.gem_handle;
|
2019-02-14 04:00:19 +00:00
|
|
|
}
|
2019-02-07 06:00:11 +00:00
|
|
|
|
|
|
|
return bo;
|
|
|
|
}
|
2019-02-05 04:32:27 +00:00
|
|
|
|
|
|
|
static struct pipe_resource *
|
|
|
|
panfrost_resource_create(struct pipe_screen *screen,
|
|
|
|
const struct pipe_resource *template)
|
|
|
|
{
|
|
|
|
struct panfrost_resource *so = CALLOC_STRUCT(panfrost_resource);
|
|
|
|
struct panfrost_screen *pscreen = (struct panfrost_screen *) screen;
|
|
|
|
|
|
|
|
so->base = *template;
|
|
|
|
so->base.screen = screen;
|
|
|
|
|
|
|
|
pipe_reference_init(&so->base.reference, 1);
|
|
|
|
|
|
|
|
/* Make sure we're familiar */
|
|
|
|
switch (template->target) {
|
|
|
|
case PIPE_BUFFER:
|
|
|
|
case PIPE_TEXTURE_1D:
|
|
|
|
case PIPE_TEXTURE_2D:
|
|
|
|
case PIPE_TEXTURE_3D:
|
2019-03-27 04:37:26 +00:00
|
|
|
case PIPE_TEXTURE_CUBE:
|
2019-02-05 04:32:27 +00:00
|
|
|
case PIPE_TEXTURE_RECT:
|
|
|
|
break;
|
|
|
|
default:
|
2019-03-08 15:24:57 +01:00
|
|
|
DBG("Unknown texture target %d\n", template->target);
|
2019-02-05 04:32:27 +00:00
|
|
|
assert(0);
|
|
|
|
}
|
|
|
|
|
panfrost: Track BO lifetime with jobs and reference counts
This (fairly large) patch continues work surrounding the panfrost_job
abstraction to improve job lifetime management. In particular, we add
infrastructure to track which BOs are used by a particular job
(currently limited to the vertex buffer BOs), to reference count these
BOs, and to automatically manage the BOs memory based on the reference
count. This set of changes serves as a code cleanup, as a way of future
proofing for allowing flushing BOs, and immediately as a bugfix to
workaround the missing reference counting for vertex buffer BOs.
Meanwhile, there are a few cleanups to vertex buffer handling code
itself, so in the short-term, this allows us to remove the costly VBO
staging workaround, since this patch addresses the underlying causes.
v2: Use pipe_reference for BO reference counting, rather than managing
it ourselves. Don't duplicate hash-table key removal. Fix vertex buffer
counting.
Signed-off-by: Alyssa Rosenzweig <alyssa@rosenzweig.io>
2019-04-14 22:42:44 +00:00
|
|
|
util_range_init(&so->valid_buffer_range);
|
|
|
|
|
2019-03-07 03:24:45 +00:00
|
|
|
if (template->bind & PIPE_BIND_DISPLAY_TARGET ||
|
|
|
|
template->bind & PIPE_BIND_SCANOUT ||
|
|
|
|
template->bind & PIPE_BIND_SHARED) {
|
|
|
|
struct pipe_resource scanout_templat = *template;
|
|
|
|
struct renderonly_scanout *scanout;
|
|
|
|
struct winsys_handle handle;
|
|
|
|
|
|
|
|
scanout = renderonly_scanout_for_resource(&scanout_templat,
|
|
|
|
pscreen->ro, &handle);
|
|
|
|
if (!scanout)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
assert(handle.type == WINSYS_HANDLE_TYPE_FD);
|
|
|
|
/* TODO: handle modifiers? */
|
|
|
|
so = pan_resource(screen->resource_from_handle(screen, template,
|
|
|
|
&handle,
|
|
|
|
PIPE_HANDLE_USAGE_FRAMEBUFFER_WRITE));
|
|
|
|
close(handle.handle);
|
|
|
|
if (!so)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
so->scanout = scanout;
|
|
|
|
pscreen->display_target = so;
|
2019-02-05 04:32:27 +00:00
|
|
|
} else {
|
2019-03-07 03:24:45 +00:00
|
|
|
so->bo = panfrost_create_bo(pscreen, template);
|
2019-02-05 04:32:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return (struct pipe_resource *)so;
|
|
|
|
}
|
|
|
|
|
2019-02-07 06:00:11 +00:00
|
|
|
static void
|
|
|
|
panfrost_destroy_bo(struct panfrost_screen *screen, struct panfrost_bo *pbo)
|
|
|
|
{
|
|
|
|
struct panfrost_bo *bo = (struct panfrost_bo *)pbo;
|
|
|
|
|
2019-03-21 02:54:38 +00:00
|
|
|
if ((bo->layout == PAN_LINEAR || bo->layout == PAN_TILED) &&
|
|
|
|
!bo->imported) {
|
2019-03-08 23:36:02 +00:00
|
|
|
struct panfrost_memory mem = {
|
2019-03-21 02:54:38 +00:00
|
|
|
.cpu = bo->cpu,
|
|
|
|
.gpu = bo->gpu,
|
|
|
|
.size = bo->size,
|
2019-03-11 13:35:27 +01:00
|
|
|
.gem_handle = bo->gem_handle,
|
2019-03-08 23:36:02 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
screen->driver->free_slab(screen, &mem);
|
2019-02-14 04:00:19 +00:00
|
|
|
}
|
|
|
|
|
2019-03-07 03:52:20 +00:00
|
|
|
if (bo->layout == PAN_AFBC) {
|
2019-02-07 06:00:11 +00:00
|
|
|
/* TODO */
|
2019-03-08 15:24:57 +01:00
|
|
|
DBG("--leaking afbc (%d bytes)--\n", bo->afbc_metadata_size);
|
2019-02-07 06:00:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (bo->has_checksum) {
|
2019-05-17 00:14:49 +00:00
|
|
|
struct panfrost_memory mem = {
|
|
|
|
.cpu = bo->checksum_slab.cpu,
|
|
|
|
.gpu = bo->checksum_slab.gpu,
|
|
|
|
.size = bo->checksum_slab.size,
|
|
|
|
.gem_handle = bo->checksum_slab.gem_handle,
|
|
|
|
};
|
|
|
|
|
|
|
|
screen->driver->free_slab(screen, &mem);
|
2019-02-07 06:00:11 +00:00
|
|
|
}
|
2019-02-15 00:15:14 +00:00
|
|
|
|
|
|
|
if (bo->imported) {
|
|
|
|
screen->driver->free_imported_bo(screen, bo);
|
|
|
|
}
|
2019-02-07 06:00:11 +00:00
|
|
|
}
|
|
|
|
|
panfrost: Track BO lifetime with jobs and reference counts
This (fairly large) patch continues work surrounding the panfrost_job
abstraction to improve job lifetime management. In particular, we add
infrastructure to track which BOs are used by a particular job
(currently limited to the vertex buffer BOs), to reference count these
BOs, and to automatically manage the BOs memory based on the reference
count. This set of changes serves as a code cleanup, as a way of future
proofing for allowing flushing BOs, and immediately as a bugfix to
workaround the missing reference counting for vertex buffer BOs.
Meanwhile, there are a few cleanups to vertex buffer handling code
itself, so in the short-term, this allows us to remove the costly VBO
staging workaround, since this patch addresses the underlying causes.
v2: Use pipe_reference for BO reference counting, rather than managing
it ourselves. Don't duplicate hash-table key removal. Fix vertex buffer
counting.
Signed-off-by: Alyssa Rosenzweig <alyssa@rosenzweig.io>
2019-04-14 22:42:44 +00:00
|
|
|
void
|
|
|
|
panfrost_bo_reference(struct panfrost_bo *bo)
|
|
|
|
{
|
|
|
|
pipe_reference(NULL, &bo->reference);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
panfrost_bo_unreference(struct pipe_screen *screen, struct panfrost_bo *bo)
|
|
|
|
{
|
|
|
|
/* When the reference count goes to zero, we need to cleanup */
|
|
|
|
|
|
|
|
if (pipe_reference(&bo->reference, NULL)) {
|
|
|
|
panfrost_destroy_bo(pan_screen(screen), bo);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-02-05 04:32:27 +00:00
|
|
|
static void
|
|
|
|
panfrost_resource_destroy(struct pipe_screen *screen,
|
|
|
|
struct pipe_resource *pt)
|
|
|
|
{
|
2019-03-08 10:27:07 +01:00
|
|
|
struct panfrost_screen *pscreen = pan_screen(screen);
|
2019-02-05 04:32:27 +00:00
|
|
|
struct panfrost_resource *rsrc = (struct panfrost_resource *) pt;
|
|
|
|
|
|
|
|
if (rsrc->scanout)
|
|
|
|
renderonly_scanout_destroy(rsrc->scanout, pscreen->ro);
|
|
|
|
|
|
|
|
if (rsrc->bo)
|
panfrost: Track BO lifetime with jobs and reference counts
This (fairly large) patch continues work surrounding the panfrost_job
abstraction to improve job lifetime management. In particular, we add
infrastructure to track which BOs are used by a particular job
(currently limited to the vertex buffer BOs), to reference count these
BOs, and to automatically manage the BOs memory based on the reference
count. This set of changes serves as a code cleanup, as a way of future
proofing for allowing flushing BOs, and immediately as a bugfix to
workaround the missing reference counting for vertex buffer BOs.
Meanwhile, there are a few cleanups to vertex buffer handling code
itself, so in the short-term, this allows us to remove the costly VBO
staging workaround, since this patch addresses the underlying causes.
v2: Use pipe_reference for BO reference counting, rather than managing
it ourselves. Don't duplicate hash-table key removal. Fix vertex buffer
counting.
Signed-off-by: Alyssa Rosenzweig <alyssa@rosenzweig.io>
2019-04-14 22:42:44 +00:00
|
|
|
panfrost_bo_unreference(screen, rsrc->bo);
|
2019-02-05 04:32:27 +00:00
|
|
|
|
panfrost: Track BO lifetime with jobs and reference counts
This (fairly large) patch continues work surrounding the panfrost_job
abstraction to improve job lifetime management. In particular, we add
infrastructure to track which BOs are used by a particular job
(currently limited to the vertex buffer BOs), to reference count these
BOs, and to automatically manage the BOs memory based on the reference
count. This set of changes serves as a code cleanup, as a way of future
proofing for allowing flushing BOs, and immediately as a bugfix to
workaround the missing reference counting for vertex buffer BOs.
Meanwhile, there are a few cleanups to vertex buffer handling code
itself, so in the short-term, this allows us to remove the costly VBO
staging workaround, since this patch addresses the underlying causes.
v2: Use pipe_reference for BO reference counting, rather than managing
it ourselves. Don't duplicate hash-table key removal. Fix vertex buffer
counting.
Signed-off-by: Alyssa Rosenzweig <alyssa@rosenzweig.io>
2019-04-14 22:42:44 +00:00
|
|
|
util_range_destroy(&rsrc->valid_buffer_range);
|
2019-02-05 04:32:27 +00:00
|
|
|
FREE(rsrc);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *
|
|
|
|
panfrost_transfer_map(struct pipe_context *pctx,
|
|
|
|
struct pipe_resource *resource,
|
|
|
|
unsigned level,
|
|
|
|
unsigned usage, /* a combination of PIPE_TRANSFER_x */
|
|
|
|
const struct pipe_box *box,
|
|
|
|
struct pipe_transfer **out_transfer)
|
|
|
|
{
|
|
|
|
int bytes_per_pixel = util_format_get_blocksize(resource->format);
|
panfrost: Track BO lifetime with jobs and reference counts
This (fairly large) patch continues work surrounding the panfrost_job
abstraction to improve job lifetime management. In particular, we add
infrastructure to track which BOs are used by a particular job
(currently limited to the vertex buffer BOs), to reference count these
BOs, and to automatically manage the BOs memory based on the reference
count. This set of changes serves as a code cleanup, as a way of future
proofing for allowing flushing BOs, and immediately as a bugfix to
workaround the missing reference counting for vertex buffer BOs.
Meanwhile, there are a few cleanups to vertex buffer handling code
itself, so in the short-term, this allows us to remove the costly VBO
staging workaround, since this patch addresses the underlying causes.
v2: Use pipe_reference for BO reference counting, rather than managing
it ourselves. Don't duplicate hash-table key removal. Fix vertex buffer
counting.
Signed-off-by: Alyssa Rosenzweig <alyssa@rosenzweig.io>
2019-04-14 22:42:44 +00:00
|
|
|
struct panfrost_resource *rsrc = pan_resource(resource);
|
|
|
|
struct panfrost_bo *bo = rsrc->bo;
|
2019-02-05 04:32:27 +00:00
|
|
|
|
2019-03-21 02:54:38 +00:00
|
|
|
struct panfrost_gtransfer *transfer = CALLOC_STRUCT(panfrost_gtransfer);
|
|
|
|
transfer->base.level = level;
|
|
|
|
transfer->base.usage = usage;
|
|
|
|
transfer->base.box = *box;
|
2019-02-05 04:32:27 +00:00
|
|
|
|
2019-03-21 02:54:38 +00:00
|
|
|
pipe_resource_reference(&transfer->base.resource, resource);
|
2019-02-05 04:32:27 +00:00
|
|
|
|
2019-03-21 02:54:38 +00:00
|
|
|
*out_transfer = &transfer->base;
|
2019-02-05 04:32:27 +00:00
|
|
|
|
2019-05-02 02:27:04 +00:00
|
|
|
/* Check if we're bound for rendering and this is a read pixels. If so,
|
|
|
|
* we need to flush */
|
|
|
|
|
|
|
|
struct panfrost_context *ctx = pan_context(pctx);
|
|
|
|
struct pipe_framebuffer_state *fb = &ctx->pipe_framebuffer;
|
2019-02-05 04:32:27 +00:00
|
|
|
|
2019-05-02 02:27:04 +00:00
|
|
|
bool is_bound = false;
|
|
|
|
|
|
|
|
for (unsigned c = 0; c < fb->nr_cbufs; ++c) {
|
|
|
|
is_bound |= fb->cbufs[c]->texture == resource;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (is_bound && (usage & PIPE_TRANSFER_READ)) {
|
|
|
|
assert(level == 0);
|
2019-02-05 04:32:27 +00:00
|
|
|
panfrost_flush(pctx, NULL, PIPE_FLUSH_END_OF_FRAME);
|
|
|
|
}
|
|
|
|
|
2019-05-02 02:27:04 +00:00
|
|
|
/* TODO: Respect usage flags */
|
|
|
|
|
panfrost: Track BO lifetime with jobs and reference counts
This (fairly large) patch continues work surrounding the panfrost_job
abstraction to improve job lifetime management. In particular, we add
infrastructure to track which BOs are used by a particular job
(currently limited to the vertex buffer BOs), to reference count these
BOs, and to automatically manage the BOs memory based on the reference
count. This set of changes serves as a code cleanup, as a way of future
proofing for allowing flushing BOs, and immediately as a bugfix to
workaround the missing reference counting for vertex buffer BOs.
Meanwhile, there are a few cleanups to vertex buffer handling code
itself, so in the short-term, this allows us to remove the costly VBO
staging workaround, since this patch addresses the underlying causes.
v2: Use pipe_reference for BO reference counting, rather than managing
it ourselves. Don't duplicate hash-table key removal. Fix vertex buffer
counting.
Signed-off-by: Alyssa Rosenzweig <alyssa@rosenzweig.io>
2019-04-14 22:42:44 +00:00
|
|
|
if (usage & PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE) {
|
|
|
|
/* TODO: reallocate */
|
|
|
|
//printf("debug: Missed reallocate\n");
|
|
|
|
} else if ((usage & PIPE_TRANSFER_WRITE)
|
|
|
|
&& resource->target == PIPE_BUFFER
|
|
|
|
&& !util_ranges_intersect(&rsrc->valid_buffer_range, box->x, box->x + box->width)) {
|
|
|
|
/* No flush for writes to uninitialized */
|
|
|
|
} else if (!(usage & PIPE_TRANSFER_UNSYNCHRONIZED)) {
|
|
|
|
if (usage & PIPE_TRANSFER_WRITE) {
|
|
|
|
/* STUB: flush reading */
|
|
|
|
//printf("debug: missed reading flush %d\n", resource->target);
|
|
|
|
} else if (usage & PIPE_TRANSFER_READ) {
|
|
|
|
/* STUB: flush writing */
|
|
|
|
//printf("debug: missed writing flush %d (%d-%d)\n", resource->target, box->x, box->x + box->width);
|
|
|
|
} else {
|
|
|
|
/* Why are you even mapping?! */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-21 02:54:38 +00:00
|
|
|
if (bo->layout != PAN_LINEAR) {
|
|
|
|
/* Non-linear resources need to be indirectly mapped */
|
2019-02-05 04:32:27 +00:00
|
|
|
|
2019-03-21 02:54:38 +00:00
|
|
|
if (usage & PIPE_TRANSFER_MAP_DIRECTLY)
|
|
|
|
return NULL;
|
|
|
|
|
2019-04-03 03:52:36 +00:00
|
|
|
transfer->base.stride = box->width * bytes_per_pixel;
|
|
|
|
transfer->base.layer_stride = transfer->base.stride * box->height;
|
|
|
|
|
2019-03-21 02:54:38 +00:00
|
|
|
/* TODO: Reads */
|
2019-04-03 03:52:36 +00:00
|
|
|
transfer->map = malloc(transfer->base.layer_stride * box->depth);
|
2019-03-21 02:54:38 +00:00
|
|
|
|
|
|
|
return transfer->map;
|
|
|
|
} else {
|
2019-04-03 03:52:36 +00:00
|
|
|
transfer->base.stride = bo->slices[level].stride;
|
|
|
|
transfer->base.layer_stride = bo->cubemap_stride;
|
|
|
|
|
2019-03-21 02:54:38 +00:00
|
|
|
return bo->cpu
|
|
|
|
+ bo->slices[level].offset
|
2019-03-27 04:37:26 +00:00
|
|
|
+ transfer->base.box.z * bo->cubemap_stride
|
2019-03-21 02:54:38 +00:00
|
|
|
+ transfer->base.box.y * bo->slices[level].stride
|
|
|
|
+ transfer->base.box.x * bytes_per_pixel;
|
|
|
|
}
|
2019-02-05 04:32:27 +00:00
|
|
|
}
|
|
|
|
|
2019-02-07 06:00:11 +00:00
|
|
|
static void
|
2019-03-21 02:54:38 +00:00
|
|
|
panfrost_tile_texture(struct panfrost_screen *screen, struct panfrost_resource *rsrc, struct panfrost_gtransfer *trans)
|
2019-02-07 06:00:11 +00:00
|
|
|
{
|
|
|
|
struct panfrost_bo *bo = (struct panfrost_bo *)rsrc->bo;
|
|
|
|
|
2019-03-21 02:54:38 +00:00
|
|
|
unsigned level = trans->base.level;
|
2019-02-07 06:00:11 +00:00
|
|
|
|
2019-03-21 02:54:38 +00:00
|
|
|
panfrost_texture_swizzle(
|
|
|
|
trans->base.box.x,
|
|
|
|
trans->base.box.y,
|
|
|
|
trans->base.box.width,
|
|
|
|
trans->base.box.height,
|
|
|
|
util_format_get_blocksize(rsrc->base.format),
|
2019-04-03 03:36:38 +00:00
|
|
|
u_minify(rsrc->base.width0, level),
|
2019-03-21 02:54:38 +00:00
|
|
|
trans->map,
|
2019-03-28 23:47:10 +00:00
|
|
|
bo->cpu
|
|
|
|
+ bo->slices[level].offset
|
|
|
|
+ bo->cubemap_stride * trans->base.box.z
|
|
|
|
);
|
2019-02-07 06:00:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2019-04-03 02:15:18 +00:00
|
|
|
panfrost_transfer_unmap(struct pipe_context *pctx,
|
|
|
|
struct pipe_transfer *transfer)
|
2019-02-07 06:00:11 +00:00
|
|
|
{
|
2019-04-03 02:15:18 +00:00
|
|
|
struct panfrost_context *ctx = pan_context(pctx);
|
|
|
|
|
|
|
|
/* Gallium expects writeback here, so we tile */
|
|
|
|
|
2019-03-21 02:54:38 +00:00
|
|
|
struct panfrost_gtransfer *trans = pan_transfer(transfer);
|
panfrost: Track BO lifetime with jobs and reference counts
This (fairly large) patch continues work surrounding the panfrost_job
abstraction to improve job lifetime management. In particular, we add
infrastructure to track which BOs are used by a particular job
(currently limited to the vertex buffer BOs), to reference count these
BOs, and to automatically manage the BOs memory based on the reference
count. This set of changes serves as a code cleanup, as a way of future
proofing for allowing flushing BOs, and immediately as a bugfix to
workaround the missing reference counting for vertex buffer BOs.
Meanwhile, there are a few cleanups to vertex buffer handling code
itself, so in the short-term, this allows us to remove the costly VBO
staging workaround, since this patch addresses the underlying causes.
v2: Use pipe_reference for BO reference counting, rather than managing
it ourselves. Don't duplicate hash-table key removal. Fix vertex buffer
counting.
Signed-off-by: Alyssa Rosenzweig <alyssa@rosenzweig.io>
2019-04-14 22:42:44 +00:00
|
|
|
struct panfrost_resource *prsrc = (struct panfrost_resource *) transfer->resource;
|
2019-02-07 06:00:11 +00:00
|
|
|
|
2019-04-03 02:15:18 +00:00
|
|
|
if (trans->map) {
|
|
|
|
struct panfrost_bo *bo = prsrc->bo;
|
|
|
|
|
|
|
|
if (transfer->usage & PIPE_TRANSFER_WRITE) {
|
|
|
|
|
|
|
|
if (bo->layout == PAN_AFBC) {
|
|
|
|
DBG("Unimplemented: writes to AFBC\n");
|
|
|
|
} else if (bo->layout == PAN_TILED) {
|
|
|
|
struct pipe_context *gallium = (struct pipe_context *) ctx;
|
|
|
|
struct panfrost_screen *screen = pan_screen(gallium->screen);
|
|
|
|
assert(transfer->box.depth == 1);
|
|
|
|
panfrost_tile_texture(screen, prsrc, trans);
|
|
|
|
}
|
2019-02-07 06:00:11 +00:00
|
|
|
}
|
2019-02-05 04:32:27 +00:00
|
|
|
|
2019-04-03 02:15:18 +00:00
|
|
|
free(trans->map);
|
|
|
|
}
|
2019-02-05 04:32:27 +00:00
|
|
|
|
panfrost: Track BO lifetime with jobs and reference counts
This (fairly large) patch continues work surrounding the panfrost_job
abstraction to improve job lifetime management. In particular, we add
infrastructure to track which BOs are used by a particular job
(currently limited to the vertex buffer BOs), to reference count these
BOs, and to automatically manage the BOs memory based on the reference
count. This set of changes serves as a code cleanup, as a way of future
proofing for allowing flushing BOs, and immediately as a bugfix to
workaround the missing reference counting for vertex buffer BOs.
Meanwhile, there are a few cleanups to vertex buffer handling code
itself, so in the short-term, this allows us to remove the costly VBO
staging workaround, since this patch addresses the underlying causes.
v2: Use pipe_reference for BO reference counting, rather than managing
it ourselves. Don't duplicate hash-table key removal. Fix vertex buffer
counting.
Signed-off-by: Alyssa Rosenzweig <alyssa@rosenzweig.io>
2019-04-14 22:42:44 +00:00
|
|
|
|
|
|
|
util_range_add(&prsrc->valid_buffer_range,
|
|
|
|
transfer->box.x,
|
|
|
|
transfer->box.x + transfer->box.width);
|
|
|
|
|
2019-02-05 04:32:27 +00:00
|
|
|
/* Derefence the resource */
|
|
|
|
pipe_resource_reference(&transfer->resource, NULL);
|
|
|
|
|
|
|
|
/* Transfer itself is CALLOCed at the moment */
|
|
|
|
free(transfer);
|
|
|
|
}
|
|
|
|
|
panfrost: Track BO lifetime with jobs and reference counts
This (fairly large) patch continues work surrounding the panfrost_job
abstraction to improve job lifetime management. In particular, we add
infrastructure to track which BOs are used by a particular job
(currently limited to the vertex buffer BOs), to reference count these
BOs, and to automatically manage the BOs memory based on the reference
count. This set of changes serves as a code cleanup, as a way of future
proofing for allowing flushing BOs, and immediately as a bugfix to
workaround the missing reference counting for vertex buffer BOs.
Meanwhile, there are a few cleanups to vertex buffer handling code
itself, so in the short-term, this allows us to remove the costly VBO
staging workaround, since this patch addresses the underlying causes.
v2: Use pipe_reference for BO reference counting, rather than managing
it ourselves. Don't duplicate hash-table key removal. Fix vertex buffer
counting.
Signed-off-by: Alyssa Rosenzweig <alyssa@rosenzweig.io>
2019-04-14 22:42:44 +00:00
|
|
|
static void
|
|
|
|
panfrost_transfer_flush_region(struct pipe_context *pctx,
|
|
|
|
struct pipe_transfer *transfer,
|
|
|
|
const struct pipe_box *box)
|
|
|
|
{
|
|
|
|
struct panfrost_resource *rsc = pan_resource(transfer->resource);
|
|
|
|
|
|
|
|
if (transfer->resource->target == PIPE_BUFFER) {
|
|
|
|
util_range_add(&rsc->valid_buffer_range,
|
|
|
|
transfer->box.x + box->x,
|
|
|
|
transfer->box.x + box->x + box->width);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-02-05 04:32:27 +00:00
|
|
|
static struct pb_slab *
|
|
|
|
panfrost_slab_alloc(void *priv, unsigned heap, unsigned entry_size, unsigned group_index)
|
|
|
|
{
|
|
|
|
struct panfrost_screen *screen = (struct panfrost_screen *) priv;
|
|
|
|
struct panfrost_memory *mem = CALLOC_STRUCT(panfrost_memory);
|
|
|
|
|
|
|
|
size_t slab_size = (1 << (MAX_SLAB_ENTRY_SIZE + 1));
|
|
|
|
|
|
|
|
mem->slab.num_entries = slab_size / entry_size;
|
|
|
|
mem->slab.num_free = mem->slab.num_entries;
|
|
|
|
|
|
|
|
LIST_INITHEAD(&mem->slab.free);
|
|
|
|
for (unsigned i = 0; i < mem->slab.num_entries; ++i) {
|
|
|
|
/* Create a slab entry */
|
|
|
|
struct panfrost_memory_entry *entry = CALLOC_STRUCT(panfrost_memory_entry);
|
|
|
|
entry->offset = entry_size * i;
|
|
|
|
|
|
|
|
entry->base.slab = &mem->slab;
|
|
|
|
entry->base.group_index = group_index;
|
|
|
|
|
|
|
|
LIST_ADDTAIL(&entry->base.head, &mem->slab.free);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Actually allocate the memory from kernel-space. Mapped, same_va, no
|
|
|
|
* special flags */
|
|
|
|
|
|
|
|
screen->driver->allocate_slab(screen, mem, slab_size / 4096, true, 0, 0, 0);
|
|
|
|
|
|
|
|
return &mem->slab;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
panfrost_slab_can_reclaim(void *priv, struct pb_slab_entry *entry)
|
|
|
|
{
|
|
|
|
struct panfrost_memory_entry *p_entry = (struct panfrost_memory_entry *) entry;
|
|
|
|
return p_entry->freed;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
panfrost_slab_free(void *priv, struct pb_slab *slab)
|
|
|
|
{
|
2019-02-14 06:17:19 +00:00
|
|
|
struct panfrost_memory *mem = (struct panfrost_memory *) slab;
|
|
|
|
struct panfrost_screen *screen = (struct panfrost_screen *) priv;
|
|
|
|
|
|
|
|
screen->driver->free_slab(screen, mem);
|
2019-02-05 04:32:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
panfrost_invalidate_resource(struct pipe_context *pctx, struct pipe_resource *prsc)
|
|
|
|
{
|
2019-03-08 15:24:57 +01:00
|
|
|
//DBG("TODO %s\n", __func__);
|
2019-02-05 04:32:27 +00:00
|
|
|
}
|
|
|
|
|
2019-02-15 23:59:58 +00:00
|
|
|
static enum pipe_format
|
|
|
|
panfrost_resource_get_internal_format(struct pipe_resource *prsrc)
|
|
|
|
{
|
|
|
|
return prsrc->format;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
panfrost_resource_set_stencil(struct pipe_resource *prsrc,
|
|
|
|
struct pipe_resource *stencil)
|
|
|
|
{
|
|
|
|
pan_resource(prsrc)->separate_stencil = pan_resource(stencil);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct pipe_resource *
|
|
|
|
panfrost_resource_get_stencil(struct pipe_resource *prsrc)
|
|
|
|
{
|
|
|
|
return &pan_resource(prsrc)->separate_stencil->base;
|
|
|
|
}
|
|
|
|
|
2019-02-05 04:32:27 +00:00
|
|
|
static const struct u_transfer_vtbl transfer_vtbl = {
|
|
|
|
.resource_create = panfrost_resource_create,
|
|
|
|
.resource_destroy = panfrost_resource_destroy,
|
|
|
|
.transfer_map = panfrost_transfer_map,
|
|
|
|
.transfer_unmap = panfrost_transfer_unmap,
|
panfrost: Track BO lifetime with jobs and reference counts
This (fairly large) patch continues work surrounding the panfrost_job
abstraction to improve job lifetime management. In particular, we add
infrastructure to track which BOs are used by a particular job
(currently limited to the vertex buffer BOs), to reference count these
BOs, and to automatically manage the BOs memory based on the reference
count. This set of changes serves as a code cleanup, as a way of future
proofing for allowing flushing BOs, and immediately as a bugfix to
workaround the missing reference counting for vertex buffer BOs.
Meanwhile, there are a few cleanups to vertex buffer handling code
itself, so in the short-term, this allows us to remove the costly VBO
staging workaround, since this patch addresses the underlying causes.
v2: Use pipe_reference for BO reference counting, rather than managing
it ourselves. Don't duplicate hash-table key removal. Fix vertex buffer
counting.
Signed-off-by: Alyssa Rosenzweig <alyssa@rosenzweig.io>
2019-04-14 22:42:44 +00:00
|
|
|
.transfer_flush_region = panfrost_transfer_flush_region,
|
2019-02-15 23:59:58 +00:00
|
|
|
.get_internal_format = panfrost_resource_get_internal_format,
|
|
|
|
.set_stencil = panfrost_resource_set_stencil,
|
|
|
|
.get_stencil = panfrost_resource_get_stencil,
|
2019-02-05 04:32:27 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
void
|
|
|
|
panfrost_resource_screen_init(struct panfrost_screen *pscreen)
|
|
|
|
{
|
|
|
|
//pscreen->base.resource_create_with_modifiers =
|
|
|
|
// panfrost_resource_create_with_modifiers;
|
|
|
|
pscreen->base.resource_create = u_transfer_helper_resource_create;
|
|
|
|
pscreen->base.resource_destroy = u_transfer_helper_resource_destroy;
|
|
|
|
pscreen->base.resource_from_handle = panfrost_resource_from_handle;
|
|
|
|
pscreen->base.resource_get_handle = panfrost_resource_get_handle;
|
|
|
|
pscreen->base.transfer_helper = u_transfer_helper_create(&transfer_vtbl,
|
2019-02-15 23:59:58 +00:00
|
|
|
true, false,
|
2019-02-05 04:32:27 +00:00
|
|
|
true, true);
|
|
|
|
|
|
|
|
pb_slabs_init(&pscreen->slabs,
|
|
|
|
MIN_SLAB_ENTRY_SIZE,
|
|
|
|
MAX_SLAB_ENTRY_SIZE,
|
|
|
|
|
|
|
|
3, /* Number of heaps */
|
|
|
|
|
|
|
|
pscreen,
|
|
|
|
|
|
|
|
panfrost_slab_can_reclaim,
|
|
|
|
panfrost_slab_alloc,
|
|
|
|
panfrost_slab_free);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
panfrost_resource_context_init(struct pipe_context *pctx)
|
|
|
|
{
|
|
|
|
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->create_surface = panfrost_create_surface;
|
|
|
|
pctx->surface_destroy = panfrost_surface_destroy;
|
|
|
|
pctx->resource_copy_region = util_resource_copy_region;
|
|
|
|
pctx->blit = panfrost_blit;
|
|
|
|
pctx->flush_resource = panfrost_flush_resource;
|
|
|
|
pctx->invalidate_resource = panfrost_invalidate_resource;
|
|
|
|
pctx->transfer_flush_region = u_transfer_helper_transfer_flush_region;
|
|
|
|
pctx->buffer_subdata = u_default_buffer_subdata;
|
|
|
|
pctx->texture_subdata = u_default_texture_subdata;
|
|
|
|
}
|