| /* |
| * 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/format_srgb.h" |
| |
| #include "vc5_context.h" |
| #include "compiler/v3d_compiler.h" |
| #include "broadcom/cle/v3d_packet_v33_pack.h" |
| |
| #if 0 |
| |
| #define SWIZ(x,y,z,w) { \ |
| PIPE_SWIZZLE_##x, \ |
| PIPE_SWIZZLE_##y, \ |
| PIPE_SWIZZLE_##z, \ |
| PIPE_SWIZZLE_##w \ |
| } |
| |
| static void |
| write_texture_border_color(struct vc5_job *job, |
| struct vc5_cl_out **uniforms, |
| struct vc5_texture_stateobj *texstate, |
| uint32_t unit) |
| { |
| struct pipe_sampler_state *sampler = texstate->samplers[unit]; |
| struct pipe_sampler_view *texture = texstate->textures[unit]; |
| struct vc5_resource *rsc = vc5_resource(texture->texture); |
| union util_color uc; |
| |
| const struct util_format_description *tex_format_desc = |
| util_format_description(texture->format); |
| |
| float border_color[4]; |
| for (int i = 0; i < 4; i++) |
| border_color[i] = sampler->border_color.f[i]; |
| if (util_format_is_srgb(texture->format)) { |
| for (int i = 0; i < 3; i++) |
| border_color[i] = |
| util_format_linear_to_srgb_float(border_color[i]); |
| } |
| |
| /* Turn the border color into the layout of channels that it would |
| * have when stored as texture contents. |
| */ |
| float storage_color[4]; |
| util_format_unswizzle_4f(storage_color, |
| border_color, |
| tex_format_desc->swizzle); |
| |
| /* Now, pack so that when the vc5_format-sampled texture contents are |
| * replaced with our border color, the vc5_get_format_swizzle() |
| * swizzling will get the right channels. |
| */ |
| if (util_format_is_depth_or_stencil(texture->format)) { |
| uc.ui[0] = util_pack_z(PIPE_FORMAT_Z24X8_UNORM, |
| sampler->border_color.f[0]) << 8; |
| } else { |
| switch (rsc->vc5_format) { |
| default: |
| case VC5_TEXTURE_TYPE_RGBA8888: |
| util_pack_color(storage_color, |
| PIPE_FORMAT_R8G8B8A8_UNORM, &uc); |
| break; |
| case VC5_TEXTURE_TYPE_RGBA4444: |
| util_pack_color(storage_color, |
| PIPE_FORMAT_A8B8G8R8_UNORM, &uc); |
| break; |
| case VC5_TEXTURE_TYPE_RGB565: |
| util_pack_color(storage_color, |
| PIPE_FORMAT_B8G8R8A8_UNORM, &uc); |
| break; |
| case VC5_TEXTURE_TYPE_ALPHA: |
| uc.ui[0] = float_to_ubyte(storage_color[0]) << 24; |
| break; |
| case VC5_TEXTURE_TYPE_LUMALPHA: |
| uc.ui[0] = ((float_to_ubyte(storage_color[1]) << 24) | |
| (float_to_ubyte(storage_color[0]) << 0)); |
| break; |
| } |
| } |
| |
| cl_aligned_u32(uniforms, uc.ui[0]); |
| } |
| #endif |
| |
| static uint32_t |
| get_texrect_scale(struct vc5_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 vc5_texture_stateobj *texstate, |
| enum quniform_contents contents, |
| uint32_t data) |
| { |
| struct pipe_sampler_view *texture = texstate->textures[data]; |
| |
| switch (contents) { |
| case QUNIFORM_TEXTURE_WIDTH: |
| 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: |
| return u_minify(texture->texture->depth0, |
| texture->u.tex.first_level); |
| case QUNIFORM_TEXTURE_ARRAY_SIZE: |
| return texture->texture->array_size; |
| case QUNIFORM_TEXTURE_LEVELS: |
| return (texture->u.tex.last_level - |
| texture->u.tex.first_level) + 1; |
| default: |
| unreachable("Bad texture size field"); |
| } |
| } |
| |
| static struct vc5_bo * |
| vc5_upload_ubo(struct vc5_context *vc5, |
| struct vc5_compiled_shader *shader, |
| const uint32_t *gallium_uniforms) |
| { |
| if (!shader->prog_data.base->ubo_size) |
| return NULL; |
| |
| struct vc5_bo *ubo = vc5_bo_alloc(vc5->screen, |
| shader->prog_data.base->ubo_size, |
| "ubo"); |
| void *data = vc5_bo_map(ubo); |
| for (uint32_t i = 0; i < shader->prog_data.base->num_ubo_ranges; i++) { |
| memcpy(data + shader->prog_data.base->ubo_ranges[i].dst_offset, |
| ((const void *)gallium_uniforms + |
| shader->prog_data.base->ubo_ranges[i].src_offset), |
| shader->prog_data.base->ubo_ranges[i].size); |
| } |
| |
| return ubo; |
| } |
| |
| /** |
| * 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 vc5_job *job, |
| struct vc5_cl_out **uniforms, |
| struct vc5_texture_stateobj *texstate, |
| uint32_t unit, |
| uint32_t shader_data) |
| { |
| struct pipe_sampler_state *psampler = texstate->samplers[unit]; |
| struct vc5_sampler_state *sampler = vc5_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 vc5_job *job, |
| struct vc5_cl_out **uniforms, |
| struct vc5_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 vc5_sampler_view *sview = vc5_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 vc5_job *job, |
| struct vc5_cl_out **uniforms, |
| struct vc5_texture_stateobj *texstate, |
| uint32_t data) |
| { |
| /* Extract the texture 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 pipe_sampler_view *psview = texstate->textures[unit]; |
| struct vc5_sampler_view *sview = vc5_sampler_view(psview); |
| struct vc5_resource *rsc = vc5_resource(psview->texture); |
| |
| cl_aligned_reloc(&job->indirect, uniforms, sview->bo, p0); |
| vc5_job_add_bo(job, rsc->bo); |
| } |
| |
| /** Writes the V3D 4.x TMU configuration parameter 1. */ |
| static void |
| write_tmu_p1(struct vc5_job *job, |
| struct vc5_cl_out **uniforms, |
| struct vc5_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 >> 24; |
| uint32_t p0 = data & 0x00ffffff; |
| |
| struct pipe_sampler_state *psampler = texstate->samplers[unit]; |
| struct vc5_sampler_state *sampler = vc5_sampler_state(psampler); |
| |
| cl_aligned_reloc(&job->indirect, uniforms, sampler->bo, p0); |
| } |
| |
| struct vc5_cl_reloc |
| vc5_write_uniforms(struct vc5_context *vc5, struct vc5_compiled_shader *shader, |
| struct vc5_constbuf_stateobj *cb, |
| struct vc5_texture_stateobj *texstate) |
| { |
| struct v3d_uniform_list *uinfo = &shader->prog_data.base->uniforms; |
| struct vc5_job *job = vc5->job; |
| const uint32_t *gallium_uniforms = cb->cb[0].user_buffer; |
| struct vc5_bo *ubo = vc5_upload_ubo(vc5, shader, gallium_uniforms); |
| |
| /* We always need to return some space for uniforms, because the HW |
| * will be prefetching, even if we don't read any in the program. |
| */ |
| vc5_cl_ensure_space(&job->indirect, MAX2(uinfo->count, 1) * 4, 4); |
| |
| struct vc5_cl_reloc uniform_stream = cl_get_address(&job->indirect); |
| vc5_bo_reference(uniform_stream.bo); |
| |
| struct vc5_cl_out *uniforms = |
| cl_start(&job->indirect); |
| |
| for (int i = 0; i < uinfo->count; i++) { |
| |
| switch (uinfo->contents[i]) { |
| case QUNIFORM_CONSTANT: |
| cl_aligned_u32(&uniforms, uinfo->data[i]); |
| break; |
| case QUNIFORM_UNIFORM: |
| cl_aligned_u32(&uniforms, |
| gallium_uniforms[uinfo->data[i]]); |
| break; |
| case QUNIFORM_VIEWPORT_X_SCALE: |
| cl_aligned_f(&uniforms, vc5->viewport.scale[0] * 256.0f); |
| break; |
| case QUNIFORM_VIEWPORT_Y_SCALE: |
| cl_aligned_f(&uniforms, vc5->viewport.scale[1] * 256.0f); |
| break; |
| |
| case QUNIFORM_VIEWPORT_Z_OFFSET: |
| cl_aligned_f(&uniforms, vc5->viewport.translate[2]); |
| break; |
| case QUNIFORM_VIEWPORT_Z_SCALE: |
| cl_aligned_f(&uniforms, vc5->viewport.scale[2]); |
| break; |
| |
| case QUNIFORM_USER_CLIP_PLANE: |
| cl_aligned_f(&uniforms, |
| vc5->clip.ucp[uinfo->data[i] / 4][uinfo->data[i] % 4]); |
| break; |
| |
| case QUNIFORM_TMU_CONFIG_P0: |
| write_tmu_p0(job, &uniforms, texstate, |
| uinfo->data[i]); |
| break; |
| |
| case QUNIFORM_TMU_CONFIG_P1: |
| write_tmu_p1(job, &uniforms, texstate, |
| uinfo->data[i]); |
| break; |
| |
| case QUNIFORM_TEXTURE_CONFIG_P1: |
| write_texture_p1(job, &uniforms, texstate, |
| uinfo->data[i]); |
| break; |
| |
| #if 0 |
| case QUNIFORM_TEXTURE_FIRST_LEVEL: |
| write_texture_first_level(job, &uniforms, texstate, |
| uinfo->data[i]); |
| break; |
| #endif |
| |
| case QUNIFORM_TEXRECT_SCALE_X: |
| case QUNIFORM_TEXRECT_SCALE_Y: |
| cl_aligned_u32(&uniforms, |
| get_texrect_scale(texstate, |
| uinfo->contents[i], |
| uinfo->data[i])); |
| 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], |
| uinfo->data[i])); |
| break; |
| |
| case QUNIFORM_STENCIL: |
| cl_aligned_u32(&uniforms, |
| vc5->zsa->stencil_uniforms[uinfo->data[i]] | |
| (uinfo->data[i] <= 1 ? |
| (vc5->stencil_ref.ref_value[uinfo->data[i]] << 8) : |
| 0)); |
| break; |
| |
| case QUNIFORM_ALPHA_REF: |
| cl_aligned_f(&uniforms, |
| vc5->zsa->base.alpha.ref_value); |
| break; |
| |
| case QUNIFORM_SAMPLE_MASK: |
| cl_aligned_u32(&uniforms, vc5->sample_mask); |
| break; |
| |
| case QUNIFORM_UBO_ADDR: |
| if (uinfo->data[i] == 0) { |
| cl_aligned_reloc(&job->indirect, &uniforms, |
| ubo, 0); |
| } else { |
| int ubo_index = uinfo->data[i]; |
| struct vc5_resource *rsc = |
| vc5_resource(cb->cb[ubo_index].buffer); |
| |
| cl_aligned_reloc(&job->indirect, &uniforms, |
| rsc->bo, |
| cb->cb[ubo_index].buffer_offset); |
| } |
| break; |
| |
| case QUNIFORM_TEXTURE_FIRST_LEVEL: |
| cl_aligned_f(&uniforms, |
| texstate->textures[uinfo->data[i]]->u.tex.first_level); |
| break; |
| |
| case QUNIFORM_TEXTURE_BORDER_COLOR: |
| /* XXX */ |
| 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, |
| uinfo->data[i]); |
| break; |
| |
| } |
| #if 0 |
| uint32_t written_val = *((uint32_t *)uniforms - 1); |
| fprintf(stderr, "shader %p[%d]: 0x%08x / 0x%08x (%f)\n", |
| shader, i, __gen_address_offset(&uniform_stream) + i * 4, |
| written_val, uif(written_val)); |
| #endif |
| } |
| |
| cl_end(&job->indirect, uniforms); |
| |
| vc5_bo_unreference(&ubo); |
| |
| return uniform_stream; |
| } |
| |
| void |
| vc5_set_shader_uniform_dirty_flags(struct vc5_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 |= VC5_DIRTY_CONSTBUF; |
| break; |
| |
| case QUNIFORM_VIEWPORT_X_SCALE: |
| case QUNIFORM_VIEWPORT_Y_SCALE: |
| case QUNIFORM_VIEWPORT_Z_OFFSET: |
| case QUNIFORM_VIEWPORT_Z_SCALE: |
| dirty |= VC5_DIRTY_VIEWPORT; |
| break; |
| |
| case QUNIFORM_USER_CLIP_PLANE: |
| dirty |= VC5_DIRTY_CLIP; |
| break; |
| |
| case QUNIFORM_TMU_CONFIG_P0: |
| case QUNIFORM_TMU_CONFIG_P1: |
| case QUNIFORM_TEXTURE_CONFIG_P1: |
| case QUNIFORM_TEXTURE_BORDER_COLOR: |
| 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: |
| /* We could flag this on just the stage we're |
| * compiling for, but it's not passed in. |
| */ |
| dirty |= VC5_DIRTY_FRAGTEX | VC5_DIRTY_VERTTEX; |
| break; |
| |
| case QUNIFORM_STENCIL: |
| case QUNIFORM_ALPHA_REF: |
| dirty |= VC5_DIRTY_ZSA; |
| break; |
| |
| case QUNIFORM_SAMPLE_MASK: |
| dirty |= VC5_DIRTY_SAMPLE_MASK; |
| break; |
| |
| default: |
| assert(quniform_contents_is_texture_p0(shader->prog_data.base->uniforms.contents[i])); |
| dirty |= VC5_DIRTY_FRAGTEX | VC5_DIRTY_VERTTEX; |
| break; |
| } |
| } |
| |
| shader->uniform_dirty_bits = dirty; |
| } |
