0,0 → 1,479 |
/* -*- mode: C; c-file-style: "k&r"; tab-width 4; indent-tabs-mode: t; -*- */ |
|
/* |
* Copyright (C) 2012 Rob Clark <robclark@freedesktop.org> |
* |
* 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. |
* |
* Authors: |
* Rob Clark <robclark@freedesktop.org> |
*/ |
|
#include "pipe/p_state.h" |
#include "util/u_string.h" |
#include "util/u_memory.h" |
#include "util/u_inlines.h" |
#include "util/u_format.h" |
#include "tgsi/tgsi_dump.h" |
#include "tgsi/tgsi_parse.h" |
|
#include "freedreno_program.h" |
|
#include "fd2_program.h" |
#include "fd2_compiler.h" |
#include "fd2_texture.h" |
#include "fd2_util.h" |
|
static struct fd2_shader_stateobj * |
create_shader(enum shader_t type) |
{ |
struct fd2_shader_stateobj *so = CALLOC_STRUCT(fd2_shader_stateobj); |
if (!so) |
return NULL; |
so->type = type; |
return so; |
} |
|
static void |
delete_shader(struct fd2_shader_stateobj *so) |
{ |
ir2_shader_destroy(so->ir); |
free(so->tokens); |
free(so->bin); |
free(so); |
} |
|
static struct fd2_shader_stateobj * |
assemble(struct fd2_shader_stateobj *so) |
{ |
free(so->bin); |
so->bin = ir2_shader_assemble(so->ir, &so->info); |
if (!so->bin) |
goto fail; |
|
if (fd_mesa_debug & FD_DBG_DISASM) { |
DBG("disassemble: type=%d", so->type); |
disasm_a2xx(so->bin, so->info.sizedwords, 0, so->type); |
} |
|
return so; |
|
fail: |
debug_error("assemble failed!"); |
delete_shader(so); |
return NULL; |
} |
|
static struct fd2_shader_stateobj * |
compile(struct fd_program_stateobj *prog, struct fd2_shader_stateobj *so) |
{ |
int ret; |
|
if (fd_mesa_debug & FD_DBG_DISASM) { |
DBG("dump tgsi: type=%d", so->type); |
tgsi_dump(so->tokens, 0); |
} |
|
ret = fd2_compile_shader(prog, so); |
if (ret) |
goto fail; |
|
/* NOTE: we don't assemble yet because for VS we don't know the |
* type information for vertex fetch yet.. so those need to be |
* patched up later before assembling. |
*/ |
|
so->info.sizedwords = 0; |
|
return so; |
|
fail: |
debug_error("compile failed!"); |
delete_shader(so); |
return NULL; |
} |
|
static void |
emit(struct fd_ringbuffer *ring, struct fd2_shader_stateobj *so) |
{ |
unsigned i; |
|
if (so->info.sizedwords == 0) |
assemble(so); |
|
OUT_PKT3(ring, CP_IM_LOAD_IMMEDIATE, 2 + so->info.sizedwords); |
OUT_RING(ring, (so->type == SHADER_VERTEX) ? 0 : 1); |
OUT_RING(ring, so->info.sizedwords); |
for (i = 0; i < so->info.sizedwords; i++) |
OUT_RING(ring, so->bin[i]); |
} |
|
static void * |
fd2_fp_state_create(struct pipe_context *pctx, |
const struct pipe_shader_state *cso) |
{ |
struct fd2_shader_stateobj *so = create_shader(SHADER_FRAGMENT); |
if (!so) |
return NULL; |
so->tokens = tgsi_dup_tokens(cso->tokens); |
return so; |
} |
|
static void |
fd2_fp_state_delete(struct pipe_context *pctx, void *hwcso) |
{ |
struct fd2_shader_stateobj *so = hwcso; |
delete_shader(so); |
} |
|
static void * |
fd2_vp_state_create(struct pipe_context *pctx, |
const struct pipe_shader_state *cso) |
{ |
struct fd2_shader_stateobj *so = create_shader(SHADER_VERTEX); |
if (!so) |
return NULL; |
so->tokens = tgsi_dup_tokens(cso->tokens); |
return so; |
} |
|
static void |
fd2_vp_state_delete(struct pipe_context *pctx, void *hwcso) |
{ |
struct fd2_shader_stateobj *so = hwcso; |
delete_shader(so); |
} |
|
static void |
patch_vtx_fetches(struct fd_context *ctx, struct fd2_shader_stateobj *so, |
struct fd_vertex_stateobj *vtx) |
{ |
unsigned i; |
|
assert(so->num_vfetch_instrs == vtx->num_elements); |
|
/* update vtx fetch instructions: */ |
for (i = 0; i < so->num_vfetch_instrs; i++) { |
struct ir2_instruction *instr = so->vfetch_instrs[i]; |
struct pipe_vertex_element *elem = &vtx->pipe[i]; |
struct pipe_vertex_buffer *vb = |
&ctx->vtx.vertexbuf.vb[elem->vertex_buffer_index]; |
enum pipe_format format = elem->src_format; |
const struct util_format_description *desc = |
util_format_description(format); |
unsigned j; |
|
/* Find the first non-VOID channel. */ |
for (j = 0; j < 4; j++) |
if (desc->channel[j].type != UTIL_FORMAT_TYPE_VOID) |
break; |
|
/* CI/CIS can probably be set in compiler instead: */ |
instr->fetch.const_idx = 20 + (i / 3); |
instr->fetch.const_idx_sel = i % 3; |
|
instr->fetch.fmt = fd2_pipe2surface(format); |
instr->fetch.is_normalized = desc->channel[j].normalized; |
instr->fetch.is_signed = |
desc->channel[j].type == UTIL_FORMAT_TYPE_SIGNED; |
instr->fetch.stride = vb->stride ? : 1; |
instr->fetch.offset = elem->src_offset; |
|
for (j = 0; j < 4; j++) |
instr->regs[0]->swizzle[j] = "xyzw01__"[desc->swizzle[j]]; |
|
assert(instr->fetch.fmt != ~0); |
|
DBG("vtx[%d]: %s (%d), ci=%d, cis=%d, id=%d, swizzle=%s, " |
"stride=%d, offset=%d", |
i, util_format_name(format), |
instr->fetch.fmt, |
instr->fetch.const_idx, |
instr->fetch.const_idx_sel, |
elem->instance_divisor, |
instr->regs[0]->swizzle, |
instr->fetch.stride, |
instr->fetch.offset); |
} |
|
/* trigger re-assemble: */ |
so->info.sizedwords = 0; |
} |
|
static void |
patch_tex_fetches(struct fd_context *ctx, struct fd2_shader_stateobj *so, |
struct fd_texture_stateobj *tex) |
{ |
unsigned i; |
|
/* update tex fetch instructions: */ |
for (i = 0; i < so->num_tfetch_instrs; i++) { |
struct ir2_instruction *instr = so->tfetch_instrs[i].instr; |
unsigned samp_id = so->tfetch_instrs[i].samp_id; |
unsigned const_idx = fd2_get_const_idx(ctx, tex, samp_id); |
|
if (const_idx != instr->fetch.const_idx) { |
instr->fetch.const_idx = const_idx; |
/* trigger re-assemble: */ |
so->info.sizedwords = 0; |
} |
} |
} |
|
void |
fd2_program_validate(struct fd_context *ctx) |
{ |
struct fd_program_stateobj *prog = &ctx->prog; |
|
/* if vertex or frag shader is dirty, we may need to recompile. Compile |
* frag shader first, as that assigns the register slots for exports |
* from the vertex shader. And therefore if frag shader has changed we |
* need to recompile both vert and frag shader. |
*/ |
if (prog->dirty & FD_SHADER_DIRTY_FP) |
compile(prog, prog->fp); |
|
if (prog->dirty & (FD_SHADER_DIRTY_FP | FD_SHADER_DIRTY_VP)) |
compile(prog, prog->vp); |
|
if (prog->dirty) |
ctx->dirty |= FD_DIRTY_PROG; |
|
/* if necessary, fix up vertex fetch instructions: */ |
if (ctx->dirty & (FD_DIRTY_VTXSTATE | FD_DIRTY_PROG)) |
patch_vtx_fetches(ctx, prog->vp, ctx->vtx.vtx); |
|
/* if necessary, fix up texture fetch instructions: */ |
if (ctx->dirty & (FD_DIRTY_TEXSTATE | FD_DIRTY_PROG)) { |
patch_tex_fetches(ctx, prog->vp, &ctx->verttex); |
patch_tex_fetches(ctx, prog->fp, &ctx->fragtex); |
} |
} |
|
void |
fd2_program_emit(struct fd_ringbuffer *ring, |
struct fd_program_stateobj *prog) |
{ |
struct ir2_shader_info *vsi = |
&((struct fd2_shader_stateobj *)prog->vp)->info; |
struct ir2_shader_info *fsi = |
&((struct fd2_shader_stateobj *)prog->fp)->info; |
uint8_t vs_gprs, fs_gprs, vs_export; |
|
emit(ring, prog->vp); |
emit(ring, prog->fp); |
|
vs_gprs = (vsi->max_reg < 0) ? 0x80 : vsi->max_reg; |
fs_gprs = (fsi->max_reg < 0) ? 0x80 : fsi->max_reg; |
vs_export = MAX2(1, prog->num_exports) - 1; |
|
OUT_PKT3(ring, CP_SET_CONSTANT, 2); |
OUT_RING(ring, CP_REG(REG_A2XX_SQ_PROGRAM_CNTL)); |
OUT_RING(ring, A2XX_SQ_PROGRAM_CNTL_PS_EXPORT_MODE(POSITION_2_VECTORS_SPRITE) | |
A2XX_SQ_PROGRAM_CNTL_VS_RESOURCE | |
A2XX_SQ_PROGRAM_CNTL_PS_RESOURCE | |
A2XX_SQ_PROGRAM_CNTL_VS_EXPORT_COUNT(vs_export) | |
A2XX_SQ_PROGRAM_CNTL_PS_REGS(fs_gprs) | |
A2XX_SQ_PROGRAM_CNTL_VS_REGS(vs_gprs)); |
|
prog->dirty = 0; |
} |
|
/* Creates shader: |
* EXEC ADDR(0x2) CNT(0x1) |
* (S)FETCH: SAMPLE R0.xyzw = R0.xyx CONST(0) LOCATION(CENTER) |
* ALLOC PARAM/PIXEL SIZE(0x0) |
* EXEC_END ADDR(0x3) CNT(0x1) |
* ALU: MAXv export0 = R0, R0 ; gl_FragColor |
* NOP |
*/ |
static struct fd2_shader_stateobj * |
create_blit_fp(void) |
{ |
struct fd2_shader_stateobj *so = create_shader(SHADER_FRAGMENT); |
struct ir2_cf *cf; |
struct ir2_instruction *instr; |
|
if (!so) |
return NULL; |
|
so->ir = ir2_shader_create(); |
|
cf = ir2_cf_create(so->ir, EXEC); |
|
instr = ir2_instr_create_tex_fetch(cf, 0); |
ir2_reg_create(instr, 0, "xyzw", 0); |
ir2_reg_create(instr, 0, "xyx", 0); |
instr->sync = true; |
|
cf = ir2_cf_create_alloc(so->ir, SQ_PARAMETER_PIXEL, 0); |
cf = ir2_cf_create(so->ir, EXEC_END); |
|
instr = ir2_instr_create_alu(cf, MAXv, ~0); |
ir2_reg_create(instr, 0, NULL, IR2_REG_EXPORT); |
ir2_reg_create(instr, 0, NULL, 0); |
ir2_reg_create(instr, 0, NULL, 0); |
|
return assemble(so); |
} |
|
/* Creates shader: |
* EXEC ADDR(0x3) CNT(0x2) |
* FETCH: VERTEX R1.xy01 = R0.x FMT_32_32_FLOAT UNSIGNED STRIDE(8) CONST(26, 1) |
* FETCH: VERTEX R2.xyz1 = R0.x FMT_32_32_32_FLOAT UNSIGNED STRIDE(12) CONST(26, 0) |
* ALLOC POSITION SIZE(0x0) |
* EXEC ADDR(0x5) CNT(0x1) |
* ALU: MAXv export62 = R2, R2 ; gl_Position |
* ALLOC PARAM/PIXEL SIZE(0x0) |
* EXEC_END ADDR(0x6) CNT(0x1) |
* ALU: MAXv export0 = R1, R1 |
* NOP |
*/ |
static struct fd2_shader_stateobj * |
create_blit_vp(void) |
{ |
struct fd2_shader_stateobj *so = create_shader(SHADER_VERTEX); |
struct ir2_cf *cf; |
struct ir2_instruction *instr; |
|
if (!so) |
return NULL; |
|
so->ir = ir2_shader_create(); |
|
cf = ir2_cf_create(so->ir, EXEC); |
|
instr = ir2_instr_create_vtx_fetch(cf, 26, 1, FMT_32_32_FLOAT, false, 8); |
instr->fetch.is_normalized = true; |
ir2_reg_create(instr, 1, "xy01", 0); |
ir2_reg_create(instr, 0, "x", 0); |
|
instr = ir2_instr_create_vtx_fetch(cf, 26, 0, FMT_32_32_32_FLOAT, false, 12); |
instr->fetch.is_normalized = true; |
ir2_reg_create(instr, 2, "xyz1", 0); |
ir2_reg_create(instr, 0, "x", 0); |
|
cf = ir2_cf_create_alloc(so->ir, SQ_POSITION, 0); |
cf = ir2_cf_create(so->ir, EXEC); |
|
instr = ir2_instr_create_alu(cf, MAXv, ~0); |
ir2_reg_create(instr, 62, NULL, IR2_REG_EXPORT); |
ir2_reg_create(instr, 2, NULL, 0); |
ir2_reg_create(instr, 2, NULL, 0); |
|
cf = ir2_cf_create_alloc(so->ir, SQ_PARAMETER_PIXEL, 0); |
cf = ir2_cf_create(so->ir, EXEC_END); |
|
instr = ir2_instr_create_alu(cf, MAXv, ~0); |
ir2_reg_create(instr, 0, NULL, IR2_REG_EXPORT); |
ir2_reg_create(instr, 1, NULL, 0); |
ir2_reg_create(instr, 1, NULL, 0); |
|
return assemble(so); |
} |
|
/* Creates shader: |
* ALLOC PARAM/PIXEL SIZE(0x0) |
* EXEC_END ADDR(0x1) CNT(0x1) |
* ALU: MAXv export0 = C0, C0 ; gl_FragColor |
*/ |
static struct fd2_shader_stateobj * |
create_solid_fp(void) |
{ |
struct fd2_shader_stateobj *so = create_shader(SHADER_FRAGMENT); |
struct ir2_cf *cf; |
struct ir2_instruction *instr; |
|
if (!so) |
return NULL; |
|
so->ir = ir2_shader_create(); |
|
cf = ir2_cf_create_alloc(so->ir, SQ_PARAMETER_PIXEL, 0); |
cf = ir2_cf_create(so->ir, EXEC_END); |
|
instr = ir2_instr_create_alu(cf, MAXv, ~0); |
ir2_reg_create(instr, 0, NULL, IR2_REG_EXPORT); |
ir2_reg_create(instr, 0, NULL, IR2_REG_CONST); |
ir2_reg_create(instr, 0, NULL, IR2_REG_CONST); |
|
return assemble(so); |
} |
|
/* Creates shader: |
* EXEC ADDR(0x3) CNT(0x1) |
* (S)FETCH: VERTEX R1.xyz1 = R0.x FMT_32_32_32_FLOAT |
* UNSIGNED STRIDE(12) CONST(26, 0) |
* ALLOC POSITION SIZE(0x0) |
* EXEC ADDR(0x4) CNT(0x1) |
* ALU: MAXv export62 = R1, R1 ; gl_Position |
* ALLOC PARAM/PIXEL SIZE(0x0) |
* EXEC_END ADDR(0x5) CNT(0x0) |
*/ |
static struct fd2_shader_stateobj * |
create_solid_vp(void) |
{ |
struct fd2_shader_stateobj *so = create_shader(SHADER_VERTEX); |
struct ir2_cf *cf; |
struct ir2_instruction *instr; |
|
if (!so) |
return NULL; |
|
so->ir = ir2_shader_create(); |
|
cf = ir2_cf_create(so->ir, EXEC); |
|
instr = ir2_instr_create_vtx_fetch(cf, 26, 0, FMT_32_32_32_FLOAT, false, 12); |
ir2_reg_create(instr, 1, "xyz1", 0); |
ir2_reg_create(instr, 0, "x", 0); |
|
cf = ir2_cf_create_alloc(so->ir, SQ_POSITION, 0); |
cf = ir2_cf_create(so->ir, EXEC); |
|
instr = ir2_instr_create_alu(cf, MAXv, ~0); |
ir2_reg_create(instr, 62, NULL, IR2_REG_EXPORT); |
ir2_reg_create(instr, 1, NULL, 0); |
ir2_reg_create(instr, 1, NULL, 0); |
|
cf = ir2_cf_create_alloc(so->ir, SQ_PARAMETER_PIXEL, 0); |
cf = ir2_cf_create(so->ir, EXEC_END); |
|
return assemble(so); |
} |
|
void |
fd2_prog_init(struct pipe_context *pctx) |
{ |
struct fd_context *ctx = fd_context(pctx); |
|
pctx->create_fs_state = fd2_fp_state_create; |
pctx->delete_fs_state = fd2_fp_state_delete; |
|
pctx->create_vs_state = fd2_vp_state_create; |
pctx->delete_vs_state = fd2_vp_state_delete; |
|
fd_prog_init(pctx); |
|
ctx->solid_prog.fp = create_solid_fp(); |
ctx->solid_prog.vp = create_solid_vp(); |
ctx->blit_prog[0].fp = create_blit_fp(); |
ctx->blit_prog[0].vp = create_blit_vp(); |
} |