static struct pipe_query *virgl_create_query(struct pipe_context *ctx,
unsigned query_type, unsigned index)
{
struct virgl_context *vctx = virgl_context(ctx);
struct virgl_query *query;
uint32_t handle;
query = CALLOC_STRUCT(virgl_query);
if (!query)
return NULL;
query->buf = (struct virgl_resource *)pipe_buffer_create(ctx->screen, PIPE_BIND_CUSTOM,
PIPE_USAGE_STAGING, sizeof(struct virgl_host_query_state));
if (!query->buf) {
FREE(query);
return NULL;
}
handle = virgl_object_assign_handle();
query->type = pipe_to_virgl_query(query_type);
query->index = index;
query->handle = handle;
query->buf->clean = FALSE;
virgl_encoder_create_query(vctx, handle, query->type, index, query->buf, 0);
return (struct pipe_query *)query;
}
static void virgl_texture_transfer_unmap(struct pipe_context *ctx,
struct pipe_transfer *transfer)
{
struct virgl_context *vctx = virgl_context(ctx);
struct virgl_transfer *trans = virgl_transfer(transfer);
struct virgl_texture *vtex = virgl_texture(transfer->resource);
uint32_t l_stride;
if (transfer->resource->target != PIPE_TEXTURE_3D &&
transfer->resource->target != PIPE_TEXTURE_CUBE &&
transfer->resource->target != PIPE_TEXTURE_1D_ARRAY &&
transfer->resource->target != PIPE_TEXTURE_2D_ARRAY &&
transfer->resource->target != PIPE_TEXTURE_CUBE_ARRAY)
l_stride = 0;
else
l_stride = trans->base.layer_stride;
if (trans->base.usage & PIPE_TRANSFER_WRITE) {
if (!(transfer->usage & PIPE_TRANSFER_FLUSH_EXPLICIT)) {
struct virgl_screen *vs = virgl_screen(ctx->screen);
vtex->base.clean = FALSE;
vctx->num_transfers++;
vs->vws->transfer_put(vs->vws, vtex->base.hw_res,
&transfer->box, trans->base.stride, l_stride, trans->offset, transfer->level);
}
}
if (trans->resolve_tmp)
pipe_resource_reference((struct pipe_resource **)&trans->resolve_tmp, NULL);
util_slab_free(&vctx->texture_transfer_pool, trans);
}
static void *virgl_buffer_transfer_map(struct pipe_context *ctx,
struct pipe_resource *resource,
unsigned level,
unsigned usage,
const struct pipe_box *box,
struct pipe_transfer **transfer)
{
struct virgl_context *vctx = virgl_context(ctx);
struct virgl_screen *vs = virgl_screen(ctx->screen);
struct virgl_buffer *vbuf = virgl_buffer(resource);
struct virgl_transfer *trans;
void *ptr;
bool readback;
uint32_t offset;
bool doflushwait = false;
if ((usage & PIPE_TRANSFER_READ) && (vbuf->on_list == TRUE))
doflushwait = true;
else
doflushwait = virgl_res_needs_flush_wait(vctx, &vbuf->base, usage);
if (doflushwait)
ctx->flush(ctx, NULL, 0);
trans = util_slab_alloc(&vctx->texture_transfer_pool);
if (!trans)
return NULL;
trans->base.resource = resource;
trans->base.level = level;
trans->base.usage = usage;
trans->base.box = *box;
trans->base.stride = 0;
trans->base.layer_stride = 0;
offset = box->x;
readback = virgl_res_needs_readback(vctx, &vbuf->base, usage);
if (readback)
vs->vws->transfer_get(vs->vws, vbuf->base.hw_res, box, trans->base.stride, trans->base.layer_stride, offset, level);
if (!(usage & PIPE_TRANSFER_UNSYNCHRONIZED))
doflushwait = true;
if (doflushwait || readback)
vs->vws->resource_wait(vs->vws, vbuf->base.hw_res);
ptr = vs->vws->resource_map(vs->vws, vbuf->base.hw_res);
if (!ptr) {
return NULL;
}
trans->offset = offset;
*transfer = &trans->base;
return ptr + trans->offset;
}
static boolean virgl_begin_query(struct pipe_context *ctx,
struct pipe_query *q)
{
struct virgl_context *vctx = virgl_context(ctx);
struct virgl_query *query = virgl_query(q);
query->buf->clean = FALSE;
virgl_encoder_begin_query(vctx, query->handle);
return true;
}
static void virgl_destroy_query(struct pipe_context *ctx,
struct pipe_query *q)
{
struct virgl_context *vctx = virgl_context(ctx);
struct virgl_query *query = virgl_query(q);
virgl_encode_delete_object(vctx, query->handle, VIRGL_OBJECT_QUERY);
pipe_resource_reference((struct pipe_resource **)&query->buf, NULL);
FREE(query);
}
static void virgl_render_condition(struct pipe_context *ctx,
struct pipe_query *q,
boolean condition,
enum pipe_render_cond_flag mode)
{
struct virgl_context *vctx = virgl_context(ctx);
struct virgl_query *query = virgl_query(q);
uint32_t handle = 0;
if (q)
handle = query->handle;
virgl_encoder_render_condition(vctx, handle, condition, mode);
}
static bool virgl_end_query(struct pipe_context *ctx,
struct pipe_query *q)
{
struct virgl_context *vctx = virgl_context(ctx);
struct virgl_query *query = virgl_query(q);
struct pipe_box box;
uint32_t qs = VIRGL_QUERY_STATE_WAIT_HOST;
u_box_1d(0, 4, &box);
virgl_transfer_inline_write(ctx, &query->buf->u.b, 0, PIPE_TRANSFER_WRITE,
&box, &qs, 0, 0);
virgl_encoder_end_query(vctx, query->handle);
return true;
}
static void virgl_buffer_transfer_unmap(struct pipe_context *ctx,
struct pipe_transfer *transfer)
{
struct virgl_context *vctx = virgl_context(ctx);
struct virgl_transfer *trans = virgl_transfer(transfer);
struct virgl_buffer *vbuf = virgl_buffer(transfer->resource);
if (trans->base.usage & PIPE_TRANSFER_WRITE) {
if (!(transfer->usage & PIPE_TRANSFER_FLUSH_EXPLICIT)) {
struct virgl_screen *vs = virgl_screen(ctx->screen);
vbuf->base.clean = FALSE;
vctx->num_transfers++;
vs->vws->transfer_put(vs->vws, vbuf->base.hw_res,
&transfer->box, trans->base.stride, trans->base.layer_stride, trans->offset, transfer->level);
}
}
util_slab_free(&vctx->texture_transfer_pool, trans);
}
static void virgl_buffer_transfer_flush_region(struct pipe_context *ctx,
struct pipe_transfer *transfer,
const struct pipe_box *box)
{
struct virgl_context *vctx = virgl_context(ctx);
struct virgl_buffer *vbuf = virgl_buffer(transfer->resource);
if (!vbuf->on_list) {
struct pipe_resource *res = NULL;
list_addtail(&vbuf->flush_list, &vctx->to_flush_bufs);
vbuf->on_list = TRUE;
pipe_resource_reference(&res, &vbuf->base.u.b);
}
util_range_add(&vbuf->valid_buffer_range, transfer->box.x + box->x,
transfer->box.x + box->x + box->width);
vbuf->base.clean = FALSE;
}
static boolean virgl_get_query_result(struct pipe_context *ctx,
struct pipe_query *q,
boolean wait,
union pipe_query_result *result)
{
struct virgl_context *vctx = virgl_context(ctx);
struct virgl_query *query = virgl_query(q);
struct pipe_transfer *transfer;
struct virgl_host_query_state *host_state;
/* ask host for query result */
if (!query->result_gotten_sent) {
query->result_gotten_sent = 1;
virgl_encoder_get_query_result(vctx, query->handle, 0);
ctx->flush(ctx, NULL, 0);
}
/* do we have to flush? */
/* now we can do the transfer to get the result back? */
remap:
host_state = pipe_buffer_map(ctx, &query->buf->u.b,
PIPE_TRANSFER_READ, &transfer);
if (host_state->query_state != VIRGL_QUERY_STATE_DONE) {
pipe_buffer_unmap(ctx, transfer);
if (wait)
goto remap;
else
return FALSE;
}
if (query->type == PIPE_QUERY_TIMESTAMP || query->type == PIPE_QUERY_TIME_ELAPSED)
result->u64 = host_state->result;
else
result->u64 = (uint32_t)host_state->result;
pipe_buffer_unmap(ctx, transfer);
query->result_gotten_sent = 0;
return TRUE;
}
static void virgl_buffer_transfer_unmap(struct pipe_context *ctx,
struct pipe_transfer *transfer)
{
struct virgl_context *vctx = virgl_context(ctx);
struct virgl_transfer *trans = virgl_transfer(transfer);
if (trans->base.usage & PIPE_TRANSFER_WRITE) {
if (transfer->usage & PIPE_TRANSFER_FLUSH_EXPLICIT) {
if (trans->range.end <= trans->range.start) {
virgl_resource_destroy_transfer(&vctx->transfer_pool, trans);
return;
}
transfer->box.x += trans->range.start;
transfer->box.width = trans->range.end - trans->range.start;
trans->offset = transfer->box.x;
}
virgl_transfer_queue_unmap(&vctx->queue, trans);
} else
virgl_resource_destroy_transfer(&vctx->transfer_pool, trans);
}
static void *virgl_buffer_transfer_map(struct pipe_context *ctx,
struct pipe_resource *resource,
unsigned level,
unsigned usage,
const struct pipe_box *box,
struct pipe_transfer **transfer)
{
struct virgl_context *vctx = virgl_context(ctx);
struct virgl_screen *vs = virgl_screen(ctx->screen);
struct virgl_resource *vbuf = virgl_resource(resource);
struct virgl_transfer *trans;
enum virgl_transfer_map_type map_type;
trans = virgl_resource_create_transfer(&vctx->transfer_pool, resource,
&vbuf->metadata, level, usage, box);
map_type = virgl_resource_transfer_prepare(vctx, trans);
switch (map_type) {
case VIRGL_TRANSFER_MAP_HW_RES:
trans->hw_res_map = vs->vws->resource_map(vs->vws, vbuf->hw_res);
break;
case VIRGL_TRANSFER_MAP_ERROR:
default:
trans->hw_res_map = NULL;
break;
}
if (!trans->hw_res_map) {
virgl_resource_destroy_transfer(&vctx->transfer_pool, trans);
return NULL;
}
if (usage & PIPE_TRANSFER_WRITE)
util_range_add(&vbuf->valid_buffer_range, box->x, box->x + box->width);
*transfer = &trans->base;
return trans->hw_res_map + trans->offset;
}
static void *virgl_texture_transfer_map(struct pipe_context *ctx,
struct pipe_resource *resource,
unsigned level,
unsigned usage,
const struct pipe_box *box,
struct pipe_transfer **transfer)
{
struct virgl_context *vctx = virgl_context(ctx);
struct virgl_screen *vs = virgl_screen(ctx->screen);
struct virgl_texture *vtex = virgl_texture(resource);
enum pipe_format format = resource->format;
struct virgl_transfer *trans;
void *ptr;
boolean readback = TRUE;
uint32_t offset;
struct virgl_hw_res *hw_res;
const unsigned h = u_minify(vtex->base.u.b.height0, level);
const unsigned nblocksy = util_format_get_nblocksy(format, h);
bool is_depth = util_format_has_depth(util_format_description(resource->format));
uint32_t l_stride;
bool doflushwait;
doflushwait = virgl_res_needs_flush_wait(vctx, &vtex->base, usage);
if (doflushwait)
ctx->flush(ctx, NULL, 0);
trans = util_slab_alloc(&vctx->texture_transfer_pool);
if (!trans)
return NULL;
trans->base.resource = resource;
trans->base.level = level;
trans->base.usage = usage;
trans->base.box = *box;
trans->base.stride = vtex->stride[level];
trans->base.layer_stride = trans->base.stride * nblocksy;
if (resource->target != PIPE_TEXTURE_3D &&
resource->target != PIPE_TEXTURE_CUBE &&
resource->target != PIPE_TEXTURE_1D_ARRAY &&
resource->target != PIPE_TEXTURE_2D_ARRAY &&
resource->target != PIPE_TEXTURE_CUBE_ARRAY)
l_stride = 0;
else
l_stride = trans->base.layer_stride;
if (is_depth && resource->nr_samples > 1) {
struct pipe_resource tmp_resource;
virgl_init_temp_resource_from_box(&tmp_resource, resource, box,
level, 0);
trans->resolve_tmp = (struct virgl_resource *)ctx->screen->resource_create(ctx->screen, &tmp_resource);
virgl_copy_region_with_blit(ctx, &trans->resolve_tmp->u.b, 0, 0, 0, 0, resource, level, box);
ctx->flush(ctx, NULL, 0);
/* we want to do a resolve blit into the temporary */
hw_res = trans->resolve_tmp->hw_res;
offset = 0;
} else {
offset = vrend_get_tex_image_offset(vtex, level, box->z);
offset += box->y / util_format_get_blockheight(format) * trans->base.stride +
box->x / util_format_get_blockwidth(format) * util_format_get_blocksize(format);
hw_res = vtex->base.hw_res;
trans->resolve_tmp = NULL;
}
readback = virgl_res_needs_readback(vctx, &vtex->base, usage);
if (readback)
vs->vws->transfer_get(vs->vws, hw_res, box, trans->base.stride, l_stride, offset, level);
if (doflushwait || readback)
vs->vws->resource_wait(vs->vws, vtex->base.hw_res);
ptr = vs->vws->resource_map(vs->vws, hw_res);
if (!ptr) {
return NULL;
}
trans->offset = offset;
*transfer = &trans->base;
return ptr + trans->offset;
}
