/*
* Copyright 2014, 2015 Red Hat.
*
* 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
* on 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
* THE AUTHOR(S) AND/OR THEIR 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 <stdio.h>
#include "util/u_memory.h"
#include "util/u_format.h"
#include "util/u_inlines.h"
#include "util/os_time.h"
#include "state_tracker/sw_winsys.h"
#include "virgl_vtest_winsys.h"
#include "virgl_vtest_public.h"
static void *virgl_vtest_resource_map(struct virgl_winsys *vws,
struct virgl_hw_res *res);
static void virgl_vtest_resource_unmap(struct virgl_winsys *vws,
struct virgl_hw_res *res);
static inline boolean can_cache_resource(struct virgl_hw_res *res)
{
return res->cacheable == TRUE;
}
static uint32_t vtest_get_transfer_size(struct virgl_hw_res *res,
const struct pipe_box *box,
uint32_t stride, uint32_t layer_stride,
uint32_t level, uint32_t *valid_stride_p)
{
uint32_t valid_stride, valid_layer_stride;
valid_stride = util_format_get_stride(res->format, box->width);
if (stride) {
if (box->height > 1)
valid_stride = stride;
}
valid_layer_stride = util_format_get_2d_size(res->format, valid_stride,
box->height);
if (layer_stride) {
if (box->depth > 1)
valid_layer_stride = layer_stride;
}
*valid_stride_p = valid_stride;
return valid_layer_stride * box->depth;
}
static int
virgl_vtest_transfer_put(struct virgl_winsys *vws,
struct virgl_hw_res *res,
const struct pipe_box *box,
uint32_t stride, uint32_t layer_stride,
uint32_t buf_offset, uint32_t level)
{
struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
uint32_t size;
void *ptr;
uint32_t valid_stride;
size = vtest_get_transfer_size(res, box, stride, layer_stride, level,
&valid_stride);
virgl_vtest_send_transfer_cmd(vtws, VCMD_TRANSFER_PUT, res->res_handle,
level, stride, layer_stride,
box, size);
ptr = virgl_vtest_resource_map(vws, res);
virgl_vtest_send_transfer_put_data(vtws, ptr + buf_offset, size);
virgl_vtest_resource_unmap(vws, res);
return 0;
}
static int
virgl_vtest_transfer_get(struct virgl_winsys *vws,
struct virgl_hw_res *res,
const struct pipe_box *box,
uint32_t stride, uint32_t layer_stride,
uint32_t buf_offset, uint32_t level)
{
struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
uint32_t size;
void *ptr;
uint32_t valid_stride;
size = vtest_get_transfer_size(res, box, stride, layer_stride, level,
&valid_stride);
virgl_vtest_send_transfer_cmd(vtws, VCMD_TRANSFER_GET, res->res_handle,
level, stride, layer_stride,
box, size);
ptr = virgl_vtest_resource_map(vws, res);
virgl_vtest_recv_transfer_get_data(vtws, ptr + buf_offset, size,
valid_stride, box, res->format);
virgl_vtest_resource_unmap(vws, res);
return 0;
}
static void virgl_hw_res_destroy(struct virgl_vtest_winsys *vtws,
struct virgl_hw_res *res)
{
virgl_vtest_send_resource_unref(vtws, res->res_handle);
if (res->dt)
vtws->sws->displaytarget_destroy(vtws->sws, res->dt);
free(res->ptr);
FREE(res);
}
static boolean virgl_vtest_resource_is_busy(struct virgl_vtest_winsys *vtws,
struct virgl_hw_res *res)
{
/* implement busy check */
int ret;
ret = virgl_vtest_busy_wait(vtws, res->res_handle, 0);
if (ret < 0)
return FALSE;
return ret == 1 ? TRUE : FALSE;
}
static void
virgl_cache_flush(struct virgl_vtest_winsys *vtws)
{
struct list_head *curr, *next;
struct virgl_hw_res *res;
mtx_lock(&vtws->mutex);
curr = vtws->delayed.next;
next = curr->next;
while (curr != &vtws->delayed) {
res = LIST_ENTRY(struct virgl_hw_res, curr, head);
LIST_DEL(&res->head);
virgl_hw_res_destroy(vtws, res);
curr = next;
next = curr->next;
}
mtx_unlock(&vtws->mutex);
}
static void
virgl_cache_list_check_free(struct virgl_vtest_winsys *vtws)
{
struct list_head *curr, *next;
struct virgl_hw_res *res;
int64_t now;
now = os_time_get();
curr = vtws->delayed.next;
next = curr->next;
while (curr != &vtws->delayed) {
res = LIST_ENTRY(struct virgl_hw_res, curr, head);
if (!os_time_timeout(res->start, res->end, now))
break;
LIST_DEL(&res->head);
virgl_hw_res_destroy(vtws, res);
curr = next;
next = curr->next;
}
}
static void virgl_vtest_resource_reference(struct virgl_vtest_winsys *vtws,
struct virgl_hw_res **dres,
struct virgl_hw_res *sres)
{
struct virgl_hw_res *old = *dres;
if (pipe_reference(&(*dres)->reference, &sres->reference)) {
if (!can_cache_resource(old)) {
virgl_hw_res_destroy(vtws, old);
} else {
mtx_lock(&vtws->mutex);
virgl_cache_list_check_free(vtws);
old->start = os_time_get();
old->end = old->start + vtws->usecs;
LIST_ADDTAIL(&old->head, &vtws->delayed);
vtws->num_delayed++;
mtx_unlock(&vtws->mutex);
}
}
*dres = sres;
}
static struct virgl_hw_res *
virgl_vtest_winsys_resource_create(struct virgl_winsys *vws,
enum pipe_texture_target target,
uint32_t format,
uint32_t bind,
uint32_t width,
uint32_t height,
uint32_t depth,
uint32_t array_size,
uint32_t last_level,
uint32_t nr_samples,
uint32_t size)
{
struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
struct virgl_hw_res *res;
static int handle = 1;
res = CALLOC_STRUCT(virgl_hw_res);
if (!res)
return NULL;
if (bind & (VIRGL_BIND_DISPLAY_TARGET | VIRGL_BIND_SCANOUT)) {
res->dt = vtws->sws->displaytarget_create(vtws->sws, bind, format,
width, height, 64, NULL,
&res->stride);
} else {
res->ptr = align_malloc(size, 64);
if (!res->ptr) {
FREE(res);
return NULL;
}
}
res->bind = bind;
res->format = format;
res->height = height;
res->width = width;
virgl_vtest_send_resource_create(vtws, handle, target, format, bind,
width, height, depth, array_size,
last_level, nr_samples);
res->res_handle = handle++;
pipe_reference_init(&res->reference, 1);
return res;
}
static void virgl_vtest_winsys_resource_unref(struct virgl_winsys *vws,
struct virgl_hw_res *hres)
{
struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
virgl_vtest_resource_reference(vtws, &hres, NULL);
}
static void *virgl_vtest_resource_map(struct virgl_winsys *vws,
struct virgl_hw_res *res)
{
struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
if (res->dt) {
return vtws->sws->displaytarget_map(vtws->sws, res->dt, 0);
} else {
res->mapped = res->ptr;
return res->mapped;
}
}
static void virgl_vtest_resource_unmap(struct virgl_winsys *vws,
struct virgl_hw_res *res)
{
struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
if (res->mapped)
res->mapped = NULL;
if (res->dt)
vtws->sws->displaytarget_unmap(vtws->sws, res->dt);
}
static void virgl_vtest_resource_wait(struct virgl_winsys *vws,
struct virgl_hw_res *res)
{
struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
virgl_vtest_busy_wait(vtws, res->res_handle, VCMD_BUSY_WAIT_FLAG_WAIT);
}
static inline int virgl_is_res_compat(struct virgl_vtest_winsys *vtws,
struct virgl_hw_res *res,
uint32_t size, uint32_t bind,
uint32_t format)
{
if (res->bind != bind)
return 0;
if (res->format != format)
return 0;
if (res->size < size)
return 0;
if (res->size > size * 2)
return 0;
if (virgl_vtest_resource_is_busy(vtws, res)) {
return -1;
}
return 1;
}
static struct virgl_hw_res *
virgl_vtest_winsys_resource_cache_create(struct virgl_winsys *vws,
enum pipe_texture_target target,
uint32_t format,
uint32_t bind,
uint32_t width,
uint32_t height,
uint32_t depth,
uint32_t array_size,
uint32_t last_level,
uint32_t nr_samples,
uint32_t size)
{
struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
struct virgl_hw_res *res, *curr_res;
struct list_head *curr, *next;
int64_t now;
int ret;
/* only store binds for vertex/index/const buffers */
if (bind != VIRGL_BIND_CONSTANT_BUFFER && bind != VIRGL_BIND_INDEX_BUFFER &&
bind != VIRGL_BIND_VERTEX_BUFFER && bind != VIRGL_BIND_CUSTOM)
goto alloc;
mtx_lock(&vtws->mutex);
res = NULL;
curr = vtws->delayed.next;
next = curr->next;
now = os_time_get();
while (curr != &vtws->delayed) {
curr_res = LIST_ENTRY(struct virgl_hw_res, curr, head);
if (!res && ((ret = virgl_is_res_compat(vtws, curr_res, size, bind, format)) > 0))
res = curr_res;
else if (os_time_timeout(curr_res->start, curr_res->end, now)) {
LIST_DEL(&curr_res->head);
virgl_hw_res_destroy(vtws, curr_res);
} else
break;
if (ret == -1)
break;
curr = next;
next = curr->next;
}
if (!res && ret != -1) {
while (curr != &vtws->delayed) {
curr_res = LIST_ENTRY(struct virgl_hw_res, curr, head);
ret = virgl_is_res_compat(vtws, curr_res, size, bind, format);
if (ret > 0) {
res = curr_res;
break;
}
if (ret == -1)
break;
curr = next;
next = curr->next;
}
}
if (res) {
LIST_DEL(&res->head);
--vtws->num_delayed;
mtx_unlock(&vtws->mutex);
pipe_reference_init(&res->reference, 1);
return res;
}
mtx_unlock(&vtws->mutex);
alloc:
res = virgl_vtest_winsys_resource_create(vws, target, format, bind,
width, height, depth, array_size,
last_level, nr_samples, size);
if (bind == VIRGL_BIND_CONSTANT_BUFFER || bind == VIRGL_BIND_INDEX_BUFFER ||
bind == VIRGL_BIND_VERTEX_BUFFER)
res->cacheable = TRUE;
return res;
}
static struct virgl_cmd_buf *virgl_vtest_cmd_buf_create(struct virgl_winsys *vws)
{
struct virgl_vtest_cmd_buf *cbuf;
cbuf = CALLOC_STRUCT(virgl_vtest_cmd_buf);
if (!cbuf)
return NULL;
cbuf->nres = 512;
cbuf->res_bo = CALLOC(cbuf->nres, sizeof(struct virgl_hw_buf*));
if (!cbuf->res_bo) {
FREE(cbuf);
return NULL;
}
cbuf->ws = vws;
cbuf->base.buf = cbuf->buf;
return &cbuf->base;
}
static void virgl_vtest_cmd_buf_destroy(struct virgl_cmd_buf *_cbuf)
{
struct virgl_vtest_cmd_buf *cbuf = virgl_vtest_cmd_buf(_cbuf);
FREE(cbuf->res_bo);
FREE(cbuf);
}
static boolean virgl_vtest_lookup_res(struct virgl_vtest_cmd_buf *cbuf,
struct virgl_hw_res *res)
{
unsigned hash = res->res_handle & (sizeof(cbuf->is_handle_added)-1);
int i;
if (cbuf->is_handle_added[hash]) {
i = cbuf->reloc_indices_hashlist[hash];
if (cbuf->res_bo[i] == res)
return true;
for (i = 0; i < cbuf->cres; i++) {
if (cbuf->res_bo[i] == res) {
cbuf->reloc_indices_hashlist[hash] = i;
return true;
}
}
}
return false;
}
static void virgl_vtest_release_all_res(struct virgl_vtest_winsys *vtws,
struct virgl_vtest_cmd_buf *cbuf)
{
int i;
for (i = 0; i < cbuf->cres; i++) {
p_atomic_dec(&cbuf->res_bo[i]->num_cs_references);
virgl_vtest_resource_reference(vtws, &cbuf->res_bo[i], NULL);
}
cbuf->cres = 0;
}
static void virgl_vtest_add_res(struct virgl_vtest_winsys *vtws,
struct virgl_vtest_cmd_buf *cbuf,
struct virgl_hw_res *res)
{
unsigned hash = res->res_handle & (sizeof(cbuf->is_handle_added)-1);
if (cbuf->cres > cbuf->nres) {
fprintf(stderr,"failure to add relocation\n");
return;
}
cbuf->res_bo[cbuf->cres] = NULL;
virgl_vtest_resource_reference(vtws, &cbuf->res_bo[cbuf->cres], res);
cbuf->is_handle_added[hash] = TRUE;
cbuf->reloc_indices_hashlist[hash] = cbuf->cres;
p_atomic_inc(&res->num_cs_references);
cbuf->cres++;
}
static int virgl_vtest_winsys_submit_cmd(struct virgl_winsys *vws,
struct virgl_cmd_buf *_cbuf)
{
struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
struct virgl_vtest_cmd_buf *cbuf = virgl_vtest_cmd_buf(_cbuf);
int ret;
if (cbuf->base.cdw == 0)
return 0;
ret = virgl_vtest_submit_cmd(vtws, cbuf);
virgl_vtest_release_all_res(vtws, cbuf);
memset(cbuf->is_handle_added, 0, sizeof(cbuf->is_handle_added));
cbuf->base.cdw = 0;
return ret;
}
static void virgl_vtest_emit_res(struct virgl_winsys *vws,
struct virgl_cmd_buf *_cbuf,
struct virgl_hw_res *res, boolean write_buf)
{
struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
struct virgl_vtest_cmd_buf *cbuf = virgl_vtest_cmd_buf(_cbuf);
boolean already_in_list = virgl_vtest_lookup_res(cbuf, res);
if (write_buf)
cbuf->base.buf[cbuf->base.cdw++] = res->res_handle;
if (!already_in_list)
virgl_vtest_add_res(vtws, cbuf, res);
}
static boolean virgl_vtest_res_is_ref(struct virgl_winsys *vws,
struct virgl_cmd_buf *_cbuf,
struct virgl_hw_res *res)
{
if (!res->num_cs_references)
return FALSE;
return TRUE;
}
static int virgl_vtest_get_caps(struct virgl_winsys *vws,
struct virgl_drm_caps *caps)
{
struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
return virgl_vtest_send_get_caps(vtws, caps);
}
static struct pipe_fence_handle *
virgl_cs_create_fence(struct virgl_winsys *vws)
{
struct virgl_hw_res *res;
res = virgl_vtest_winsys_resource_cache_create(vws,
PIPE_BUFFER,
PIPE_FORMAT_R8_UNORM,
PIPE_BIND_CUSTOM,
8, 1, 1, 0, 0, 0, 8);
return (struct pipe_fence_handle *)res;
}
static bool virgl_fence_wait(struct virgl_winsys *vws,
struct pipe_fence_handle *fence,
uint64_t timeout)
{
struct virgl_vtest_winsys *vdws = virgl_vtest_winsys(vws);
struct virgl_hw_res *res = virgl_hw_res(fence);
if (timeout == 0)
return !virgl_vtest_resource_is_busy(vdws, res);
if (timeout != PIPE_TIMEOUT_INFINITE) {
int64_t start_time = os_time_get();
timeout /= 1000;
while (virgl_vtest_resource_is_busy(vdws, res)) {
if (os_time_get() - start_time >= timeout)
return FALSE;
os_time_sleep(10);
}
return TRUE;
}
virgl_vtest_resource_wait(vws, res);
return TRUE;
}
static void virgl_fence_reference(struct virgl_winsys *vws,
struct pipe_fence_handle **dst,
struct pipe_fence_handle *src)
{
struct virgl_vtest_winsys *vdws = virgl_vtest_winsys(vws);
virgl_vtest_resource_reference(vdws, (struct virgl_hw_res **)dst,
virgl_hw_res(src));
}
static void virgl_vtest_flush_frontbuffer(struct virgl_winsys *vws,
struct virgl_hw_res *res,
unsigned level, unsigned layer,
void *winsys_drawable_handle,
struct pipe_box *sub_box)
{
struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
struct pipe_box box;
void *map;
uint32_t size;
uint32_t offset = 0, valid_stride;
if (!res->dt)
return;
memset(&box, 0, sizeof(box));
if (sub_box) {
box = *sub_box;
offset = box.y / util_format_get_blockheight(res->format) * res->stride +
box.x / util_format_get_blockwidth(res->format) * util_format_get_blocksize(res->format);
} else {
box.z = layer;
box.width = res->width;
box.height = res->height;
box.depth = 1;
}
size = vtest_get_transfer_size(res, &box, res->stride, 0, level, &valid_stride);
virgl_vtest_busy_wait(vtws, res->res_handle, VCMD_BUSY_WAIT_FLAG_WAIT);
map = vtws->sws->displaytarget_map(vtws->sws, res->dt, 0);
/* execute a transfer */
virgl_vtest_send_transfer_cmd(vtws, VCMD_TRANSFER_GET, res->res_handle,
level, res->stride, 0, &box, size);
virgl_vtest_recv_transfer_get_data(vtws, map + offset, size, valid_stride,
&box, res->format);
vtws->sws->displaytarget_unmap(vtws->sws, res->dt);
vtws->sws->displaytarget_display(vtws->sws, res->dt, winsys_drawable_handle,
sub_box);
}
static void
virgl_vtest_winsys_destroy(struct virgl_winsys *vws)
{
struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
virgl_cache_flush(vtws);
mtx_destroy(&vtws->mutex);
FREE(vtws);
}
struct virgl_winsys *
virgl_vtest_winsys_wrap(struct sw_winsys *sws)
{
struct virgl_vtest_winsys *vtws;
vtws = CALLOC_STRUCT(virgl_vtest_winsys);
if (!vtws)
return NULL;
virgl_vtest_connect(vtws);
vtws->sws = sws;
vtws->usecs = 1000000;
LIST_INITHEAD(&vtws->delayed);
(void) mtx_init(&vtws->mutex, mtx_plain);
vtws->base.destroy = virgl_vtest_winsys_destroy;
vtws->base.transfer_put = virgl_vtest_transfer_put;
vtws->base.transfer_get = virgl_vtest_transfer_get;
vtws->base.resource_create = virgl_vtest_winsys_resource_cache_create;
vtws->base.resource_unref = virgl_vtest_winsys_resource_unref;
vtws->base.resource_map = virgl_vtest_resource_map;
vtws->base.resource_wait = virgl_vtest_resource_wait;
vtws->base.cmd_buf_create = virgl_vtest_cmd_buf_create;
vtws->base.cmd_buf_destroy = virgl_vtest_cmd_buf_destroy;
vtws->base.submit_cmd = virgl_vtest_winsys_submit_cmd;
vtws->base.emit_res = virgl_vtest_emit_res;
vtws->base.res_is_referenced = virgl_vtest_res_is_ref;
vtws->base.get_caps = virgl_vtest_get_caps;
vtws->base.cs_create_fence = virgl_cs_create_fence;
vtws->base.fence_wait = virgl_fence_wait;
vtws->base.fence_reference = virgl_fence_reference;
vtws->base.flush_frontbuffer = virgl_vtest_flush_frontbuffer;
return &vtws->base;
}