|
|
@ -59,7 +59,7 @@ static inline const void *get_buf_ptr(const uint32_t *buf, uint32_t offset) |
|
|
|
return &buf[offset]; |
|
|
|
return &buf[offset]; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_create_shader(struct vrend_decode_ctx *ctx, |
|
|
|
static int vrend_decode_create_shader(struct vrend_context *ctx, |
|
|
|
const uint32_t *buf, |
|
|
|
const uint32_t *buf, |
|
|
|
uint32_t handle, |
|
|
|
uint32_t handle, |
|
|
|
uint16_t length) |
|
|
|
uint16_t length) |
|
|
@ -122,12 +122,12 @@ static int vrend_decode_create_shader(struct vrend_decode_ctx *ctx, |
|
|
|
memset(&so_info, 0, sizeof(so_info)); |
|
|
|
memset(&so_info, 0, sizeof(so_info)); |
|
|
|
|
|
|
|
|
|
|
|
shd_text = get_buf_ptr(buf, shader_offset); |
|
|
|
shd_text = get_buf_ptr(buf, shader_offset); |
|
|
|
ret = vrend_create_shader(ctx->grctx, handle, &so_info, req_local_mem, (const char *)shd_text, offlen, num_tokens, type, length - shader_offset + 1); |
|
|
|
ret = vrend_create_shader(ctx, handle, &so_info, req_local_mem, (const char *)shd_text, offlen, num_tokens, type, length - shader_offset + 1); |
|
|
|
|
|
|
|
|
|
|
|
return ret; |
|
|
|
return ret; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_create_stream_output_target(struct vrend_decode_ctx *ctx, const uint32_t *buf, |
|
|
|
static int vrend_decode_create_stream_output_target(struct vrend_context *ctx, const uint32_t *buf, |
|
|
|
uint32_t handle, uint16_t length) |
|
|
|
uint32_t handle, uint16_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
uint32_t res_handle, buffer_size, buffer_offset; |
|
|
|
uint32_t res_handle, buffer_size, buffer_offset; |
|
|
@ -139,11 +139,11 @@ static int vrend_decode_create_stream_output_target(struct vrend_decode_ctx *ctx |
|
|
|
buffer_offset = get_buf_entry(buf, VIRGL_OBJ_STREAMOUT_BUFFER_OFFSET); |
|
|
|
buffer_offset = get_buf_entry(buf, VIRGL_OBJ_STREAMOUT_BUFFER_OFFSET); |
|
|
|
buffer_size = get_buf_entry(buf, VIRGL_OBJ_STREAMOUT_BUFFER_SIZE); |
|
|
|
buffer_size = get_buf_entry(buf, VIRGL_OBJ_STREAMOUT_BUFFER_SIZE); |
|
|
|
|
|
|
|
|
|
|
|
return vrend_create_so_target(ctx->grctx, handle, res_handle, buffer_offset, |
|
|
|
return vrend_create_so_target(ctx, handle, res_handle, buffer_offset, |
|
|
|
buffer_size); |
|
|
|
buffer_size); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_set_framebuffer_state(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_set_framebuffer_state(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
if (length < 2) |
|
|
|
if (length < 2) |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
@ -161,11 +161,11 @@ static int vrend_decode_set_framebuffer_state(struct vrend_decode_ctx *ctx, cons |
|
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < nr_cbufs; i++) |
|
|
|
for (i = 0; i < nr_cbufs; i++) |
|
|
|
surf_handle[i] = get_buf_entry(buf, VIRGL_SET_FRAMEBUFFER_STATE_CBUF_HANDLE(i)); |
|
|
|
surf_handle[i] = get_buf_entry(buf, VIRGL_SET_FRAMEBUFFER_STATE_CBUF_HANDLE(i)); |
|
|
|
vrend_set_framebuffer_state(ctx->grctx, nr_cbufs, surf_handle, zsurf_handle); |
|
|
|
vrend_set_framebuffer_state(ctx, nr_cbufs, surf_handle, zsurf_handle); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_set_framebuffer_state_no_attach(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_set_framebuffer_state_no_attach(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
uint32_t width, height; |
|
|
|
uint32_t width, height; |
|
|
|
uint32_t layers, samples; |
|
|
|
uint32_t layers, samples; |
|
|
@ -182,11 +182,11 @@ static int vrend_decode_set_framebuffer_state_no_attach(struct vrend_decode_ctx |
|
|
|
layers = VIRGL_SET_FRAMEBUFFER_STATE_NO_ATTACH_LAYERS(tmp); |
|
|
|
layers = VIRGL_SET_FRAMEBUFFER_STATE_NO_ATTACH_LAYERS(tmp); |
|
|
|
samples = VIRGL_SET_FRAMEBUFFER_STATE_NO_ATTACH_SAMPLES(tmp); |
|
|
|
samples = VIRGL_SET_FRAMEBUFFER_STATE_NO_ATTACH_SAMPLES(tmp); |
|
|
|
|
|
|
|
|
|
|
|
vrend_set_framebuffer_state_no_attach(ctx->grctx, width, height, layers, samples); |
|
|
|
vrend_set_framebuffer_state_no_attach(ctx, width, height, layers, samples); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_clear(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_clear(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
union pipe_color_union color; |
|
|
|
union pipe_color_union color; |
|
|
|
double depth; |
|
|
|
double depth; |
|
|
@ -202,11 +202,11 @@ static int vrend_decode_clear(struct vrend_decode_ctx *ctx, const uint32_t *buf, |
|
|
|
memcpy(&depth, depth_ptr, sizeof(double)); |
|
|
|
memcpy(&depth, depth_ptr, sizeof(double)); |
|
|
|
stencil = get_buf_entry(buf, VIRGL_OBJ_CLEAR_STENCIL); |
|
|
|
stencil = get_buf_entry(buf, VIRGL_OBJ_CLEAR_STENCIL); |
|
|
|
|
|
|
|
|
|
|
|
vrend_clear(ctx->grctx, buffers, &color, depth, stencil); |
|
|
|
vrend_clear(ctx, buffers, &color, depth, stencil); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_clear_texture(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_clear_texture(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
struct pipe_box box; |
|
|
|
struct pipe_box box; |
|
|
|
uint32_t handle; |
|
|
|
uint32_t handle; |
|
|
@ -229,7 +229,7 @@ static int vrend_decode_clear_texture(struct vrend_decode_ctx *ctx, const uint32 |
|
|
|
arr[2] = get_buf_entry(buf, VIRGL_TEXTURE_ARRAY_C); |
|
|
|
arr[2] = get_buf_entry(buf, VIRGL_TEXTURE_ARRAY_C); |
|
|
|
arr[3] = get_buf_entry(buf, VIRGL_TEXTURE_ARRAY_D); |
|
|
|
arr[3] = get_buf_entry(buf, VIRGL_TEXTURE_ARRAY_D); |
|
|
|
|
|
|
|
|
|
|
|
vrend_clear_texture(ctx->grctx, handle, level, &box, (void *) &arr); |
|
|
|
vrend_clear_texture(ctx, handle, level, &box, (void *) &arr); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
@ -240,7 +240,7 @@ static float uif(unsigned int ui) |
|
|
|
return myuif.f; |
|
|
|
return myuif.f; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_set_viewport_state(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_set_viewport_state(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
struct pipe_viewport_state vps[PIPE_MAX_VIEWPORTS]; |
|
|
|
struct pipe_viewport_state vps[PIPE_MAX_VIEWPORTS]; |
|
|
|
uint i, v; |
|
|
|
uint i, v; |
|
|
@ -265,22 +265,22 @@ static int vrend_decode_set_viewport_state(struct vrend_decode_ctx *ctx, const u |
|
|
|
vps[v].translate[i] = uif(get_buf_entry(buf, VIRGL_SET_VIEWPORT_STATE_TRANSLATE_0(v) + i)); |
|
|
|
vps[v].translate[i] = uif(get_buf_entry(buf, VIRGL_SET_VIEWPORT_STATE_TRANSLATE_0(v) + i)); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
vrend_set_viewport_states(ctx->grctx, start_slot, num_viewports, vps); |
|
|
|
vrend_set_viewport_states(ctx, start_slot, num_viewports, vps); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_set_index_buffer(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_set_index_buffer(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
if (length != 1 && length != 3) |
|
|
|
if (length != 1 && length != 3) |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
|
vrend_set_index_buffer(ctx->grctx, |
|
|
|
vrend_set_index_buffer(ctx, |
|
|
|
get_buf_entry(buf, VIRGL_SET_INDEX_BUFFER_HANDLE), |
|
|
|
get_buf_entry(buf, VIRGL_SET_INDEX_BUFFER_HANDLE), |
|
|
|
(length == 3) ? get_buf_entry(buf, VIRGL_SET_INDEX_BUFFER_INDEX_SIZE) : 0, |
|
|
|
(length == 3) ? get_buf_entry(buf, VIRGL_SET_INDEX_BUFFER_INDEX_SIZE) : 0, |
|
|
|
(length == 3) ? get_buf_entry(buf, VIRGL_SET_INDEX_BUFFER_OFFSET) : 0); |
|
|
|
(length == 3) ? get_buf_entry(buf, VIRGL_SET_INDEX_BUFFER_OFFSET) : 0); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_set_constant_buffer(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_set_constant_buffer(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
uint32_t shader; |
|
|
|
uint32_t shader; |
|
|
|
uint32_t index; |
|
|
|
uint32_t index; |
|
|
@ -295,11 +295,11 @@ static int vrend_decode_set_constant_buffer(struct vrend_decode_ctx *ctx, const |
|
|
|
if (shader >= PIPE_SHADER_TYPES) |
|
|
|
if (shader >= PIPE_SHADER_TYPES) |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
|
|
|
|
|
|
|
|
|
vrend_set_constants(ctx->grctx, shader, index, nc, get_buf_ptr(buf, VIRGL_SET_CONSTANT_BUFFER_DATA_START)); |
|
|
|
vrend_set_constants(ctx, shader, index, nc, get_buf_ptr(buf, VIRGL_SET_CONSTANT_BUFFER_DATA_START)); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_set_uniform_buffer(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_set_uniform_buffer(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
if (length != VIRGL_SET_UNIFORM_BUFFER_SIZE) |
|
|
|
if (length != VIRGL_SET_UNIFORM_BUFFER_SIZE) |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
@ -316,11 +316,11 @@ static int vrend_decode_set_uniform_buffer(struct vrend_decode_ctx *ctx, const u |
|
|
|
if (index >= PIPE_MAX_CONSTANT_BUFFERS) |
|
|
|
if (index >= PIPE_MAX_CONSTANT_BUFFERS) |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
|
|
|
|
|
|
|
|
|
vrend_set_uniform_buffer(ctx->grctx, shader, index, offset, blength, handle); |
|
|
|
vrend_set_uniform_buffer(ctx, shader, index, offset, blength, handle); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_set_vertex_buffers(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_set_vertex_buffers(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
int num_vbo; |
|
|
|
int num_vbo; |
|
|
|
int i; |
|
|
|
int i; |
|
|
@ -334,16 +334,16 @@ static int vrend_decode_set_vertex_buffers(struct vrend_decode_ctx *ctx, const u |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < num_vbo; i++) { |
|
|
|
for (i = 0; i < num_vbo; i++) { |
|
|
|
vrend_set_single_vbo(ctx->grctx, i, |
|
|
|
vrend_set_single_vbo(ctx, i, |
|
|
|
get_buf_entry(buf, VIRGL_SET_VERTEX_BUFFER_STRIDE(i)), |
|
|
|
get_buf_entry(buf, VIRGL_SET_VERTEX_BUFFER_STRIDE(i)), |
|
|
|
get_buf_entry(buf, VIRGL_SET_VERTEX_BUFFER_OFFSET(i)), |
|
|
|
get_buf_entry(buf, VIRGL_SET_VERTEX_BUFFER_OFFSET(i)), |
|
|
|
get_buf_entry(buf, VIRGL_SET_VERTEX_BUFFER_HANDLE(i))); |
|
|
|
get_buf_entry(buf, VIRGL_SET_VERTEX_BUFFER_HANDLE(i))); |
|
|
|
} |
|
|
|
} |
|
|
|
vrend_set_num_vbo(ctx->grctx, num_vbo); |
|
|
|
vrend_set_num_vbo(ctx, num_vbo); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_set_sampler_views(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_set_sampler_views(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
uint32_t num_samps; |
|
|
|
uint32_t num_samps; |
|
|
|
uint32_t i; |
|
|
|
uint32_t i; |
|
|
@ -365,19 +365,16 @@ static int vrend_decode_set_sampler_views(struct vrend_decode_ctx *ctx, const ui |
|
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < num_samps; i++) { |
|
|
|
for (i = 0; i < num_samps; i++) { |
|
|
|
uint32_t handle = get_buf_entry(buf, VIRGL_SET_SAMPLER_VIEWS_V0_HANDLE + i); |
|
|
|
uint32_t handle = get_buf_entry(buf, VIRGL_SET_SAMPLER_VIEWS_V0_HANDLE + i); |
|
|
|
vrend_set_single_sampler_view(ctx->grctx, shader_type, i + start_slot, handle); |
|
|
|
vrend_set_single_sampler_view(ctx, shader_type, i + start_slot, handle); |
|
|
|
} |
|
|
|
} |
|
|
|
vrend_set_num_sampler_views(ctx->grctx, shader_type, start_slot, num_samps); |
|
|
|
vrend_set_num_sampler_views(ctx, shader_type, start_slot, num_samps); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static void vrend_decode_transfer_common(struct vrend_decode_ctx *ctx, |
|
|
|
static void vrend_decode_transfer_common(const uint32_t *buf, |
|
|
|
const uint32_t *buf, |
|
|
|
|
|
|
|
uint32_t *dst_handle, |
|
|
|
uint32_t *dst_handle, |
|
|
|
struct vrend_transfer_info *info) |
|
|
|
struct vrend_transfer_info *info) |
|
|
|
{ |
|
|
|
{ |
|
|
|
(void)ctx; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
*dst_handle = get_buf_entry(buf, VIRGL_RESOURCE_IW_RES_HANDLE); |
|
|
|
*dst_handle = get_buf_entry(buf, VIRGL_RESOURCE_IW_RES_HANDLE); |
|
|
|
|
|
|
|
|
|
|
|
info->level = get_buf_entry(buf, VIRGL_RESOURCE_IW_LEVEL); |
|
|
|
info->level = get_buf_entry(buf, VIRGL_RESOURCE_IW_LEVEL); |
|
|
@ -391,7 +388,7 @@ static void vrend_decode_transfer_common(struct vrend_decode_ctx *ctx, |
|
|
|
info->box->depth = get_buf_entry(buf, VIRGL_RESOURCE_IW_D); |
|
|
|
info->box->depth = get_buf_entry(buf, VIRGL_RESOURCE_IW_D); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_resource_inline_write(struct vrend_decode_ctx *ctx, const uint32_t *buf, |
|
|
|
static int vrend_decode_resource_inline_write(struct vrend_context *ctx, const uint32_t *buf, |
|
|
|
uint32_t length) |
|
|
|
uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
struct pipe_box box; |
|
|
|
struct pipe_box box; |
|
|
@ -406,7 +403,7 @@ static int vrend_decode_resource_inline_write(struct vrend_decode_ctx *ctx, cons |
|
|
|
|
|
|
|
|
|
|
|
memset(&info, 0, sizeof(info)); |
|
|
|
memset(&info, 0, sizeof(info)); |
|
|
|
info.box = &box; |
|
|
|
info.box = &box; |
|
|
|
vrend_decode_transfer_common(ctx, buf, &dst_handle, &info); |
|
|
|
vrend_decode_transfer_common(buf, &dst_handle, &info); |
|
|
|
data_len = (length - 11) * 4; |
|
|
|
data_len = (length - 11) * 4; |
|
|
|
data = get_buf_ptr(buf, VIRGL_RESOURCE_IW_DATA_START); |
|
|
|
data = get_buf_ptr(buf, VIRGL_RESOURCE_IW_DATA_START); |
|
|
|
|
|
|
|
|
|
|
@ -417,10 +414,10 @@ static int vrend_decode_resource_inline_write(struct vrend_decode_ctx *ctx, cons |
|
|
|
|
|
|
|
|
|
|
|
info.iovec = &dataiovec; |
|
|
|
info.iovec = &dataiovec; |
|
|
|
info.iovec_cnt = 1; |
|
|
|
info.iovec_cnt = 1; |
|
|
|
return vrend_transfer_inline_write(ctx->grctx, dst_handle, &info); |
|
|
|
return vrend_transfer_inline_write(ctx, dst_handle, &info); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_draw_vbo(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_draw_vbo(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
struct pipe_draw_info info; |
|
|
|
struct pipe_draw_info info; |
|
|
|
uint32_t cso; |
|
|
|
uint32_t cso; |
|
|
@ -458,10 +455,10 @@ static int vrend_decode_draw_vbo(struct vrend_decode_ctx *ctx, const uint32_t *b |
|
|
|
|
|
|
|
|
|
|
|
cso = get_buf_entry(buf, VIRGL_DRAW_VBO_COUNT_FROM_SO); |
|
|
|
cso = get_buf_entry(buf, VIRGL_DRAW_VBO_COUNT_FROM_SO); |
|
|
|
|
|
|
|
|
|
|
|
return vrend_draw_vbo(ctx->grctx, &info, cso, handle, indirect_draw_count_handle); |
|
|
|
return vrend_draw_vbo(ctx, &info, cso, handle, indirect_draw_count_handle); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_create_blend(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t handle, uint16_t length) |
|
|
|
static int vrend_decode_create_blend(struct vrend_context *ctx, const uint32_t *buf, uint32_t handle, uint16_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
struct pipe_blend_state *blend_state; |
|
|
|
struct pipe_blend_state *blend_state; |
|
|
|
uint32_t tmp; |
|
|
|
uint32_t tmp; |
|
|
@ -497,7 +494,7 @@ static int vrend_decode_create_blend(struct vrend_decode_ctx *ctx, const uint32_ |
|
|
|
blend_state->rt[i].colormask = (tmp >> 27) & 0xf; |
|
|
|
blend_state->rt[i].colormask = (tmp >> 27) & 0xf; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
tmp = vrend_renderer_object_insert(ctx->grctx, blend_state, handle, |
|
|
|
tmp = vrend_renderer_object_insert(ctx, blend_state, handle, |
|
|
|
VIRGL_OBJECT_BLEND); |
|
|
|
VIRGL_OBJECT_BLEND); |
|
|
|
if (tmp == 0) { |
|
|
|
if (tmp == 0) { |
|
|
|
FREE(blend_state); |
|
|
|
FREE(blend_state); |
|
|
@ -506,7 +503,7 @@ static int vrend_decode_create_blend(struct vrend_decode_ctx *ctx, const uint32_ |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_create_dsa(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t handle, uint16_t length) |
|
|
|
static int vrend_decode_create_dsa(struct vrend_context *ctx, const uint32_t *buf, uint32_t handle, uint16_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
int i; |
|
|
|
int i; |
|
|
|
struct pipe_depth_stencil_alpha_state *dsa_state; |
|
|
|
struct pipe_depth_stencil_alpha_state *dsa_state; |
|
|
@ -541,7 +538,7 @@ static int vrend_decode_create_dsa(struct vrend_decode_ctx *ctx, const uint32_t |
|
|
|
tmp = get_buf_entry(buf, VIRGL_OBJ_DSA_ALPHA_REF); |
|
|
|
tmp = get_buf_entry(buf, VIRGL_OBJ_DSA_ALPHA_REF); |
|
|
|
dsa_state->alpha.ref_value = uif(tmp); |
|
|
|
dsa_state->alpha.ref_value = uif(tmp); |
|
|
|
|
|
|
|
|
|
|
|
tmp = vrend_renderer_object_insert(ctx->grctx, dsa_state, handle, |
|
|
|
tmp = vrend_renderer_object_insert(ctx, dsa_state, handle, |
|
|
|
VIRGL_OBJECT_DSA); |
|
|
|
VIRGL_OBJECT_DSA); |
|
|
|
if (tmp == 0) { |
|
|
|
if (tmp == 0) { |
|
|
|
FREE(dsa_state); |
|
|
|
FREE(dsa_state); |
|
|
@ -550,7 +547,7 @@ static int vrend_decode_create_dsa(struct vrend_decode_ctx *ctx, const uint32_t |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_create_rasterizer(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t handle, uint16_t length) |
|
|
|
static int vrend_decode_create_rasterizer(struct vrend_context *ctx, const uint32_t *buf, uint32_t handle, uint16_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
struct pipe_rasterizer_state *rs_state; |
|
|
|
struct pipe_rasterizer_state *rs_state; |
|
|
|
uint32_t tmp; |
|
|
|
uint32_t tmp; |
|
|
@ -607,7 +604,7 @@ static int vrend_decode_create_rasterizer(struct vrend_decode_ctx *ctx, const ui |
|
|
|
rs_state->offset_scale = uif(get_buf_entry(buf, VIRGL_OBJ_RS_OFFSET_SCALE)); |
|
|
|
rs_state->offset_scale = uif(get_buf_entry(buf, VIRGL_OBJ_RS_OFFSET_SCALE)); |
|
|
|
rs_state->offset_clamp = uif(get_buf_entry(buf, VIRGL_OBJ_RS_OFFSET_CLAMP)); |
|
|
|
rs_state->offset_clamp = uif(get_buf_entry(buf, VIRGL_OBJ_RS_OFFSET_CLAMP)); |
|
|
|
|
|
|
|
|
|
|
|
tmp = vrend_renderer_object_insert(ctx->grctx, rs_state, handle, |
|
|
|
tmp = vrend_renderer_object_insert(ctx, rs_state, handle, |
|
|
|
VIRGL_OBJECT_RASTERIZER); |
|
|
|
VIRGL_OBJECT_RASTERIZER); |
|
|
|
if (tmp == 0) { |
|
|
|
if (tmp == 0) { |
|
|
|
FREE(rs_state); |
|
|
|
FREE(rs_state); |
|
|
@ -616,7 +613,7 @@ static int vrend_decode_create_rasterizer(struct vrend_decode_ctx *ctx, const ui |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_create_surface(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t handle, uint16_t length) |
|
|
|
static int vrend_decode_create_surface(struct vrend_context *ctx, const uint32_t *buf, uint32_t handle, uint16_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
uint32_t res_handle, format, val0, val1; |
|
|
|
uint32_t res_handle, format, val0, val1; |
|
|
|
int ret; |
|
|
|
int ret; |
|
|
@ -629,11 +626,11 @@ static int vrend_decode_create_surface(struct vrend_decode_ctx *ctx, const uint3 |
|
|
|
/* decide later if these are texture or buffer */ |
|
|
|
/* decide later if these are texture or buffer */ |
|
|
|
val0 = get_buf_entry(buf, VIRGL_OBJ_SURFACE_BUFFER_FIRST_ELEMENT); |
|
|
|
val0 = get_buf_entry(buf, VIRGL_OBJ_SURFACE_BUFFER_FIRST_ELEMENT); |
|
|
|
val1 = get_buf_entry(buf, VIRGL_OBJ_SURFACE_BUFFER_LAST_ELEMENT); |
|
|
|
val1 = get_buf_entry(buf, VIRGL_OBJ_SURFACE_BUFFER_LAST_ELEMENT); |
|
|
|
ret = vrend_create_surface(ctx->grctx, handle, res_handle, format, val0, val1); |
|
|
|
ret = vrend_create_surface(ctx, handle, res_handle, format, val0, val1); |
|
|
|
return ret; |
|
|
|
return ret; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_create_sampler_view(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t handle, uint16_t length) |
|
|
|
static int vrend_decode_create_sampler_view(struct vrend_context *ctx, const uint32_t *buf, uint32_t handle, uint16_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
uint32_t res_handle, format, val0, val1, swizzle_packed; |
|
|
|
uint32_t res_handle, format, val0, val1, swizzle_packed; |
|
|
|
|
|
|
|
|
|
|
@ -645,10 +642,10 @@ static int vrend_decode_create_sampler_view(struct vrend_decode_ctx *ctx, const |
|
|
|
val0 = get_buf_entry(buf, VIRGL_OBJ_SAMPLER_VIEW_BUFFER_FIRST_ELEMENT); |
|
|
|
val0 = get_buf_entry(buf, VIRGL_OBJ_SAMPLER_VIEW_BUFFER_FIRST_ELEMENT); |
|
|
|
val1 = get_buf_entry(buf, VIRGL_OBJ_SAMPLER_VIEW_BUFFER_LAST_ELEMENT); |
|
|
|
val1 = get_buf_entry(buf, VIRGL_OBJ_SAMPLER_VIEW_BUFFER_LAST_ELEMENT); |
|
|
|
swizzle_packed = get_buf_entry(buf, VIRGL_OBJ_SAMPLER_VIEW_SWIZZLE); |
|
|
|
swizzle_packed = get_buf_entry(buf, VIRGL_OBJ_SAMPLER_VIEW_SWIZZLE); |
|
|
|
return vrend_create_sampler_view(ctx->grctx, handle, res_handle, format, val0, val1,swizzle_packed); |
|
|
|
return vrend_create_sampler_view(ctx, handle, res_handle, format, val0, val1,swizzle_packed); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_create_sampler_state(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t handle, uint16_t length) |
|
|
|
static int vrend_decode_create_sampler_state(struct vrend_context *ctx, const uint32_t *buf, uint32_t handle, uint16_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
struct pipe_sampler_state state; |
|
|
|
struct pipe_sampler_state state; |
|
|
|
int i; |
|
|
|
int i; |
|
|
@ -679,10 +676,10 @@ static int vrend_decode_create_sampler_state(struct vrend_decode_ctx *ctx, const |
|
|
|
state.min_mip_filter != PIPE_TEX_MIPFILTER_NEAREST) |
|
|
|
state.min_mip_filter != PIPE_TEX_MIPFILTER_NEAREST) |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
|
|
|
|
|
|
|
|
|
return vrend_create_sampler_state(ctx->grctx, handle, &state); |
|
|
|
return vrend_create_sampler_state(ctx, handle, &state); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_create_ve(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t handle, uint16_t length) |
|
|
|
static int vrend_decode_create_ve(struct vrend_context *ctx, const uint32_t *buf, uint32_t handle, uint16_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
struct pipe_vertex_element *ve = NULL; |
|
|
|
struct pipe_vertex_element *ve = NULL; |
|
|
|
int num_elements; |
|
|
|
int num_elements; |
|
|
@ -717,13 +714,13 @@ static int vrend_decode_create_ve(struct vrend_decode_ctx *ctx, const uint32_t * |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
ret = vrend_create_vertex_elements_state(ctx->grctx, handle, num_elements, ve); |
|
|
|
ret = vrend_create_vertex_elements_state(ctx, handle, num_elements, ve); |
|
|
|
|
|
|
|
|
|
|
|
FREE(ve); |
|
|
|
FREE(ve); |
|
|
|
return ret; |
|
|
|
return ret; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_create_query(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t handle, uint16_t length) |
|
|
|
static int vrend_decode_create_query(struct vrend_context *ctx, const uint32_t *buf, uint32_t handle, uint16_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
uint32_t query_type; |
|
|
|
uint32_t query_type; |
|
|
|
uint32_t query_index; |
|
|
|
uint32_t query_index; |
|
|
@ -741,10 +738,10 @@ static int vrend_decode_create_query(struct vrend_decode_ctx *ctx, const uint32_ |
|
|
|
offset = get_buf_entry(buf, VIRGL_OBJ_QUERY_OFFSET); |
|
|
|
offset = get_buf_entry(buf, VIRGL_OBJ_QUERY_OFFSET); |
|
|
|
res_handle = get_buf_entry(buf, VIRGL_OBJ_QUERY_RES_HANDLE); |
|
|
|
res_handle = get_buf_entry(buf, VIRGL_OBJ_QUERY_RES_HANDLE); |
|
|
|
|
|
|
|
|
|
|
|
return vrend_create_query(ctx->grctx, handle, query_type, query_index, res_handle, offset); |
|
|
|
return vrend_create_query(ctx, handle, query_type, query_index, res_handle, offset); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_create_object(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_create_object(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
if (length < 1) |
|
|
|
if (length < 1) |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
@ -757,7 +754,7 @@ static int vrend_decode_create_object(struct vrend_decode_ctx *ctx, const uint32 |
|
|
|
if (handle == 0) |
|
|
|
if (handle == 0) |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
|
|
|
|
|
|
|
|
|
VREND_DEBUG(dbg_object, ctx->grctx," CREATE %-18s handle:0x%x len:%d\n", |
|
|
|
VREND_DEBUG(dbg_object, ctx," CREATE %-18s handle:0x%x len:%d\n", |
|
|
|
vrend_get_object_type_name(obj_type), handle, length); |
|
|
|
vrend_get_object_type_name(obj_type), handle, length); |
|
|
|
|
|
|
|
|
|
|
|
TRACE_SCOPE("CREATE %-18s", vrend_get_object_type_name(obj_type)); |
|
|
|
TRACE_SCOPE("CREATE %-18s", vrend_get_object_type_name(obj_type)); |
|
|
@ -800,7 +797,7 @@ static int vrend_decode_create_object(struct vrend_decode_ctx *ctx, const uint32 |
|
|
|
return ret; |
|
|
|
return ret; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_bind_object(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_bind_object(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
if (length != 1) |
|
|
|
if (length != 1) |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
@ -809,22 +806,22 @@ static int vrend_decode_bind_object(struct vrend_decode_ctx *ctx, const uint32_t |
|
|
|
uint32_t handle = get_buf_entry(buf, VIRGL_OBJ_BIND_HANDLE); |
|
|
|
uint32_t handle = get_buf_entry(buf, VIRGL_OBJ_BIND_HANDLE); |
|
|
|
uint8_t obj_type = (header >> 8) & 0xff; |
|
|
|
uint8_t obj_type = (header >> 8) & 0xff; |
|
|
|
|
|
|
|
|
|
|
|
VREND_DEBUG(dbg_object, ctx->grctx, |
|
|
|
VREND_DEBUG(dbg_object, ctx, |
|
|
|
" BIND %-20s handle:0x%x len:%d\n", |
|
|
|
" BIND %-20s handle:0x%x len:%d\n", |
|
|
|
vrend_get_object_type_name(obj_type), handle, length); |
|
|
|
vrend_get_object_type_name(obj_type), handle, length); |
|
|
|
|
|
|
|
|
|
|
|
switch (obj_type) { |
|
|
|
switch (obj_type) { |
|
|
|
case VIRGL_OBJECT_BLEND: |
|
|
|
case VIRGL_OBJECT_BLEND: |
|
|
|
vrend_object_bind_blend(ctx->grctx, handle); |
|
|
|
vrend_object_bind_blend(ctx, handle); |
|
|
|
break; |
|
|
|
break; |
|
|
|
case VIRGL_OBJECT_DSA: |
|
|
|
case VIRGL_OBJECT_DSA: |
|
|
|
vrend_object_bind_dsa(ctx->grctx, handle); |
|
|
|
vrend_object_bind_dsa(ctx, handle); |
|
|
|
break; |
|
|
|
break; |
|
|
|
case VIRGL_OBJECT_RASTERIZER: |
|
|
|
case VIRGL_OBJECT_RASTERIZER: |
|
|
|
vrend_object_bind_rasterizer(ctx->grctx, handle); |
|
|
|
vrend_object_bind_rasterizer(ctx, handle); |
|
|
|
break; |
|
|
|
break; |
|
|
|
case VIRGL_OBJECT_VERTEX_ELEMENTS: |
|
|
|
case VIRGL_OBJECT_VERTEX_ELEMENTS: |
|
|
|
vrend_bind_vertex_elements_state(ctx->grctx, handle); |
|
|
|
vrend_bind_vertex_elements_state(ctx, handle); |
|
|
|
break; |
|
|
|
break; |
|
|
|
default: |
|
|
|
default: |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
@ -833,23 +830,23 @@ static int vrend_decode_bind_object(struct vrend_decode_ctx *ctx, const uint32_t |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_destroy_object(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_destroy_object(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
if (length != 1) |
|
|
|
if (length != 1) |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
|
|
|
|
|
|
|
|
|
uint32_t handle = get_buf_entry(buf, VIRGL_OBJ_DESTROY_HANDLE); |
|
|
|
uint32_t handle = get_buf_entry(buf, VIRGL_OBJ_DESTROY_HANDLE); |
|
|
|
|
|
|
|
|
|
|
|
VREND_DEBUG_EXT(dbg_object, ctx->grctx, |
|
|
|
VREND_DEBUG_EXT(dbg_object, ctx, |
|
|
|
uint32_t obj = (get_buf_entry(buf, 0) >> 8) & 0xFF; |
|
|
|
uint32_t obj = (get_buf_entry(buf, 0) >> 8) & 0xFF; |
|
|
|
vrend_printf(" DESTROY %-17s handle:0x%x\n", |
|
|
|
vrend_printf(" DESTROY %-17s handle:0x%x\n", |
|
|
|
vrend_get_object_type_name(obj), handle)); |
|
|
|
vrend_get_object_type_name(obj), handle)); |
|
|
|
|
|
|
|
|
|
|
|
vrend_renderer_object_destroy(ctx->grctx, handle); |
|
|
|
vrend_renderer_object_destroy(ctx, handle); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_set_stencil_ref(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_set_stencil_ref(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
if (length != VIRGL_SET_STENCIL_REF_SIZE) |
|
|
|
if (length != VIRGL_SET_STENCIL_REF_SIZE) |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
@ -859,11 +856,11 @@ static int vrend_decode_set_stencil_ref(struct vrend_decode_ctx *ctx, const uint |
|
|
|
|
|
|
|
|
|
|
|
ref.ref_value[0] = val & 0xff; |
|
|
|
ref.ref_value[0] = val & 0xff; |
|
|
|
ref.ref_value[1] = (val >> 8) & 0xff; |
|
|
|
ref.ref_value[1] = (val >> 8) & 0xff; |
|
|
|
vrend_set_stencil_ref(ctx->grctx, &ref); |
|
|
|
vrend_set_stencil_ref(ctx, &ref); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_set_blend_color(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_set_blend_color(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
struct pipe_blend_color color; |
|
|
|
struct pipe_blend_color color; |
|
|
|
int i; |
|
|
|
int i; |
|
|
@ -874,11 +871,11 @@ static int vrend_decode_set_blend_color(struct vrend_decode_ctx *ctx, const uint |
|
|
|
for (i = 0; i < 4; i++) |
|
|
|
for (i = 0; i < 4; i++) |
|
|
|
color.color[i] = uif(get_buf_entry(buf, VIRGL_SET_BLEND_COLOR(i))); |
|
|
|
color.color[i] = uif(get_buf_entry(buf, VIRGL_SET_BLEND_COLOR(i))); |
|
|
|
|
|
|
|
|
|
|
|
vrend_set_blend_color(ctx->grctx, &color); |
|
|
|
vrend_set_blend_color(ctx, &color); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_set_scissor_state(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_set_scissor_state(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
struct pipe_scissor_state ss[PIPE_MAX_VIEWPORTS]; |
|
|
|
struct pipe_scissor_state ss[PIPE_MAX_VIEWPORTS]; |
|
|
|
uint32_t temp; |
|
|
|
uint32_t temp; |
|
|
@ -907,11 +904,11 @@ static int vrend_decode_set_scissor_state(struct vrend_decode_ctx *ctx, const ui |
|
|
|
ss[s].maxy = (temp >> 16) & 0xffff; |
|
|
|
ss[s].maxy = (temp >> 16) & 0xffff; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
vrend_set_scissor_state(ctx->grctx, start_slot, num_scissor, ss); |
|
|
|
vrend_set_scissor_state(ctx, start_slot, num_scissor, ss); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_set_polygon_stipple(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_set_polygon_stipple(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
struct pipe_poly_stipple ps; |
|
|
|
struct pipe_poly_stipple ps; |
|
|
|
int i; |
|
|
|
int i; |
|
|
@ -922,11 +919,11 @@ static int vrend_decode_set_polygon_stipple(struct vrend_decode_ctx *ctx, const |
|
|
|
for (i = 0; i < 32; i++) |
|
|
|
for (i = 0; i < 32; i++) |
|
|
|
ps.stipple[i] = get_buf_entry(buf, VIRGL_POLYGON_STIPPLE_P0 + i); |
|
|
|
ps.stipple[i] = get_buf_entry(buf, VIRGL_POLYGON_STIPPLE_P0 + i); |
|
|
|
|
|
|
|
|
|
|
|
vrend_set_polygon_stipple(ctx->grctx, &ps); |
|
|
|
vrend_set_polygon_stipple(ctx, &ps); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_set_clip_state(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_set_clip_state(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
struct pipe_clip_state clip; |
|
|
|
struct pipe_clip_state clip; |
|
|
|
int i, j; |
|
|
|
int i, j; |
|
|
@ -937,33 +934,33 @@ static int vrend_decode_set_clip_state(struct vrend_decode_ctx *ctx, const uint3 |
|
|
|
for (i = 0; i < 8; i++) |
|
|
|
for (i = 0; i < 8; i++) |
|
|
|
for (j = 0; j < 4; j++) |
|
|
|
for (j = 0; j < 4; j++) |
|
|
|
clip.ucp[i][j] = uif(get_buf_entry(buf, VIRGL_SET_CLIP_STATE_C0 + (i * 4) + j)); |
|
|
|
clip.ucp[i][j] = uif(get_buf_entry(buf, VIRGL_SET_CLIP_STATE_C0 + (i * 4) + j)); |
|
|
|
vrend_set_clip_state(ctx->grctx, &clip); |
|
|
|
vrend_set_clip_state(ctx, &clip); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_set_sample_mask(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_set_sample_mask(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
unsigned mask; |
|
|
|
unsigned mask; |
|
|
|
|
|
|
|
|
|
|
|
if (length != VIRGL_SET_SAMPLE_MASK_SIZE) |
|
|
|
if (length != VIRGL_SET_SAMPLE_MASK_SIZE) |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
|
mask = get_buf_entry(buf, VIRGL_SET_SAMPLE_MASK_MASK); |
|
|
|
mask = get_buf_entry(buf, VIRGL_SET_SAMPLE_MASK_MASK); |
|
|
|
vrend_set_sample_mask(ctx->grctx, mask); |
|
|
|
vrend_set_sample_mask(ctx, mask); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_set_min_samples(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_set_min_samples(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
unsigned min_samples; |
|
|
|
unsigned min_samples; |
|
|
|
|
|
|
|
|
|
|
|
if (length != VIRGL_SET_MIN_SAMPLES_SIZE) |
|
|
|
if (length != VIRGL_SET_MIN_SAMPLES_SIZE) |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
|
min_samples = get_buf_entry(buf, VIRGL_SET_MIN_SAMPLES_MASK); |
|
|
|
min_samples = get_buf_entry(buf, VIRGL_SET_MIN_SAMPLES_MASK); |
|
|
|
vrend_set_min_samples(ctx->grctx, min_samples); |
|
|
|
vrend_set_min_samples(ctx, min_samples); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_resource_copy_region(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_resource_copy_region(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
struct pipe_box box; |
|
|
|
struct pipe_box box; |
|
|
|
uint32_t dst_handle, src_handle; |
|
|
|
uint32_t dst_handle, src_handle; |
|
|
@ -987,7 +984,7 @@ static int vrend_decode_resource_copy_region(struct vrend_decode_ctx *ctx, const |
|
|
|
box.height = get_buf_entry(buf, VIRGL_CMD_RCR_SRC_H); |
|
|
|
box.height = get_buf_entry(buf, VIRGL_CMD_RCR_SRC_H); |
|
|
|
box.depth = get_buf_entry(buf, VIRGL_CMD_RCR_SRC_D); |
|
|
|
box.depth = get_buf_entry(buf, VIRGL_CMD_RCR_SRC_D); |
|
|
|
|
|
|
|
|
|
|
|
vrend_renderer_resource_copy_region(ctx->grctx, dst_handle, |
|
|
|
vrend_renderer_resource_copy_region(ctx, dst_handle, |
|
|
|
dst_level, dstx, dsty, dstz, |
|
|
|
dst_level, dstx, dsty, dstz, |
|
|
|
src_handle, src_level, |
|
|
|
src_handle, src_level, |
|
|
|
&box); |
|
|
|
&box); |
|
|
@ -995,7 +992,7 @@ static int vrend_decode_resource_copy_region(struct vrend_decode_ctx *ctx, const |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_blit(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_blit(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
struct pipe_blit_info info; |
|
|
|
struct pipe_blit_info info; |
|
|
|
uint32_t dst_handle, src_handle, temp; |
|
|
|
uint32_t dst_handle, src_handle, temp; |
|
|
@ -1034,11 +1031,11 @@ static int vrend_decode_blit(struct vrend_decode_ctx *ctx, const uint32_t *buf, |
|
|
|
info.src.box.height = get_buf_entry(buf, VIRGL_CMD_BLIT_SRC_H); |
|
|
|
info.src.box.height = get_buf_entry(buf, VIRGL_CMD_BLIT_SRC_H); |
|
|
|
info.src.box.depth = get_buf_entry(buf, VIRGL_CMD_BLIT_SRC_D); |
|
|
|
info.src.box.depth = get_buf_entry(buf, VIRGL_CMD_BLIT_SRC_D); |
|
|
|
|
|
|
|
|
|
|
|
vrend_renderer_blit(ctx->grctx, dst_handle, src_handle, &info); |
|
|
|
vrend_renderer_blit(ctx, dst_handle, src_handle, &info); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_bind_sampler_states(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_bind_sampler_states(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
if (length < 2) |
|
|
|
if (length < 2) |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
@ -1050,32 +1047,32 @@ static int vrend_decode_bind_sampler_states(struct vrend_decode_ctx *ctx, const |
|
|
|
if (shader_type >= PIPE_SHADER_TYPES) |
|
|
|
if (shader_type >= PIPE_SHADER_TYPES) |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
|
|
|
|
|
|
|
|
|
vrend_bind_sampler_states(ctx->grctx, shader_type, start_slot, num_states, |
|
|
|
vrend_bind_sampler_states(ctx, shader_type, start_slot, num_states, |
|
|
|
get_buf_ptr(buf, VIRGL_BIND_SAMPLER_STATES_S0_HANDLE)); |
|
|
|
get_buf_ptr(buf, VIRGL_BIND_SAMPLER_STATES_S0_HANDLE)); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_begin_query(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_begin_query(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
if (length != 1) |
|
|
|
if (length != 1) |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
|
|
|
|
|
|
|
|
|
uint32_t handle = get_buf_entry(buf, VIRGL_QUERY_BEGIN_HANDLE); |
|
|
|
uint32_t handle = get_buf_entry(buf, VIRGL_QUERY_BEGIN_HANDLE); |
|
|
|
|
|
|
|
|
|
|
|
return vrend_begin_query(ctx->grctx, handle); |
|
|
|
return vrend_begin_query(ctx, handle); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_end_query(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_end_query(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
if (length != 1) |
|
|
|
if (length != 1) |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
|
|
|
|
|
|
|
|
|
uint32_t handle = get_buf_entry(buf, VIRGL_QUERY_END_HANDLE); |
|
|
|
uint32_t handle = get_buf_entry(buf, VIRGL_QUERY_END_HANDLE); |
|
|
|
|
|
|
|
|
|
|
|
return vrend_end_query(ctx->grctx, handle); |
|
|
|
return vrend_end_query(ctx, handle); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_get_query_result(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_get_query_result(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
if (length != 2) |
|
|
|
if (length != 2) |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
@ -1083,11 +1080,11 @@ static int vrend_decode_get_query_result(struct vrend_decode_ctx *ctx, const uin |
|
|
|
uint32_t handle = get_buf_entry(buf, VIRGL_QUERY_RESULT_HANDLE); |
|
|
|
uint32_t handle = get_buf_entry(buf, VIRGL_QUERY_RESULT_HANDLE); |
|
|
|
uint32_t wait = get_buf_entry(buf, VIRGL_QUERY_RESULT_WAIT); |
|
|
|
uint32_t wait = get_buf_entry(buf, VIRGL_QUERY_RESULT_WAIT); |
|
|
|
|
|
|
|
|
|
|
|
vrend_get_query_result(ctx->grctx, handle, wait); |
|
|
|
vrend_get_query_result(ctx, handle, wait); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_get_query_result_qbo(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_get_query_result_qbo(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
if (length != VIRGL_QUERY_RESULT_QBO_SIZE) |
|
|
|
if (length != VIRGL_QUERY_RESULT_QBO_SIZE) |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
@ -1099,11 +1096,11 @@ static int vrend_decode_get_query_result_qbo(struct vrend_decode_ctx *ctx, const |
|
|
|
uint32_t offset = get_buf_entry(buf, VIRGL_QUERY_RESULT_QBO_OFFSET); |
|
|
|
uint32_t offset = get_buf_entry(buf, VIRGL_QUERY_RESULT_QBO_OFFSET); |
|
|
|
int32_t index = get_buf_entry(buf, VIRGL_QUERY_RESULT_QBO_INDEX); |
|
|
|
int32_t index = get_buf_entry(buf, VIRGL_QUERY_RESULT_QBO_INDEX); |
|
|
|
|
|
|
|
|
|
|
|
vrend_get_query_result_qbo(ctx->grctx, handle, qbo_handle, wait, result_type, offset, index); |
|
|
|
vrend_get_query_result_qbo(ctx, handle, qbo_handle, wait, result_type, offset, index); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_set_render_condition(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_set_render_condition(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
if (length != VIRGL_RENDER_CONDITION_SIZE) |
|
|
|
if (length != VIRGL_RENDER_CONDITION_SIZE) |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
@ -1112,44 +1109,44 @@ static int vrend_decode_set_render_condition(struct vrend_decode_ctx *ctx, const |
|
|
|
bool condition = get_buf_entry(buf, VIRGL_RENDER_CONDITION_CONDITION) & 1; |
|
|
|
bool condition = get_buf_entry(buf, VIRGL_RENDER_CONDITION_CONDITION) & 1; |
|
|
|
uint mode = get_buf_entry(buf, VIRGL_RENDER_CONDITION_MODE); |
|
|
|
uint mode = get_buf_entry(buf, VIRGL_RENDER_CONDITION_MODE); |
|
|
|
|
|
|
|
|
|
|
|
vrend_render_condition(ctx->grctx, handle, condition, mode); |
|
|
|
vrend_render_condition(ctx, handle, condition, mode); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_set_sub_ctx(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_set_sub_ctx(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
if (length != 1) |
|
|
|
if (length != 1) |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
|
|
|
|
|
|
|
|
|
uint32_t ctx_sub_id = get_buf_entry(buf, 1); |
|
|
|
uint32_t ctx_sub_id = get_buf_entry(buf, 1); |
|
|
|
|
|
|
|
|
|
|
|
vrend_renderer_set_sub_ctx(ctx->grctx, ctx_sub_id); |
|
|
|
vrend_renderer_set_sub_ctx(ctx, ctx_sub_id); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_create_sub_ctx(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_create_sub_ctx(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
if (length != 1) |
|
|
|
if (length != 1) |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
|
|
|
|
|
|
|
|
|
uint32_t ctx_sub_id = get_buf_entry(buf, 1); |
|
|
|
uint32_t ctx_sub_id = get_buf_entry(buf, 1); |
|
|
|
|
|
|
|
|
|
|
|
vrend_renderer_create_sub_ctx(ctx->grctx, ctx_sub_id); |
|
|
|
vrend_renderer_create_sub_ctx(ctx, ctx_sub_id); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_destroy_sub_ctx(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_destroy_sub_ctx(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
if (length != 1) |
|
|
|
if (length != 1) |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
|
|
|
|
|
|
|
|
|
uint32_t ctx_sub_id = get_buf_entry(buf, 1); |
|
|
|
uint32_t ctx_sub_id = get_buf_entry(buf, 1); |
|
|
|
|
|
|
|
|
|
|
|
vrend_renderer_destroy_sub_ctx(ctx->grctx, ctx_sub_id); |
|
|
|
vrend_renderer_destroy_sub_ctx(ctx, ctx_sub_id); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_bind_shader(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_bind_shader(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
uint32_t handle, type; |
|
|
|
uint32_t handle, type; |
|
|
|
if (length != VIRGL_BIND_SHADER_SIZE) |
|
|
|
if (length != VIRGL_BIND_SHADER_SIZE) |
|
|
@ -1158,11 +1155,11 @@ static int vrend_decode_bind_shader(struct vrend_decode_ctx *ctx, const uint32_t |
|
|
|
handle = get_buf_entry(buf, VIRGL_BIND_SHADER_HANDLE); |
|
|
|
handle = get_buf_entry(buf, VIRGL_BIND_SHADER_HANDLE); |
|
|
|
type = get_buf_entry(buf, VIRGL_BIND_SHADER_TYPE); |
|
|
|
type = get_buf_entry(buf, VIRGL_BIND_SHADER_TYPE); |
|
|
|
|
|
|
|
|
|
|
|
vrend_bind_shader(ctx->grctx, handle, type); |
|
|
|
vrend_bind_shader(ctx, handle, type); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_set_tess_state(struct vrend_decode_ctx *ctx, |
|
|
|
static int vrend_decode_set_tess_state(struct vrend_context *ctx, |
|
|
|
const uint32_t *buf, uint32_t length) |
|
|
|
const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
float tess_factors[6]; |
|
|
|
float tess_factors[6]; |
|
|
@ -1174,11 +1171,11 @@ static int vrend_decode_set_tess_state(struct vrend_decode_ctx *ctx, |
|
|
|
for (i = 0; i < 6; i++) { |
|
|
|
for (i = 0; i < 6; i++) { |
|
|
|
tess_factors[i] = uif(get_buf_entry(buf, i + 1)); |
|
|
|
tess_factors[i] = uif(get_buf_entry(buf, i + 1)); |
|
|
|
} |
|
|
|
} |
|
|
|
vrend_set_tess_state(ctx->grctx, tess_factors); |
|
|
|
vrend_set_tess_state(ctx, tess_factors); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_set_shader_buffers(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_set_shader_buffers(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
uint32_t num_ssbo; |
|
|
|
uint32_t num_ssbo; |
|
|
|
uint32_t shader_type, start_slot; |
|
|
|
uint32_t shader_type, start_slot; |
|
|
@ -1203,13 +1200,13 @@ static int vrend_decode_set_shader_buffers(struct vrend_decode_ctx *ctx, const u |
|
|
|
uint32_t offset = get_buf_entry(buf, VIRGL_SET_SHADER_BUFFER_OFFSET(i)); |
|
|
|
uint32_t offset = get_buf_entry(buf, VIRGL_SET_SHADER_BUFFER_OFFSET(i)); |
|
|
|
uint32_t buf_len = get_buf_entry(buf, VIRGL_SET_SHADER_BUFFER_LENGTH(i)); |
|
|
|
uint32_t buf_len = get_buf_entry(buf, VIRGL_SET_SHADER_BUFFER_LENGTH(i)); |
|
|
|
uint32_t handle = get_buf_entry(buf, VIRGL_SET_SHADER_BUFFER_RES_HANDLE(i)); |
|
|
|
uint32_t handle = get_buf_entry(buf, VIRGL_SET_SHADER_BUFFER_RES_HANDLE(i)); |
|
|
|
vrend_set_single_ssbo(ctx->grctx, shader_type, start_slot + i, offset, buf_len, |
|
|
|
vrend_set_single_ssbo(ctx, shader_type, start_slot + i, offset, buf_len, |
|
|
|
handle); |
|
|
|
handle); |
|
|
|
} |
|
|
|
} |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_set_atomic_buffers(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_set_atomic_buffers(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
uint32_t num_abo; |
|
|
|
uint32_t num_abo; |
|
|
|
uint32_t start_slot; |
|
|
|
uint32_t start_slot; |
|
|
@ -1231,13 +1228,13 @@ static int vrend_decode_set_atomic_buffers(struct vrend_decode_ctx *ctx, const u |
|
|
|
uint32_t offset = get_buf_entry(buf, i * VIRGL_SET_ATOMIC_BUFFER_ELEMENT_SIZE + 2); |
|
|
|
uint32_t offset = get_buf_entry(buf, i * VIRGL_SET_ATOMIC_BUFFER_ELEMENT_SIZE + 2); |
|
|
|
uint32_t buf_len = get_buf_entry(buf, i * VIRGL_SET_ATOMIC_BUFFER_ELEMENT_SIZE + 3); |
|
|
|
uint32_t buf_len = get_buf_entry(buf, i * VIRGL_SET_ATOMIC_BUFFER_ELEMENT_SIZE + 3); |
|
|
|
uint32_t handle = get_buf_entry(buf, i * VIRGL_SET_ATOMIC_BUFFER_ELEMENT_SIZE + 4); |
|
|
|
uint32_t handle = get_buf_entry(buf, i * VIRGL_SET_ATOMIC_BUFFER_ELEMENT_SIZE + 4); |
|
|
|
vrend_set_single_abo(ctx->grctx, start_slot + i, offset, buf_len, handle); |
|
|
|
vrend_set_single_abo(ctx, start_slot + i, offset, buf_len, handle); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_set_shader_images(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_set_shader_images(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
uint32_t num_images; |
|
|
|
uint32_t num_images; |
|
|
|
uint32_t shader_type, start_slot; |
|
|
|
uint32_t shader_type, start_slot; |
|
|
@ -1263,23 +1260,23 @@ static int vrend_decode_set_shader_images(struct vrend_decode_ctx *ctx, const ui |
|
|
|
uint32_t layer_offset = get_buf_entry(buf, VIRGL_SET_SHADER_IMAGE_LAYER_OFFSET(i)); |
|
|
|
uint32_t layer_offset = get_buf_entry(buf, VIRGL_SET_SHADER_IMAGE_LAYER_OFFSET(i)); |
|
|
|
uint32_t level_size = get_buf_entry(buf, VIRGL_SET_SHADER_IMAGE_LEVEL_SIZE(i)); |
|
|
|
uint32_t level_size = get_buf_entry(buf, VIRGL_SET_SHADER_IMAGE_LEVEL_SIZE(i)); |
|
|
|
uint32_t handle = get_buf_entry(buf, VIRGL_SET_SHADER_IMAGE_RES_HANDLE(i)); |
|
|
|
uint32_t handle = get_buf_entry(buf, VIRGL_SET_SHADER_IMAGE_RES_HANDLE(i)); |
|
|
|
vrend_set_single_image_view(ctx->grctx, shader_type, start_slot + i, format, access, |
|
|
|
vrend_set_single_image_view(ctx, shader_type, start_slot + i, format, access, |
|
|
|
layer_offset, level_size, handle); |
|
|
|
layer_offset, level_size, handle); |
|
|
|
} |
|
|
|
} |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_memory_barrier(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_memory_barrier(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
if (length != VIRGL_MEMORY_BARRIER_SIZE) |
|
|
|
if (length != VIRGL_MEMORY_BARRIER_SIZE) |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
|
|
|
|
|
|
|
|
|
unsigned flags = get_buf_entry(buf, VIRGL_MEMORY_BARRIER_FLAGS); |
|
|
|
unsigned flags = get_buf_entry(buf, VIRGL_MEMORY_BARRIER_FLAGS); |
|
|
|
vrend_memory_barrier(ctx->grctx, flags); |
|
|
|
vrend_memory_barrier(ctx, flags); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_launch_grid(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_launch_grid(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
uint32_t block[3], grid[3]; |
|
|
|
uint32_t block[3], grid[3]; |
|
|
|
uint32_t indirect_handle, indirect_offset; |
|
|
|
uint32_t indirect_handle, indirect_offset; |
|
|
@ -1294,11 +1291,11 @@ static int vrend_decode_launch_grid(struct vrend_decode_ctx *ctx, const uint32_t |
|
|
|
grid[2] = get_buf_entry(buf, VIRGL_LAUNCH_GRID_Z); |
|
|
|
grid[2] = get_buf_entry(buf, VIRGL_LAUNCH_GRID_Z); |
|
|
|
indirect_handle = get_buf_entry(buf, VIRGL_LAUNCH_INDIRECT_HANDLE); |
|
|
|
indirect_handle = get_buf_entry(buf, VIRGL_LAUNCH_INDIRECT_HANDLE); |
|
|
|
indirect_offset = get_buf_entry(buf, VIRGL_LAUNCH_INDIRECT_OFFSET); |
|
|
|
indirect_offset = get_buf_entry(buf, VIRGL_LAUNCH_INDIRECT_OFFSET); |
|
|
|
vrend_launch_grid(ctx->grctx, block, grid, indirect_handle, indirect_offset); |
|
|
|
vrend_launch_grid(ctx, block, grid, indirect_handle, indirect_offset); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_set_streamout_targets(struct vrend_decode_ctx *ctx, |
|
|
|
static int vrend_decode_set_streamout_targets(struct vrend_context *ctx, |
|
|
|
const uint32_t *buf, uint32_t length) |
|
|
|
const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
uint32_t handles[16]; |
|
|
|
uint32_t handles[16]; |
|
|
@ -1314,21 +1311,21 @@ static int vrend_decode_set_streamout_targets(struct vrend_decode_ctx *ctx, |
|
|
|
append_bitmask = get_buf_entry(buf, VIRGL_SET_STREAMOUT_TARGETS_APPEND_BITMASK); |
|
|
|
append_bitmask = get_buf_entry(buf, VIRGL_SET_STREAMOUT_TARGETS_APPEND_BITMASK); |
|
|
|
for (i = 0; i < num_handles; i++) |
|
|
|
for (i = 0; i < num_handles; i++) |
|
|
|
handles[i] = get_buf_entry(buf, VIRGL_SET_STREAMOUT_TARGETS_H0 + i); |
|
|
|
handles[i] = get_buf_entry(buf, VIRGL_SET_STREAMOUT_TARGETS_H0 + i); |
|
|
|
vrend_set_streamout_targets(ctx->grctx, append_bitmask, num_handles, handles); |
|
|
|
vrend_set_streamout_targets(ctx, append_bitmask, num_handles, handles); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_texture_barrier(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_texture_barrier(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
if (length != VIRGL_TEXTURE_BARRIER_SIZE) |
|
|
|
if (length != VIRGL_TEXTURE_BARRIER_SIZE) |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
|
|
|
|
|
|
|
|
|
unsigned flags = get_buf_entry(buf, VIRGL_TEXTURE_BARRIER_FLAGS); |
|
|
|
unsigned flags = get_buf_entry(buf, VIRGL_TEXTURE_BARRIER_FLAGS); |
|
|
|
vrend_texture_barrier(ctx->grctx, flags); |
|
|
|
vrend_texture_barrier(ctx, flags); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_set_debug_mask(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_set_debug_mask(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
char *flagstring; |
|
|
|
char *flagstring; |
|
|
|
int slen = sizeof(uint32_t) * length; |
|
|
|
int slen = sizeof(uint32_t) * length; |
|
|
@ -1345,14 +1342,14 @@ static int vrend_decode_set_debug_mask(struct vrend_decode_ctx *ctx, const uint3 |
|
|
|
|
|
|
|
|
|
|
|
memcpy(flagstring, flag_buf, slen); |
|
|
|
memcpy(flagstring, flag_buf, slen); |
|
|
|
flagstring[slen] = 0; |
|
|
|
flagstring[slen] = 0; |
|
|
|
vrend_context_set_debug_flags(ctx->grctx, flagstring); |
|
|
|
vrend_context_set_debug_flags(ctx, flagstring); |
|
|
|
|
|
|
|
|
|
|
|
free(flagstring); |
|
|
|
free(flagstring); |
|
|
|
|
|
|
|
|
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_set_tweaks(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_set_tweaks(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
VREND_DEBUG(dbg_tweak, NULL, "Received TWEAK set command\n"); |
|
|
|
VREND_DEBUG(dbg_tweak, NULL, "Received TWEAK set command\n"); |
|
|
|
|
|
|
|
|
|
|
@ -1362,12 +1359,12 @@ static int vrend_decode_set_tweaks(struct vrend_decode_ctx *ctx, const uint32_t |
|
|
|
uint32_t tweak_id = get_buf_entry(buf, VIRGL_SET_TWEAKS_ID); |
|
|
|
uint32_t tweak_id = get_buf_entry(buf, VIRGL_SET_TWEAKS_ID); |
|
|
|
uint32_t tweak_value = get_buf_entry(buf, VIRGL_SET_TWEAKS_VALUE); |
|
|
|
uint32_t tweak_value = get_buf_entry(buf, VIRGL_SET_TWEAKS_VALUE); |
|
|
|
|
|
|
|
|
|
|
|
vrend_set_active_tweaks(vrend_get_context_tweaks(ctx->grctx), tweak_id, tweak_value); |
|
|
|
vrend_set_active_tweaks(vrend_get_context_tweaks(ctx), tweak_id, tweak_value); |
|
|
|
return 0; |
|
|
|
return 0; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_transfer3d(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_transfer3d(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
struct pipe_box box; |
|
|
|
struct pipe_box box; |
|
|
|
uint32_t dst_handle; |
|
|
|
uint32_t dst_handle; |
|
|
@ -1378,7 +1375,7 @@ static int vrend_decode_transfer3d(struct vrend_decode_ctx *ctx, const uint32_t |
|
|
|
|
|
|
|
|
|
|
|
memset(&info, 0, sizeof(info)); |
|
|
|
memset(&info, 0, sizeof(info)); |
|
|
|
info.box = &box; |
|
|
|
info.box = &box; |
|
|
|
vrend_decode_transfer_common(ctx, buf, &dst_handle, &info); |
|
|
|
vrend_decode_transfer_common(buf, &dst_handle, &info); |
|
|
|
info.offset = get_buf_entry(buf, VIRGL_TRANSFER3D_DATA_OFFSET); |
|
|
|
info.offset = get_buf_entry(buf, VIRGL_TRANSFER3D_DATA_OFFSET); |
|
|
|
int transfer_mode = get_buf_entry(buf, VIRGL_TRANSFER3D_DIRECTION); |
|
|
|
int transfer_mode = get_buf_entry(buf, VIRGL_TRANSFER3D_DIRECTION); |
|
|
|
|
|
|
|
|
|
|
@ -1386,11 +1383,11 @@ static int vrend_decode_transfer3d(struct vrend_decode_ctx *ctx, const uint32_t |
|
|
|
transfer_mode != VIRGL_TRANSFER_FROM_HOST) |
|
|
|
transfer_mode != VIRGL_TRANSFER_FROM_HOST) |
|
|
|
return EINVAL; |
|
|
|
return EINVAL; |
|
|
|
|
|
|
|
|
|
|
|
return vrend_renderer_transfer_iov(ctx->grctx, dst_handle, &info, |
|
|
|
return vrend_renderer_transfer_iov(ctx, dst_handle, &info, |
|
|
|
transfer_mode); |
|
|
|
transfer_mode); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_copy_transfer3d(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_copy_transfer3d(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
struct pipe_box box; |
|
|
|
struct pipe_box box; |
|
|
|
struct vrend_transfer_info info; |
|
|
|
struct vrend_transfer_info info; |
|
|
@ -1402,17 +1399,17 @@ static int vrend_decode_copy_transfer3d(struct vrend_decode_ctx *ctx, const uint |
|
|
|
|
|
|
|
|
|
|
|
memset(&info, 0, sizeof(info)); |
|
|
|
memset(&info, 0, sizeof(info)); |
|
|
|
info.box = &box; |
|
|
|
info.box = &box; |
|
|
|
vrend_decode_transfer_common(ctx, buf, &dst_handle, &info); |
|
|
|
vrend_decode_transfer_common(buf, &dst_handle, &info); |
|
|
|
info.offset = get_buf_entry(buf, VIRGL_COPY_TRANSFER3D_SRC_RES_OFFSET); |
|
|
|
info.offset = get_buf_entry(buf, VIRGL_COPY_TRANSFER3D_SRC_RES_OFFSET); |
|
|
|
info.synchronized = (get_buf_entry(buf, VIRGL_COPY_TRANSFER3D_SYNCHRONIZED) != 0); |
|
|
|
info.synchronized = (get_buf_entry(buf, VIRGL_COPY_TRANSFER3D_SYNCHRONIZED) != 0); |
|
|
|
|
|
|
|
|
|
|
|
src_handle = get_buf_entry(buf, VIRGL_COPY_TRANSFER3D_SRC_RES_HANDLE); |
|
|
|
src_handle = get_buf_entry(buf, VIRGL_COPY_TRANSFER3D_SRC_RES_HANDLE); |
|
|
|
|
|
|
|
|
|
|
|
return vrend_renderer_copy_transfer3d(ctx->grctx, dst_handle, src_handle, |
|
|
|
return vrend_renderer_copy_transfer3d(ctx, dst_handle, src_handle, |
|
|
|
&info); |
|
|
|
&info); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_pipe_resource_create(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_pipe_resource_create(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
struct vrend_renderer_resource_create_args args = { 0 }; |
|
|
|
struct vrend_renderer_resource_create_args args = { 0 }; |
|
|
|
uint32_t blob_id; |
|
|
|
uint32_t blob_id; |
|
|
@ -1432,7 +1429,7 @@ static int vrend_decode_pipe_resource_create(struct vrend_decode_ctx *ctx, const |
|
|
|
args.flags = get_buf_entry(buf, VIRGL_PIPE_RES_CREATE_FLAGS); |
|
|
|
args.flags = get_buf_entry(buf, VIRGL_PIPE_RES_CREATE_FLAGS); |
|
|
|
blob_id = get_buf_entry(buf, VIRGL_PIPE_RES_CREATE_BLOB_ID); |
|
|
|
blob_id = get_buf_entry(buf, VIRGL_PIPE_RES_CREATE_BLOB_ID); |
|
|
|
|
|
|
|
|
|
|
|
return vrend_renderer_pipe_resource_create(ctx->grctx, blob_id, &args); |
|
|
|
return vrend_renderer_pipe_resource_create(ctx, blob_id, &args); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static void vrend_decode_ctx_init_base(struct vrend_decode_ctx *dctx, |
|
|
|
static void vrend_decode_ctx_init_base(struct vrend_decode_ctx *dctx, |
|
|
@ -1515,9 +1512,9 @@ static int vrend_decode_ctx_get_blob(struct virgl_context *ctx, |
|
|
|
return blob->u.pipe_resource ? 0 : EINVAL; |
|
|
|
return blob->u.pipe_resource ? 0 : EINVAL; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
typedef int (*vrend_decode_callback)(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length); |
|
|
|
typedef int (*vrend_decode_callback)(struct vrend_context *ctx, const uint32_t *buf, uint32_t length); |
|
|
|
|
|
|
|
|
|
|
|
static int vrend_decode_dummy(struct vrend_decode_ctx *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
static int vrend_decode_dummy(struct vrend_context *ctx, const uint32_t *buf, uint32_t length) |
|
|
|
{ |
|
|
|
{ |
|
|
|
(void)ctx; |
|
|
|
(void)ctx; |
|
|
|
(void)buf; |
|
|
|
(void)buf; |
|
|
@ -1615,12 +1612,12 @@ static int vrend_decode_ctx_submit_cmd(struct virgl_context *ctx, |
|
|
|
break; |
|
|
|
break; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
VREND_DEBUG(dbg_cmd, gdctx->grctx,"%-4d %-20s len:%d\n", |
|
|
|
VREND_DEBUG(dbg_cmd, gdctx->grctx, "%-4d %-20s len:%d\n", |
|
|
|
cur_offset, vrend_get_comand_name(cmd), len); |
|
|
|
cur_offset, vrend_get_comand_name(cmd), len); |
|
|
|
|
|
|
|
|
|
|
|
TRACE_SCOPE("%s", vrend_get_comand_name(cmd)); |
|
|
|
TRACE_SCOPE("%s", vrend_get_comand_name(cmd)); |
|
|
|
|
|
|
|
|
|
|
|
ret = decode_table[cmd](gdctx, buf, len); |
|
|
|
ret = decode_table[cmd](gdctx->grctx, buf, len); |
|
|
|
if (ret) { |
|
|
|
if (ret) { |
|
|
|
if (ret == EINVAL) { |
|
|
|
if (ret == EINVAL) { |
|
|
|
vrend_report_buffer_error(gdctx->grctx, *buf); |
|
|
|
vrend_report_buffer_error(gdctx->grctx, *buf); |
|
|
|