532 lines
21 KiB
C
532 lines
21 KiB
C
/*
|
|
* Copyright © 2014-2017 Broadcom
|
|
*
|
|
* 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, sublicense,
|
|
* 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 NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS 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 "util/u_pack_color.h"
|
|
#include "util/u_upload_mgr.h"
|
|
|
|
#include "v3d_context.h"
|
|
#include "compiler/v3d_compiler.h"
|
|
|
|
/* We don't expect that the packets we use in this file change across across
|
|
* hw versions, so we just include directly the v33 header
|
|
*/
|
|
#include "broadcom/cle/v3d_packet_v33_pack.h"
|
|
|
|
static uint32_t
|
|
get_texrect_scale(struct v3d_texture_stateobj *texstate,
|
|
enum quniform_contents contents,
|
|
uint32_t data)
|
|
{
|
|
struct pipe_sampler_view *texture = texstate->textures[data];
|
|
uint32_t dim;
|
|
|
|
if (contents == QUNIFORM_TEXRECT_SCALE_X)
|
|
dim = texture->texture->width0;
|
|
else
|
|
dim = texture->texture->height0;
|
|
|
|
return fui(1.0f / dim);
|
|
}
|
|
|
|
static uint32_t
|
|
get_texture_size(struct v3d_texture_stateobj *texstate,
|
|
enum quniform_contents contents,
|
|
uint32_t data)
|
|
{
|
|
struct pipe_sampler_view *texture = texstate->textures[data];
|
|
switch (contents) {
|
|
case QUNIFORM_TEXTURE_WIDTH:
|
|
if (texture->target == PIPE_BUFFER) {
|
|
return texture->u.buf.size /
|
|
util_format_get_blocksize(texture->format);
|
|
} else {
|
|
return u_minify(texture->texture->width0,
|
|
texture->u.tex.first_level);
|
|
}
|
|
case QUNIFORM_TEXTURE_HEIGHT:
|
|
return u_minify(texture->texture->height0,
|
|
texture->u.tex.first_level);
|
|
case QUNIFORM_TEXTURE_DEPTH:
|
|
assert(texture->target != PIPE_BUFFER);
|
|
return u_minify(texture->texture->depth0,
|
|
texture->u.tex.first_level);
|
|
case QUNIFORM_TEXTURE_ARRAY_SIZE:
|
|
assert(texture->target != PIPE_BUFFER);
|
|
return texture->texture->array_size;
|
|
case QUNIFORM_TEXTURE_LEVELS:
|
|
assert(texture->target != PIPE_BUFFER);
|
|
return (texture->u.tex.last_level -
|
|
texture->u.tex.first_level) + 1;
|
|
default:
|
|
unreachable("Bad texture size field");
|
|
}
|
|
}
|
|
|
|
static uint32_t
|
|
get_image_size(struct v3d_shaderimg_stateobj *shaderimg,
|
|
enum quniform_contents contents,
|
|
uint32_t data)
|
|
{
|
|
struct v3d_image_view *image = &shaderimg->si[data];
|
|
|
|
switch (contents) {
|
|
case QUNIFORM_IMAGE_WIDTH:
|
|
if (image->base.resource->target == PIPE_BUFFER) {
|
|
return image->base.u.buf.size /
|
|
util_format_get_blocksize(image->base.format);
|
|
} else {
|
|
return u_minify(image->base.resource->width0,
|
|
image->base.u.tex.level);
|
|
}
|
|
case QUNIFORM_IMAGE_HEIGHT:
|
|
assert(image->base.resource->target != PIPE_BUFFER);
|
|
return u_minify(image->base.resource->height0,
|
|
image->base.u.tex.level);
|
|
case QUNIFORM_IMAGE_DEPTH:
|
|
assert(image->base.resource->target != PIPE_BUFFER);
|
|
return u_minify(image->base.resource->depth0,
|
|
image->base.u.tex.level);
|
|
case QUNIFORM_IMAGE_ARRAY_SIZE:
|
|
assert(image->base.resource->target != PIPE_BUFFER);
|
|
return image->base.resource->array_size;
|
|
default:
|
|
unreachable("Bad texture size field");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Writes the V3D 3.x P0 (CFG_MODE=1) texture parameter.
|
|
*
|
|
* Some bits of this field are dependent on the type of sample being done by
|
|
* the shader, while other bits are dependent on the sampler state. We OR the
|
|
* two together here.
|
|
*/
|
|
static void
|
|
write_texture_p0(struct v3d_job *job,
|
|
struct v3d_cl_out **uniforms,
|
|
struct v3d_texture_stateobj *texstate,
|
|
uint32_t unit,
|
|
uint32_t shader_data)
|
|
{
|
|
struct pipe_sampler_state *psampler = texstate->samplers[unit];
|
|
struct v3d_sampler_state *sampler = v3d_sampler_state(psampler);
|
|
|
|
cl_aligned_u32(uniforms, shader_data | sampler->p0);
|
|
}
|
|
|
|
/** Writes the V3D 3.x P1 (CFG_MODE=1) texture parameter. */
|
|
static void
|
|
write_texture_p1(struct v3d_job *job,
|
|
struct v3d_cl_out **uniforms,
|
|
struct v3d_texture_stateobj *texstate,
|
|
uint32_t data)
|
|
{
|
|
/* Extract the texture unit from the top bits, and the compiler's
|
|
* packed p1 from the bottom.
|
|
*/
|
|
uint32_t unit = data >> 5;
|
|
uint32_t p1 = data & 0x1f;
|
|
|
|
struct pipe_sampler_view *psview = texstate->textures[unit];
|
|
struct v3d_sampler_view *sview = v3d_sampler_view(psview);
|
|
|
|
struct V3D33_TEXTURE_UNIFORM_PARAMETER_1_CFG_MODE1 unpacked = {
|
|
.texture_state_record_base_address = texstate->texture_state[unit],
|
|
};
|
|
|
|
uint32_t packed;
|
|
V3D33_TEXTURE_UNIFORM_PARAMETER_1_CFG_MODE1_pack(&job->indirect,
|
|
(uint8_t *)&packed,
|
|
&unpacked);
|
|
|
|
cl_aligned_u32(uniforms, p1 | packed | sview->p1);
|
|
}
|
|
|
|
/** Writes the V3D 4.x TMU configuration parameter 0. */
|
|
static void
|
|
write_tmu_p0(struct v3d_job *job,
|
|
struct v3d_cl_out **uniforms,
|
|
struct v3d_texture_stateobj *texstate,
|
|
uint32_t data)
|
|
{
|
|
int unit = v3d_unit_data_get_unit(data);
|
|
struct pipe_sampler_view *psview = texstate->textures[unit];
|
|
struct v3d_sampler_view *sview = v3d_sampler_view(psview);
|
|
/* GL_OES_texture_buffer spec:
|
|
* "If no buffer object is bound to the buffer texture, the
|
|
* results of the texel access are undefined."
|
|
*
|
|
* This can be interpreted as allowing any result to come back, but
|
|
* not terminate the program (and some tests interpret that).
|
|
*
|
|
* FIXME: just return is not a full valid solution, as it could still
|
|
* try to get a wrong address for the shader state address. Perhaps we
|
|
* would need to set up a BO with a "default texture state"
|
|
*/
|
|
if (sview == NULL)
|
|
return;
|
|
|
|
struct v3d_resource *rsc = v3d_resource(sview->texture);
|
|
|
|
cl_aligned_reloc(&job->indirect, uniforms, sview->bo,
|
|
v3d_unit_data_get_offset(data));
|
|
v3d_job_add_bo(job, rsc->bo);
|
|
}
|
|
|
|
static void
|
|
write_image_tmu_p0(struct v3d_job *job,
|
|
struct v3d_cl_out **uniforms,
|
|
struct v3d_shaderimg_stateobj *img,
|
|
uint32_t data)
|
|
{
|
|
/* Extract the image unit from the top bits, and the compiler's
|
|
* packed p0 from the bottom.
|
|
*/
|
|
uint32_t unit = data >> 24;
|
|
uint32_t p0 = data & 0x00ffffff;
|
|
|
|
struct v3d_image_view *iview = &img->si[unit];
|
|
struct v3d_resource *rsc = v3d_resource(iview->base.resource);
|
|
|
|
cl_aligned_reloc(&job->indirect, uniforms,
|
|
v3d_resource(iview->tex_state)->bo,
|
|
iview->tex_state_offset | p0);
|
|
v3d_job_add_bo(job, rsc->bo);
|
|
}
|
|
|
|
/** Writes the V3D 4.x TMU configuration parameter 1. */
|
|
static void
|
|
write_tmu_p1(struct v3d_job *job,
|
|
struct v3d_cl_out **uniforms,
|
|
struct v3d_texture_stateobj *texstate,
|
|
uint32_t data)
|
|
{
|
|
uint32_t unit = v3d_unit_data_get_unit(data);
|
|
struct pipe_sampler_state *psampler = texstate->samplers[unit];
|
|
struct v3d_sampler_state *sampler = v3d_sampler_state(psampler);
|
|
struct pipe_sampler_view *psview = texstate->textures[unit];
|
|
struct v3d_sampler_view *sview = v3d_sampler_view(psview);
|
|
int variant = 0;
|
|
|
|
/* If we are being asked by the compiler to write parameter 1, then we
|
|
* need that. So if we are at this point, we should expect to have a
|
|
* sampler and psampler. As an additional assert, we can check that we
|
|
* are not on a texel buffer case, as these don't have a sampler.
|
|
*/
|
|
assert(psview->target != PIPE_BUFFER);
|
|
assert(sampler);
|
|
assert(psampler);
|
|
|
|
if (sampler->border_color_variants)
|
|
variant = sview->sampler_variant;
|
|
|
|
cl_aligned_reloc(&job->indirect, uniforms,
|
|
v3d_resource(sampler->sampler_state)->bo,
|
|
sampler->sampler_state_offset[variant] |
|
|
v3d_unit_data_get_offset(data));
|
|
}
|
|
|
|
struct v3d_cl_reloc
|
|
v3d_write_uniforms(struct v3d_context *v3d, struct v3d_job *job,
|
|
struct v3d_compiled_shader *shader,
|
|
enum pipe_shader_type stage)
|
|
{
|
|
struct v3d_constbuf_stateobj *cb = &v3d->constbuf[stage];
|
|
struct v3d_texture_stateobj *texstate = &v3d->tex[stage];
|
|
struct v3d_uniform_list *uinfo = &shader->prog_data.base->uniforms;
|
|
const uint32_t *gallium_uniforms = cb->cb[0].user_buffer;
|
|
|
|
/* The hardware always pre-fetches the next uniform (also when there
|
|
* aren't any), so we always allocate space for an extra slot. This
|
|
* fixes MMU exceptions reported since Linux kernel 5.4 when the
|
|
* uniforms fill up the tail bytes of a page in the indirect
|
|
* BO. In that scenario, when the hardware pre-fetches after reading
|
|
* the last uniform it will read beyond the end of the page and trigger
|
|
* the MMU exception.
|
|
*/
|
|
v3d_cl_ensure_space(&job->indirect, (uinfo->count + 1) * 4, 4);
|
|
|
|
struct v3d_cl_reloc uniform_stream = cl_get_address(&job->indirect);
|
|
v3d_bo_reference(uniform_stream.bo);
|
|
|
|
struct v3d_cl_out *uniforms =
|
|
cl_start(&job->indirect);
|
|
|
|
for (int i = 0; i < uinfo->count; i++) {
|
|
uint32_t data = uinfo->data[i];
|
|
|
|
switch (uinfo->contents[i]) {
|
|
case QUNIFORM_CONSTANT:
|
|
cl_aligned_u32(&uniforms, data);
|
|
break;
|
|
case QUNIFORM_UNIFORM:
|
|
cl_aligned_u32(&uniforms, gallium_uniforms[data]);
|
|
break;
|
|
case QUNIFORM_VIEWPORT_X_SCALE:
|
|
cl_aligned_f(&uniforms, v3d->viewport.scale[0] * 256.0f);
|
|
break;
|
|
case QUNIFORM_VIEWPORT_Y_SCALE:
|
|
cl_aligned_f(&uniforms, v3d->viewport.scale[1] * 256.0f);
|
|
break;
|
|
|
|
case QUNIFORM_VIEWPORT_Z_OFFSET:
|
|
cl_aligned_f(&uniforms, v3d->viewport.translate[2]);
|
|
break;
|
|
case QUNIFORM_VIEWPORT_Z_SCALE:
|
|
cl_aligned_f(&uniforms, v3d->viewport.scale[2]);
|
|
break;
|
|
|
|
case QUNIFORM_USER_CLIP_PLANE:
|
|
cl_aligned_f(&uniforms,
|
|
v3d->clip.ucp[data / 4][data % 4]);
|
|
break;
|
|
|
|
case QUNIFORM_TMU_CONFIG_P0:
|
|
write_tmu_p0(job, &uniforms, texstate, data);
|
|
break;
|
|
|
|
case QUNIFORM_TMU_CONFIG_P1:
|
|
write_tmu_p1(job, &uniforms, texstate, data);
|
|
break;
|
|
|
|
case QUNIFORM_IMAGE_TMU_CONFIG_P0:
|
|
write_image_tmu_p0(job, &uniforms,
|
|
&v3d->shaderimg[stage], data);
|
|
break;
|
|
|
|
case QUNIFORM_TEXTURE_CONFIG_P1:
|
|
write_texture_p1(job, &uniforms, texstate,
|
|
data);
|
|
break;
|
|
|
|
case QUNIFORM_TEXRECT_SCALE_X:
|
|
case QUNIFORM_TEXRECT_SCALE_Y:
|
|
cl_aligned_u32(&uniforms,
|
|
get_texrect_scale(texstate,
|
|
uinfo->contents[i],
|
|
data));
|
|
break;
|
|
|
|
case QUNIFORM_TEXTURE_WIDTH:
|
|
case QUNIFORM_TEXTURE_HEIGHT:
|
|
case QUNIFORM_TEXTURE_DEPTH:
|
|
case QUNIFORM_TEXTURE_ARRAY_SIZE:
|
|
case QUNIFORM_TEXTURE_LEVELS:
|
|
cl_aligned_u32(&uniforms,
|
|
get_texture_size(texstate,
|
|
uinfo->contents[i],
|
|
data));
|
|
break;
|
|
|
|
case QUNIFORM_IMAGE_WIDTH:
|
|
case QUNIFORM_IMAGE_HEIGHT:
|
|
case QUNIFORM_IMAGE_DEPTH:
|
|
case QUNIFORM_IMAGE_ARRAY_SIZE:
|
|
cl_aligned_u32(&uniforms,
|
|
get_image_size(&v3d->shaderimg[stage],
|
|
uinfo->contents[i],
|
|
data));
|
|
break;
|
|
|
|
case QUNIFORM_LINE_WIDTH:
|
|
cl_aligned_f(&uniforms,
|
|
v3d->rasterizer->base.line_width);
|
|
break;
|
|
|
|
case QUNIFORM_AA_LINE_WIDTH:
|
|
cl_aligned_f(&uniforms, v3d_get_real_line_width(v3d));
|
|
break;
|
|
|
|
case QUNIFORM_UBO_ADDR: {
|
|
uint32_t unit = v3d_unit_data_get_unit(data);
|
|
/* Constant buffer 0 may be a system memory pointer,
|
|
* in which case we want to upload a shadow copy to
|
|
* the GPU.
|
|
*/
|
|
if (!cb->cb[unit].buffer) {
|
|
u_upload_data(v3d->uploader, 0,
|
|
cb->cb[unit].buffer_size, 16,
|
|
cb->cb[unit].user_buffer,
|
|
&cb->cb[unit].buffer_offset,
|
|
&cb->cb[unit].buffer);
|
|
}
|
|
|
|
cl_aligned_reloc(&job->indirect, &uniforms,
|
|
v3d_resource(cb->cb[unit].buffer)->bo,
|
|
cb->cb[unit].buffer_offset +
|
|
v3d_unit_data_get_offset(data));
|
|
break;
|
|
}
|
|
|
|
case QUNIFORM_SSBO_OFFSET: {
|
|
struct pipe_shader_buffer *sb =
|
|
&v3d->ssbo[stage].sb[data];
|
|
|
|
cl_aligned_reloc(&job->indirect, &uniforms,
|
|
v3d_resource(sb->buffer)->bo,
|
|
sb->buffer_offset);
|
|
break;
|
|
}
|
|
|
|
case QUNIFORM_GET_SSBO_SIZE:
|
|
cl_aligned_u32(&uniforms,
|
|
v3d->ssbo[stage].sb[data].buffer_size);
|
|
break;
|
|
|
|
case QUNIFORM_TEXTURE_FIRST_LEVEL:
|
|
cl_aligned_f(&uniforms,
|
|
texstate->textures[data]->u.tex.first_level);
|
|
break;
|
|
|
|
case QUNIFORM_SPILL_OFFSET:
|
|
cl_aligned_reloc(&job->indirect, &uniforms,
|
|
v3d->prog.spill_bo, 0);
|
|
break;
|
|
|
|
case QUNIFORM_SPILL_SIZE_PER_THREAD:
|
|
cl_aligned_u32(&uniforms,
|
|
v3d->prog.spill_size_per_thread);
|
|
break;
|
|
|
|
case QUNIFORM_NUM_WORK_GROUPS:
|
|
cl_aligned_u32(&uniforms,
|
|
v3d->compute_num_workgroups[data]);
|
|
break;
|
|
|
|
case QUNIFORM_SHARED_OFFSET:
|
|
cl_aligned_reloc(&job->indirect, &uniforms,
|
|
v3d->compute_shared_memory, 0);
|
|
break;
|
|
|
|
case QUNIFORM_FB_LAYERS:
|
|
cl_aligned_u32(&uniforms, job->num_layers);
|
|
break;
|
|
|
|
default:
|
|
assert(quniform_contents_is_texture_p0(uinfo->contents[i]));
|
|
|
|
write_texture_p0(job, &uniforms, texstate,
|
|
uinfo->contents[i] -
|
|
QUNIFORM_TEXTURE_CONFIG_P0_0,
|
|
data);
|
|
break;
|
|
|
|
}
|
|
#if 0
|
|
uint32_t written_val = *((uint32_t *)uniforms - 1);
|
|
fprintf(stderr, "shader %p[%d]: 0x%08x / 0x%08x (%f) ",
|
|
shader, i, __gen_address_offset(&uniform_stream) + i * 4,
|
|
written_val, uif(written_val));
|
|
vir_dump_uniform(uinfo->contents[i], data);
|
|
fprintf(stderr, "\n");
|
|
#endif
|
|
}
|
|
|
|
cl_end(&job->indirect, uniforms);
|
|
|
|
return uniform_stream;
|
|
}
|
|
|
|
void
|
|
v3d_set_shader_uniform_dirty_flags(struct v3d_compiled_shader *shader)
|
|
{
|
|
uint32_t dirty = 0;
|
|
|
|
for (int i = 0; i < shader->prog_data.base->uniforms.count; i++) {
|
|
switch (shader->prog_data.base->uniforms.contents[i]) {
|
|
case QUNIFORM_CONSTANT:
|
|
break;
|
|
case QUNIFORM_UNIFORM:
|
|
case QUNIFORM_UBO_ADDR:
|
|
dirty |= V3D_DIRTY_CONSTBUF;
|
|
break;
|
|
|
|
case QUNIFORM_VIEWPORT_X_SCALE:
|
|
case QUNIFORM_VIEWPORT_Y_SCALE:
|
|
case QUNIFORM_VIEWPORT_Z_OFFSET:
|
|
case QUNIFORM_VIEWPORT_Z_SCALE:
|
|
dirty |= V3D_DIRTY_VIEWPORT;
|
|
break;
|
|
|
|
case QUNIFORM_USER_CLIP_PLANE:
|
|
dirty |= V3D_DIRTY_CLIP;
|
|
break;
|
|
|
|
case QUNIFORM_TMU_CONFIG_P0:
|
|
case QUNIFORM_TMU_CONFIG_P1:
|
|
case QUNIFORM_TEXTURE_CONFIG_P1:
|
|
case QUNIFORM_TEXTURE_FIRST_LEVEL:
|
|
case QUNIFORM_TEXRECT_SCALE_X:
|
|
case QUNIFORM_TEXRECT_SCALE_Y:
|
|
case QUNIFORM_TEXTURE_WIDTH:
|
|
case QUNIFORM_TEXTURE_HEIGHT:
|
|
case QUNIFORM_TEXTURE_DEPTH:
|
|
case QUNIFORM_TEXTURE_ARRAY_SIZE:
|
|
case QUNIFORM_TEXTURE_LEVELS:
|
|
case QUNIFORM_SPILL_OFFSET:
|
|
case QUNIFORM_SPILL_SIZE_PER_THREAD:
|
|
/* We could flag this on just the stage we're
|
|
* compiling for, but it's not passed in.
|
|
*/
|
|
dirty |= V3D_DIRTY_FRAGTEX | V3D_DIRTY_VERTTEX |
|
|
V3D_DIRTY_GEOMTEX | V3D_DIRTY_COMPTEX;
|
|
break;
|
|
|
|
case QUNIFORM_SSBO_OFFSET:
|
|
case QUNIFORM_GET_SSBO_SIZE:
|
|
dirty |= V3D_DIRTY_SSBO;
|
|
break;
|
|
|
|
case QUNIFORM_IMAGE_TMU_CONFIG_P0:
|
|
case QUNIFORM_IMAGE_WIDTH:
|
|
case QUNIFORM_IMAGE_HEIGHT:
|
|
case QUNIFORM_IMAGE_DEPTH:
|
|
case QUNIFORM_IMAGE_ARRAY_SIZE:
|
|
dirty |= V3D_DIRTY_SHADER_IMAGE;
|
|
break;
|
|
|
|
case QUNIFORM_LINE_WIDTH:
|
|
case QUNIFORM_AA_LINE_WIDTH:
|
|
dirty |= V3D_DIRTY_RASTERIZER;
|
|
break;
|
|
|
|
case QUNIFORM_NUM_WORK_GROUPS:
|
|
case QUNIFORM_SHARED_OFFSET:
|
|
/* Compute always recalculates uniforms. */
|
|
break;
|
|
|
|
case QUNIFORM_FB_LAYERS:
|
|
dirty |= V3D_DIRTY_FRAMEBUFFER;
|
|
break;
|
|
|
|
default:
|
|
assert(quniform_contents_is_texture_p0(shader->prog_data.base->uniforms.contents[i]));
|
|
dirty |= V3D_DIRTY_FRAGTEX | V3D_DIRTY_VERTTEX |
|
|
V3D_DIRTY_GEOMTEX | V3D_DIRTY_COMPTEX;
|
|
break;
|
|
}
|
|
}
|
|
|
|
shader->uniform_dirty_bits = dirty;
|
|
}
|