fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-01-07 00:00:12 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

R300: cleanup FS code and fill in missing details

Browse source
This commit is contained in:
Alex Deucher 2008-05-13 08:37:58 -04:00
parent 0cc8ed5ccc
commit 9ef4126d48
6 changed files with 405 additions and 371 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
src/mesa/drivers/dri/r300/r300_cmdbuf.c
View file

@ -409,7 +409,7 @@ void r300InitCmdBuf(r300ContextPtr r300)
ALLOC_STATE(sc_screendoor, always, 2, 0);
r300->hw.sc_screendoor.cmd[0] = cmdpacket0(R300_SC_SCREENDOOR, 1);
ALLOC_STATE(us_out_fmt, always, 6, 0);
r300->hw.us_out_fmt.cmd[0] = cmdpacket0(R500_US_OUT_FMT, 5);
r300->hw.us_out_fmt.cmd[0] = cmdpacket0(R300_US_OUT_FMT, 5);
if (is_r500) {
ALLOC_STATE(fp, always, R500_FP_CMDSIZE, 0);
@ -422,19 +422,19 @@ void r300InitCmdBuf(r300ContextPtr r300)
r300->hw.r500fp_const.cmd[R300_FPI_CMD_0] = cmdr500fp(0, 0, 1, 0);
} else {
ALLOC_STATE(fp, always, R300_FP_CMDSIZE, 0);
r300->hw.fp.cmd[R300_FP_CMD_0] = cmdpacket0(R300_PFS_CNTL_0, 3);
r300->hw.fp.cmd[R300_FP_CMD_1] = cmdpacket0(R300_PFS_NODE_0, 4);
r300->hw.fp.cmd[R300_FP_CMD_0] = cmdpacket0(R300_US_CONFIG, 3);
r300->hw.fp.cmd[R300_FP_CMD_1] = cmdpacket0(R300_US_CODE_ADDR_0, 4);
ALLOC_STATE(fpt, variable, R300_FPT_CMDSIZE, 0);
r300->hw.fpt.cmd[R300_FPT_CMD_0] = cmdpacket0(R300_PFS_TEXI_0, 0);
r300->hw.fpt.cmd[R300_FPT_CMD_0] = cmdpacket0(R300_US_TEX_INST_0, 0);
ALLOC_STATE(fpi[0], variable, R300_FPI_CMDSIZE, 0);
r300->hw.fpi[0].cmd[R300_FPI_CMD_0] = cmdpacket0(R300_PFS_INSTR0_0, 1);
r300->hw.fpi[0].cmd[R300_FPI_CMD_0] = cmdpacket0(R300_US_ALU_RGB_INST_0, 1);
ALLOC_STATE(fpi[1], variable, R300_FPI_CMDSIZE, 1);
r300->hw.fpi[1].cmd[R300_FPI_CMD_0] = cmdpacket0(R300_PFS_INSTR1_0, 1);
r300->hw.fpi[1].cmd[R300_FPI_CMD_0] = cmdpacket0(R300_US_ALU_RGB_ADDR_0, 1);
ALLOC_STATE(fpi[2], variable, R300_FPI_CMDSIZE, 2);
r300->hw.fpi[2].cmd[R300_FPI_CMD_0] = cmdpacket0(R300_PFS_INSTR2_0, 1);
r300->hw.fpi[2].cmd[R300_FPI_CMD_0] = cmdpacket0(R300_US_ALU_ALPHA_INST_0, 1);
ALLOC_STATE(fpi[3], variable, R300_FPI_CMDSIZE, 3);
r300->hw.fpi[3].cmd[R300_FPI_CMD_0] = cmdpacket0(R300_PFS_INSTR3_0, 1);
r300->hw.fpi[3].cmd[R300_FPI_CMD_0] = cmdpacket0(R300_US_ALU_ALPHA_ADDR_0, 1);
ALLOC_STATE(fpp, variable, R300_FPP_CMDSIZE, 0);
r300->hw.fpp.cmd[R300_FPP_CMD_0] = cmdpacket0(R300_PFS_PARAM_0_X, 0);
}

207
src/mesa/drivers/dri/r300/r300_fragprog.c
View file

@ -172,19 +172,19 @@ static const struct {
int s_op;
} r300_fpop[] = {
/* *INDENT-OFF* */
{"MAD", 3, R300_FPI0_OUTC_MAD, R300_FPI2_OUTA_MAD},
{"DP3", 2, R300_FPI0_OUTC_DP3, R300_FPI2_OUTA_DP4},
{"DP4", 2, R300_FPI0_OUTC_DP4, R300_FPI2_OUTA_DP4},
{"MIN", 2, R300_FPI0_OUTC_MIN, R300_FPI2_OUTA_MIN},
{"MAX", 2, R300_FPI0_OUTC_MAX, R300_FPI2_OUTA_MAX},
{"CMP", 3, R300_FPI0_OUTC_CMP, R300_FPI2_OUTA_CMP},
{"FRC", 1, R300_FPI0_OUTC_FRC, R300_FPI2_OUTA_FRC},
{"EX2", 1, R300_FPI0_OUTC_REPL_ALPHA, R300_FPI2_OUTA_EX2},
{"LG2", 1, R300_FPI0_OUTC_REPL_ALPHA, R300_FPI2_OUTA_LG2},
{"RCP", 1, R300_FPI0_OUTC_REPL_ALPHA, R300_FPI2_OUTA_RCP},
{"RSQ", 1, R300_FPI0_OUTC_REPL_ALPHA, R300_FPI2_OUTA_RSQ},
{"REPL_ALPHA", 1, R300_FPI0_OUTC_REPL_ALPHA, PFS_INVAL},
{"CMPH", 3, R300_FPI0_OUTC_CMPH, PFS_INVAL},
{"MAD", 3, R300_ALU_OUTC_MAD, R300_ALU_OUTA_MAD},
{"DP3", 2, R300_ALU_OUTC_DP3, R300_ALU_OUTA_DP4},
{"DP4", 2, R300_ALU_OUTC_DP4, R300_ALU_OUTA_DP4},
{"MIN", 2, R300_ALU_OUTC_MIN, R300_ALU_OUTA_MIN},
{"MAX", 2, R300_ALU_OUTC_MAX, R300_ALU_OUTA_MAX},
{"CMP", 3, R300_ALU_OUTC_CMP, R300_ALU_OUTA_CMP},
{"FRC", 1, R300_ALU_OUTC_FRC, R300_ALU_OUTA_FRC},
{"EX2", 1, R300_ALU_OUTC_REPL_ALPHA, R300_ALU_OUTA_EX2},
{"LG2", 1, R300_ALU_OUTC_REPL_ALPHA, R300_ALU_OUTA_LG2},
{"RCP", 1, R300_ALU_OUTC_REPL_ALPHA, R300_ALU_OUTA_RCP},
{"RSQ", 1, R300_ALU_OUTC_REPL_ALPHA, R300_ALU_OUTA_RSQ},
{"REPL_ALPHA", 1, R300_ALU_OUTC_REPL_ALPHA, PFS_INVAL},
{"CMPH", 3, R300_ALU_OUTC_CMPH, PFS_INVAL},
/* *INDENT-ON* */
};
@ -209,17 +209,17 @@ static const struct r300_pfs_swizzle {
GLuint flags;
} v_swiz[] = {
/* *INDENT-OFF* */
{MAKE_SWZ3(X, Y, Z), R300_FPI0_ARGC_SRC0C_XYZ, 4, SLOT_SRC_VECTOR},
{MAKE_SWZ3(X, X, X), R300_FPI0_ARGC_SRC0C_XXX, 4, SLOT_SRC_VECTOR},
{MAKE_SWZ3(Y, Y, Y), R300_FPI0_ARGC_SRC0C_YYY, 4, SLOT_SRC_VECTOR},
{MAKE_SWZ3(Z, Z, Z), R300_FPI0_ARGC_SRC0C_ZZZ, 4, SLOT_SRC_VECTOR},
{MAKE_SWZ3(W, W, W), R300_FPI0_ARGC_SRC0A, 1, SLOT_SRC_SCALAR},
{MAKE_SWZ3(Y, Z, X), R300_FPI0_ARGC_SRC0C_YZX, 1, SLOT_SRC_VECTOR},
{MAKE_SWZ3(Z, X, Y), R300_FPI0_ARGC_SRC0C_ZXY, 1, SLOT_SRC_VECTOR},
{MAKE_SWZ3(W, Z, Y), R300_FPI0_ARGC_SRC0CA_WZY, 1, SLOT_SRC_BOTH},
{MAKE_SWZ3(ONE, ONE, ONE), R300_FPI0_ARGC_ONE, 0, 0},
{MAKE_SWZ3(ZERO, ZERO, ZERO), R300_FPI0_ARGC_ZERO, 0, 0},
{MAKE_SWZ3(HALF, HALF, HALF), R300_FPI0_ARGC_HALF, 0, 0},
{MAKE_SWZ3(X, Y, Z), R300_ALU_ARGC_SRC0C_XYZ, 4, SLOT_SRC_VECTOR},
{MAKE_SWZ3(X, X, X), R300_ALU_ARGC_SRC0C_XXX, 4, SLOT_SRC_VECTOR},
{MAKE_SWZ3(Y, Y, Y), R300_ALU_ARGC_SRC0C_YYY, 4, SLOT_SRC_VECTOR},
{MAKE_SWZ3(Z, Z, Z), R300_ALU_ARGC_SRC0C_ZZZ, 4, SLOT_SRC_VECTOR},
{MAKE_SWZ3(W, W, W), R300_ALU_ARGC_SRC0A, 1, SLOT_SRC_SCALAR},
{MAKE_SWZ3(Y, Z, X), R300_ALU_ARGC_SRC0C_YZX, 1, SLOT_SRC_VECTOR},
{MAKE_SWZ3(Z, X, Y), R300_ALU_ARGC_SRC0C_ZXY, 1, SLOT_SRC_VECTOR},
{MAKE_SWZ3(W, Z, Y), R300_ALU_ARGC_SRC0CA_WZY, 1, SLOT_SRC_BOTH},
{MAKE_SWZ3(ONE, ONE, ONE), R300_ALU_ARGC_ONE, 0, 0},
{MAKE_SWZ3(ZERO, ZERO, ZERO), R300_ALU_ARGC_ZERO, 0, 0},
{MAKE_SWZ3(HALF, HALF, HALF), R300_ALU_ARGC_HALF, 0, 0},
{PFS_INVAL, 0, 0, 0},
/* *INDENT-ON* */
};
@ -252,13 +252,13 @@ static const struct {
GLuint flags;
} s_swiz[] = {
/* *INDENT-OFF* */
{R300_FPI2_ARGA_SRC0C_X, 3, SLOT_SRC_VECTOR},
{R300_FPI2_ARGA_SRC0C_Y, 3, SLOT_SRC_VECTOR},
{R300_FPI2_ARGA_SRC0C_Z, 3, SLOT_SRC_VECTOR},
{R300_FPI2_ARGA_SRC0A, 1, SLOT_SRC_SCALAR},
{R300_FPI2_ARGA_ZERO, 0, 0},
{R300_FPI2_ARGA_ONE, 0, 0},
{R300_FPI2_ARGA_HALF, 0, 0}
{R300_ALU_ARGA_SRC0C_X, 3, SLOT_SRC_VECTOR},
{R300_ALU_ARGA_SRC0C_Y, 3, SLOT_SRC_VECTOR},
{R300_ALU_ARGA_SRC0C_Z, 3, SLOT_SRC_VECTOR},
{R300_ALU_ARGA_SRC0A, 1, SLOT_SRC_SCALAR},
{R300_ALU_ARGA_ZERO, 0, 0},
{R300_ALU_ARGA_ONE, 0, 0},
{R300_ALU_ARGA_HALF, 0, 0}
/* *INDENT-ON* */
};
@ -859,11 +859,11 @@ static int t_hw_dst(struct r300_fragment_program *fp,
switch (index) {
case FRAG_RESULT_COLR:
fp->node[fp->cur_node].flags |=
R300_PFS_NODE_OUTPUT_COLOR;
R300_RGBA_OUT;
break;
case FRAG_RESULT_DEPR:
fp->node[fp->cur_node].flags |=
R300_PFS_NODE_OUTPUT_DEPTH;
R300_W_OUT;
break;
}
return index;
@ -907,7 +907,7 @@ static void emit_tex(struct r300_fragment_program *fp,
din = cs->dest_in_node;
/* Resolve source/dest to hardware registers */
if (opcode != R300_FPITX_OP_KIL) {
if (opcode != R300_TEX_OP_KIL) {
if (fpi->TexSrcTarget == TEXTURE_RECT_INDEX) {
/**
* Hardware uses [0..1]x[0..1] range for rectangle textures
@ -1007,11 +1007,10 @@ static void emit_tex(struct r300_fragment_program *fp,
if (fp->cur_node == 0)
fp->first_node_has_tex = 1;
fp->tex.inst[fp->tex.length++] = 0 | (hwsrc << R300_FPITX_SRC_SHIFT)
| (hwdest << R300_FPITX_DST_SHIFT)
| (unit << R300_FPITX_IMAGE_SHIFT)
/* not entirely sure about this */
| (opcode << R300_FPITX_OPCODE_SHIFT);
fp->tex.inst[fp->tex.length++] = 0 | (hwsrc << R300_SRC_ADDR_SHIFT)
| (hwdest << R300_DST_ADDR_SHIFT)
| (unit << R300_TEX_ID_SHIFT)
| (opcode << R300_TEX_INST_SHIFT);
cs->dest_in_node |= (1 << hwdest);
if (REG_GET_TYPE(coord) != REG_TYPE_CONST)
@ -1228,17 +1227,17 @@ static int find_and_prepare_slot(struct r300_fragment_program *fp,
}
// Emit the source fetch code
fp->alu.inst[pos].inst1 &= ~R300_FPI1_SRC_MASK;
fp->alu.inst[pos].inst1 &= ~R300_ALU_SRC_MASK;
fp->alu.inst[pos].inst1 |=
((cs->slot[pos].vsrc[0] << R300_FPI1_SRC0C_SHIFT) |
(cs->slot[pos].vsrc[1] << R300_FPI1_SRC1C_SHIFT) |
(cs->slot[pos].vsrc[2] << R300_FPI1_SRC2C_SHIFT));
((cs->slot[pos].vsrc[0] << R300_ALU_SRC0C_SHIFT) |
(cs->slot[pos].vsrc[1] << R300_ALU_SRC1C_SHIFT) |
(cs->slot[pos].vsrc[2] << R300_ALU_SRC2C_SHIFT));
fp->alu.inst[pos].inst3 &= ~R300_FPI3_SRC_MASK;
fp->alu.inst[pos].inst3 &= ~R300_ALU_SRC_MASK;
fp->alu.inst[pos].inst3 |=
((cs->slot[pos].ssrc[0] << R300_FPI3_SRC0A_SHIFT) |
(cs->slot[pos].ssrc[1] << R300_FPI3_SRC1A_SHIFT) |
(cs->slot[pos].ssrc[2] << R300_FPI3_SRC2A_SHIFT));
((cs->slot[pos].ssrc[0] << R300_ALU_SRC0A_SHIFT) |
(cs->slot[pos].ssrc[1] << R300_ALU_SRC1A_SHIFT) |
(cs->slot[pos].ssrc[2] << R300_ALU_SRC2A_SHIFT));
// Emit the argument selection code
if (emit_vop) {
@ -1257,17 +1256,17 @@ static int find_and_prepare_slot(struct r300_fragment_program *fp,
ARG_ABS
: 0);
} else {
swz[i] = R300_FPI0_ARGC_ZERO;
swz[i] = R300_ALU_ARGC_ZERO;
}
}
fp->alu.inst[pos].inst0 &=
~(R300_FPI0_ARG0C_MASK | R300_FPI0_ARG1C_MASK |
R300_FPI0_ARG2C_MASK);
~(R300_ALU_ARG0C_MASK | R300_ALU_ARG1C_MASK |
R300_ALU_ARG2C_MASK);
fp->alu.inst[pos].inst0 |=
(swz[0] << R300_FPI0_ARG0C_SHIFT) | (swz[1] <<
R300_FPI0_ARG1C_SHIFT)
| (swz[2] << R300_FPI0_ARG2C_SHIFT);
(swz[0] << R300_ALU_ARG0C_SHIFT) | (swz[1] <<
R300_ALU_ARG1C_SHIFT)
| (swz[2] << R300_ALU_ARG2C_SHIFT);
}
if (emit_sop) {
@ -1286,17 +1285,17 @@ static int find_and_prepare_slot(struct r300_fragment_program *fp,
ARG_ABS
: 0);
} else {
swz[i] = R300_FPI2_ARGA_ZERO;
swz[i] = R300_ALU_ARGA_ZERO;
}
}
fp->alu.inst[pos].inst2 &=
~(R300_FPI2_ARG0A_MASK | R300_FPI2_ARG1A_MASK |
R300_FPI2_ARG2A_MASK);
~(R300_ALU_ARG0A_MASK | R300_ALU_ARG1A_MASK |
R300_ALU_ARG2A_MASK);
fp->alu.inst[pos].inst2 |=
(swz[0] << R300_FPI2_ARG0A_SHIFT) | (swz[1] <<
R300_FPI2_ARG1A_SHIFT)
| (swz[2] << R300_FPI2_ARG2A_SHIFT);
(swz[0] << R300_ALU_ARG0A_SHIFT) | (swz[1] <<
R300_ALU_ARG1A_SHIFT)
| (swz[2] << R300_ALU_ARG2A_SHIFT);
}
return pos;
@ -1333,9 +1332,9 @@ static void emit_arith(struct r300_fragment_program *fp,
emit_vop = GL_FALSE;
emit_sop = GL_FALSE;
if ((mask & WRITEMASK_XYZ) || vop == R300_FPI0_OUTC_DP3)
if ((mask & WRITEMASK_XYZ) || vop == R300_ALU_OUTC_DP3)
emit_vop = GL_TRUE;
if ((mask & WRITEMASK_W) || vop == R300_FPI0_OUTC_REPL_ALPHA)
if ((mask & WRITEMASK_W) || vop == R300_ALU_OUTC_REPL_ALPHA)
emit_sop = GL_TRUE;
pos =
@ -1347,33 +1346,33 @@ static void emit_arith(struct r300_fragment_program *fp,
hwdest = t_hw_dst(fp, dest, GL_FALSE, pos); /* Note: Side effects wrt register allocation */
if (flags & PFS_FLAG_SAT) {
vop |= R300_FPI0_OUTC_SAT;
sop |= R300_FPI2_OUTA_SAT;
vop |= R300_ALU_OUTC_CLAMP;
sop |= R300_ALU_OUTA_CLAMP;
}
/* Throw the pieces together and get FPI0/1 */
/* Throw the pieces together and get ALU/1 */
if (emit_vop) {
fp->alu.inst[pos].inst0 |= vop;
fp->alu.inst[pos].inst1 |= hwdest << R300_FPI1_DSTC_SHIFT;
fp->alu.inst[pos].inst1 |= hwdest << R300_ALU_DSTC_SHIFT;
if (REG_GET_TYPE(dest) == REG_TYPE_OUTPUT) {
if (REG_GET_INDEX(dest) == FRAG_RESULT_COLR) {
fp->alu.inst[pos].inst1 |=
(mask & WRITEMASK_XYZ) <<
R300_FPI1_DSTC_OUTPUT_MASK_SHIFT;
R300_ALU_DSTC_OUTPUT_MASK_SHIFT;
} else
assert(0);
} else {
fp->alu.inst[pos].inst1 |=
(mask & WRITEMASK_XYZ) <<
R300_FPI1_DSTC_REG_MASK_SHIFT;
R300_ALU_DSTC_REG_MASK_SHIFT;
cs->hwtemps[hwdest].vector_valid = pos + 1;
}
}
/* And now FPI2/3 */
/* And now ALU/3 */
if (emit_sop) {
fp->alu.inst[pos].inst2 |= sop;
@ -1381,18 +1380,18 @@ static void emit_arith(struct r300_fragment_program *fp,
if (REG_GET_TYPE(dest) == REG_TYPE_OUTPUT) {
if (REG_GET_INDEX(dest) == FRAG_RESULT_COLR) {
fp->alu.inst[pos].inst3 |=
(hwdest << R300_FPI3_DSTA_SHIFT) |
R300_FPI3_DSTA_OUTPUT;
(hwdest << R300_ALU_DSTA_SHIFT) |
R300_ALU_DSTA_OUTPUT;
} else if (REG_GET_INDEX(dest) ==
FRAG_RESULT_DEPR) {
fp->alu.inst[pos].inst3 |=
R300_FPI3_DSTA_DEPTH;
R300_ALU_DSTA_DEPTH;
} else
assert(0);
} else {
fp->alu.inst[pos].inst3 |=
(hwdest << R300_FPI3_DSTA_SHIFT) |
R300_FPI3_DSTA_REG;
(hwdest << R300_ALU_DSTA_SHIFT) |
R300_ALU_DSTA_REG;
cs->hwtemps[hwdest].scalar_valid = pos + 1;
}
@ -1708,7 +1707,7 @@ static GLboolean parse_program(struct r300_fragment_program *fp)
src[0], undef, undef, flags);
break;
case OPCODE_KIL:
emit_tex(fp, fpi, R300_FPITX_OP_KIL);
emit_tex(fp, fpi, R300_TEX_OP_KIL);
break;
case OPCODE_LG2:
src[0] = t_scalar_src(fp, fpi->SrcReg[0]);
@ -1943,13 +1942,13 @@ static GLboolean parse_program(struct r300_fragment_program *fp)
src[0], pfs_one, negate(src[1]), flags);
break;
case OPCODE_TEX:
emit_tex(fp, fpi, R300_FPITX_OP_TEX);
emit_tex(fp, fpi, R300_TEX_OP_LD);
break;
case OPCODE_TXB:
emit_tex(fp, fpi, R300_FPITX_OP_TXB);
emit_tex(fp, fpi, R300_TEX_OP_TXB);
break;
case OPCODE_TXP:
emit_tex(fp, fpi, R300_FPITX_OP_TXP);
emit_tex(fp, fpi, R300_TEX_OP_TXP);
break;
case OPCODE_XPD:{
src[0] = t_src(fp, fpi->SrcReg[0]);
@ -2282,18 +2281,18 @@ static void dump_program(struct r300_fragment_program *fp)
const char *instr;
switch ((fp->tex.
inst[i] >> R300_FPITX_OPCODE_SHIFT) &
inst[i] >> R300_TEX_INST_SHIFT) &
15) {
case R300_FPITX_OP_TEX:
case R300_TEX_OP_LD:
instr = "TEX";
break;
case R300_FPITX_OP_KIL:
case R300_TEX_OP_KIL:
instr = "KIL";
break;
case R300_FPITX_OP_TXP:
case R300_TEX_OP_TXP:
instr = "TXP";
break;
case R300_FPITX_OP_TXB:
case R300_TEX_OP_TXB:
instr = "TXB";
break;
default:
@ -2304,15 +2303,13 @@ static void dump_program(struct r300_fragment_program *fp)
" %s t%i, %c%i, texture[%i] (%08x)\n",
instr,
(fp->tex.
inst[i] >> R300_FPITX_DST_SHIFT) & 31,
(fp->tex.
inst[i] & R300_FPITX_SRC_CONST) ? 'c' :
inst[i] >> R300_DST_ADDR_SHIFT) & 31,
't',
(fp->tex.
inst[i] >> R300_FPITX_SRC_SHIFT) & 31,
inst[i] >> R300_SRC_ADDR_SHIFT) & 31,
(fp->tex.
inst[i] & R300_FPITX_IMAGE_MASK) >>
R300_FPITX_IMAGE_SHIFT,
inst[i] & R300_TEX_ID_MASK) >>
R300_TEX_ID_SHIFT,
fp->tex.inst[i]);
}
}
@ -2338,45 +2335,45 @@ static void dump_program(struct r300_fragment_program *fp)
dstc[0] = 0;
sprintf(flags, "%s%s%s",
(fp->alu.inst[i].
inst1 & R300_FPI1_DSTC_REG_X) ? "x" : "",
inst1 & R300_ALU_DSTC_REG_X) ? "x" : "",
(fp->alu.inst[i].
inst1 & R300_FPI1_DSTC_REG_Y) ? "y" : "",
inst1 & R300_ALU_DSTC_REG_Y) ? "y" : "",
(fp->alu.inst[i].
inst1 & R300_FPI1_DSTC_REG_Z) ? "z" : "");
inst1 & R300_ALU_DSTC_REG_Z) ? "z" : "");
if (flags[0] != 0) {
sprintf(dstc, "t%i.%s ",
(fp->alu.inst[i].
inst1 >> R300_FPI1_DSTC_SHIFT) & 31,
inst1 >> R300_ALU_DSTC_SHIFT) & 31,
flags);
}
sprintf(flags, "%s%s%s",
(fp->alu.inst[i].
inst1 & R300_FPI1_DSTC_OUTPUT_X) ? "x" : "",
inst1 & R300_ALU_DSTC_OUTPUT_X) ? "x" : "",
(fp->alu.inst[i].
inst1 & R300_FPI1_DSTC_OUTPUT_Y) ? "y" : "",
inst1 & R300_ALU_DSTC_OUTPUT_Y) ? "y" : "",
(fp->alu.inst[i].
inst1 & R300_FPI1_DSTC_OUTPUT_Z) ? "z" : "");
inst1 & R300_ALU_DSTC_OUTPUT_Z) ? "z" : "");
if (flags[0] != 0) {
sprintf(tmp, "o%i.%s",
(fp->alu.inst[i].
inst1 >> R300_FPI1_DSTC_SHIFT) & 31,
inst1 >> R300_ALU_DSTC_SHIFT) & 31,
flags);
strcat(dstc, tmp);
}
dsta[0] = 0;
if (fp->alu.inst[i].inst3 & R300_FPI3_DSTA_REG) {
if (fp->alu.inst[i].inst3 & R300_ALU_DSTA_REG) {
sprintf(dsta, "t%i.w ",
(fp->alu.inst[i].
inst3 >> R300_FPI3_DSTA_SHIFT) & 31);
inst3 >> R300_ALU_DSTA_SHIFT) & 31);
}
if (fp->alu.inst[i].inst3 & R300_FPI3_DSTA_OUTPUT) {
if (fp->alu.inst[i].inst3 & R300_ALU_DSTA_OUTPUT) {
sprintf(tmp, "o%i.w ",
(fp->alu.inst[i].
inst3 >> R300_FPI3_DSTA_SHIFT) & 31);
inst3 >> R300_ALU_DSTA_SHIFT) & 31);
strcat(dsta, tmp);
}
if (fp->alu.inst[i].inst3 & R300_FPI3_DSTA_DEPTH) {
if (fp->alu.inst[i].inst3 & R300_ALU_DSTA_DEPTH) {
strcat(dsta, "Z");
}
@ -2396,19 +2393,19 @@ static void dump_program(struct r300_fragment_program *fp)
d = regc & 31;
if (d < 12) {
switch (d % 4) {
case R300_FPI0_ARGC_SRC0C_XYZ:
case R300_ALU_ARGC_SRC0C_XYZ:
sprintf(buf, "%s.xyz",
srcc[d / 4]);
break;
case R300_FPI0_ARGC_SRC0C_XXX:
case R300_ALU_ARGC_SRC0C_XXX:
sprintf(buf, "%s.xxx",
srcc[d / 4]);
break;
case R300_FPI0_ARGC_SRC0C_YYY:
case R300_ALU_ARGC_SRC0C_YYY:
sprintf(buf, "%s.yyy",
srcc[d / 4]);
break;
case R300_FPI0_ARGC_SRC0C_ZZZ:
case R300_ALU_ARGC_SRC0C_ZZZ:
sprintf(buf, "%s.zzz",
srcc[d / 4]);
break;

64
src/mesa/drivers/dri/r300/r300_fragprog.h
View file

@ -75,23 +75,23 @@ typedef struct r300_fragment_program_swizzle {
#define SRC_STRIDE 6
#define NOP_INST0 ( \
(R300_FPI0_OUTC_MAD) | \
(R300_FPI0_ARGC_ZERO << R300_FPI0_ARG0C_SHIFT) | \
(R300_FPI0_ARGC_ZERO << R300_FPI0_ARG1C_SHIFT) | \
(R300_FPI0_ARGC_ZERO << R300_FPI0_ARG2C_SHIFT))
(R300_ALU_OUTC_MAD) | \
(R300_ALU_ARGC_ZERO << R300_ALU_ARG0C_SHIFT) | \
(R300_ALU_ARGC_ZERO << R300_ALU_ARG1C_SHIFT) | \
(R300_ALU_ARGC_ZERO << R300_ALU_ARG2C_SHIFT))
#define NOP_INST1 ( \
((0 | SRC_CONST) << R300_FPI1_SRC0C_SHIFT) | \
((0 | SRC_CONST) << R300_FPI1_SRC1C_SHIFT) | \
((0 | SRC_CONST) << R300_FPI1_SRC2C_SHIFT))
((0 | SRC_CONST) << R300_ALU_SRC0C_SHIFT) | \
((0 | SRC_CONST) << R300_ALU_SRC1C_SHIFT) | \
((0 | SRC_CONST) << R300_ALU_SRC2C_SHIFT))
#define NOP_INST2 ( \
(R300_FPI2_OUTA_MAD) | \
(R300_FPI2_ARGA_ZERO << R300_FPI2_ARG0A_SHIFT) | \
(R300_FPI2_ARGA_ZERO << R300_FPI2_ARG1A_SHIFT) | \
(R300_FPI2_ARGA_ZERO << R300_FPI2_ARG2A_SHIFT))
(R300_ALU_OUTA_MAD) | \
(R300_ALU_ARGA_ZERO << R300_ALU_ARG0A_SHIFT) | \
(R300_ALU_ARGA_ZERO << R300_ALU_ARG1A_SHIFT) | \
(R300_ALU_ARGA_ZERO << R300_ALU_ARG2A_SHIFT))
#define NOP_INST3 ( \
((0 | SRC_CONST) << R300_FPI3_SRC0A_SHIFT) | \
((0 | SRC_CONST) << R300_FPI3_SRC1A_SHIFT) | \
((0 | SRC_CONST) << R300_FPI3_SRC2A_SHIFT))
((0 | SRC_CONST) << R300_ALU_SRC0A_SHIFT) | \
((0 | SRC_CONST) << R300_ALU_SRC1A_SHIFT) | \
((0 | SRC_CONST) << R300_ALU_SRC2A_SHIFT))
#define DRI_CONF_FP_OPTIMIZATION_SPEED 0
#define DRI_CONF_FP_OPTIMIZATION_QUALITY 1
@ -117,42 +117,42 @@ typedef struct r300_fragment_program_swizzle {
#define FP_SELC_MASK_XYZ 7
#define FP_SELC(destidx,regmask,outmask,src0,src1,src2) \
(((destidx) << R300_FPI1_DSTC_SHIFT) | \
(((destidx) << R300_ALU_DSTC_SHIFT) | \
(FP_SELC_MASK_##regmask << 23) | \
(FP_SELC_MASK_##outmask << 26) | \
((src0) << R300_FPI1_SRC0C_SHIFT) | \
((src1) << R300_FPI1_SRC1C_SHIFT) | \
((src2) << R300_FPI1_SRC2C_SHIFT))
((src0) << R300_ALU_SRC0C_SHIFT) | \
((src1) << R300_ALU_SRC1C_SHIFT) | \
((src2) << R300_ALU_SRC2C_SHIFT))
#define FP_SELA_MASK_NO 0
#define FP_SELA_MASK_W 1
#define FP_SELA(destidx,regmask,outmask,src0,src1,src2) \
(((destidx) << R300_FPI3_DSTA_SHIFT) | \
(((destidx) << R300_ALU_DSTA_SHIFT) | \
(FP_SELA_MASK_##regmask << 23) | \
(FP_SELA_MASK_##outmask << 24) | \
((src0) << R300_FPI3_SRC0A_SHIFT) | \
((src1) << R300_FPI3_SRC1A_SHIFT) | \
((src2) << R300_FPI3_SRC2A_SHIFT))
((src0) << R300_ALU_SRC0A_SHIFT) | \
((src1) << R300_ALU_SRC1A_SHIFT) | \
((src2) << R300_ALU_SRC2A_SHIFT))
/* Produce unshifted argument selectors */
#define FP_ARGC(source) R300_FPI0_ARGC_##source
#define FP_ARGA(source) R300_FPI2_ARGA_##source
#define FP_ARGC(source) R300_ALU_ARGC_##source
#define FP_ARGA(source) R300_ALU_ARGA_##source
#define FP_ABS(arg) ((arg) | (1 << 6))
#define FP_NEG(arg) ((arg) ^ (1 << 5))
/* Produce instruction dword */
#define FP_INSTRC(opcode,arg0,arg1,arg2) \
(R300_FPI0_OUTC_##opcode | \
((arg0) << R300_FPI0_ARG0C_SHIFT) | \
((arg1) << R300_FPI0_ARG1C_SHIFT) | \
((arg2) << R300_FPI0_ARG2C_SHIFT))
(R300_ALU_OUTC_##opcode | \
((arg0) << R300_ALU_ARG0C_SHIFT) | \
((arg1) << R300_ALU_ARG1C_SHIFT) | \
((arg2) << R300_ALU_ARG2C_SHIFT))
#define FP_INSTRA(opcode,arg0,arg1,arg2) \
(R300_FPI2_OUTA_##opcode | \
((arg0) << R300_FPI2_ARG0A_SHIFT) | \
((arg1) << R300_FPI2_ARG1A_SHIFT) | \
((arg2) << R300_FPI2_ARG2A_SHIFT))
(R300_ALU_OUTA_##opcode | \
((arg0) << R300_ALU_ARG0A_SHIFT) | \
((arg1) << R300_ALU_ARG1A_SHIFT) | \
((arg2) << R300_ALU_ARG2A_SHIFT))
#endif

14
src/mesa/drivers/dri/r300/r300_ioctl.c
View file

@ -330,31 +330,31 @@ static void r300EmitClearState(GLcontext * ctx)
if (!is_r500) {
R300_STATECHANGE(r300, fp);
reg_start(R300_PFS_CNTL_0, 2);
reg_start(R300_US_CONFIG, 2);
e32(0x0);
e32(0x0);
e32(0x0);
reg_start(R300_PFS_NODE_0, 3);
reg_start(R300_US_CODE_ADDR_0, 3);
e32(0x0);
e32(0x0);
e32(0x0);
e32(R300_PFS_NODE_OUTPUT_COLOR);
e32(R300_RGBA_OUT);
R300_STATECHANGE(r300, fpi[0]);
R300_STATECHANGE(r300, fpi[1]);
R300_STATECHANGE(r300, fpi[2]);
R300_STATECHANGE(r300, fpi[3]);
reg_start(R300_PFS_INSTR0_0, 0);
reg_start(R300_US_ALU_RGB_INST_0, 0);
e32(FP_INSTRC(MAD, FP_ARGC(SRC0C_XYZ), FP_ARGC(ONE), FP_ARGC(ZERO)));
reg_start(R300_PFS_INSTR1_0, 0);
reg_start(R300_US_ALU_RGB_ADDR_0, 0);
e32(FP_SELC(0, NO, XYZ, FP_TMP(0), 0, 0));
reg_start(R300_PFS_INSTR2_0, 0);
reg_start(R300_US_ALU_ALPHA_INST_0, 0);
e32(FP_INSTRA(MAD, FP_ARGA(SRC0A), FP_ARGA(ONE), FP_ARGA(ZERO)));
reg_start(R300_PFS_INSTR3_0, 0);
reg_start(R300_US_ALU_ALPHA_ADDR_0, 0);
e32(FP_SELA(0, NO, W, FP_TMP(0), 0, 0));
} else {
R300_STATECHANGE(r300, r500fp);

447
src/mesa/drivers/dri/r300/r300_reg.h
View file

@ -1596,23 +1596,23 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
* offsets into the respective instruction streams, while *_END points to the
* last instruction relative to this offset.
*/
#define R300_PFS_CNTL_0 0x4600
#define R300_US_CONFIG 0x4600
# define R300_PFS_CNTL_LAST_NODES_SHIFT 0
# define R300_PFS_CNTL_LAST_NODES_MASK (3 << 0)
# define R300_PFS_CNTL_FIRST_NODE_HAS_TEX (1 << 3)
#define R300_PFS_CNTL_1 0x4604
#define R300_US_PIXSIZE 0x4604
/* There is an unshifted value here which has so far always been equal to the
* index of the highest used temporary register.
*/
#define R300_PFS_CNTL_2 0x4608
#define R300_US_CODE_OFFSET 0x4608
# define R300_PFS_CNTL_ALU_OFFSET_SHIFT 0
# define R300_PFS_CNTL_ALU_OFFSET_MASK (63 << 0)
# define R300_PFS_CNTL_ALU_END_SHIFT 6
# define R300_PFS_CNTL_ALU_END_MASK (63 << 6)
# define R300_PFS_CNTL_TEX_OFFSET_SHIFT 12
# define R300_PFS_CNTL_TEX_OFFSET_MASK (31 << 12) /* GUESS */
# define R300_PFS_CNTL_TEX_OFFSET_SHIFT 13
# define R300_PFS_CNTL_TEX_OFFSET_MASK (31 << 13)
# define R300_PFS_CNTL_TEX_END_SHIFT 18
# define R300_PFS_CNTL_TEX_END_MASK (31 << 18) /* GUESS */
# define R300_PFS_CNTL_TEX_END_MASK (31 << 18)
/* gap */
@ -1623,70 +1623,65 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* Offsets are relative to the master offset from PFS_CNTL_2.
*/
#define R300_PFS_NODE_0 0x4610
#define R300_PFS_NODE_1 0x4614
#define R300_PFS_NODE_2 0x4618
#define R300_PFS_NODE_3 0x461C
# define R300_PFS_NODE_ALU_OFFSET_SHIFT 0
# define R300_PFS_NODE_ALU_OFFSET_MASK (63 << 0)
# define R300_PFS_NODE_ALU_END_SHIFT 6
# define R300_PFS_NODE_ALU_END_MASK (63 << 6)
# define R300_PFS_NODE_TEX_OFFSET_SHIFT 12
# define R300_PFS_NODE_TEX_OFFSET_MASK (31 << 12)
# define R300_PFS_NODE_TEX_END_SHIFT 17
# define R300_PFS_NODE_TEX_END_MASK (31 << 17)
# define R300_PFS_NODE_OUTPUT_COLOR (1 << 22)
# define R300_PFS_NODE_OUTPUT_DEPTH (1 << 23)
#define R300_US_CODE_ADDR_0 0x4610
#define R300_US_CODE_ADDR_1 0x4614
#define R300_US_CODE_ADDR_2 0x4618
#define R300_US_CODE_ADDR_3 0x461C
# define R300_ALU_START_SHIFT 0
# define R300_ALU_START_MASK (63 << 0)
# define R300_ALU_SIZE_SHIFT 6
# define R300_ALU_SIZE_MASK (63 << 6)
# define R300_TEX_START_SHIFT 12
# define R300_TEX_START_MASK (31 << 12)
# define R300_TEX_SIZE_SHIFT 17
# define R300_TEX_SIZE_MASK (31 << 17)
# define R300_RGBA_OUT (1 << 22)
# define R300_W_OUT (1 << 23)
/* TEX
* As far as I can tell, texture instructions cannot write into output
* registers directly. A subsequent ALU instruction is always necessary,
* even if it's just MAD o0, r0, 1, 0
*/
#define R300_PFS_TEXI_0 0x4620
# define R300_FPITX_SRC_SHIFT 0
# define R300_FPITX_SRC_MASK (31 << 0)
/* GUESS */
# define R300_FPITX_SRC_CONST (1 << 5)
# define R300_FPITX_DST_SHIFT 6
# define R300_FPITX_DST_MASK (31 << 6)
# define R300_FPITX_IMAGE_SHIFT 11
/* GUESS based on layout and native limits */
# define R300_FPITX_IMAGE_MASK (15 << 11)
/* Unsure if these are opcodes, or some kind of bitfield, but this is how
* they were set when I checked
*/
# define R300_FPITX_OPCODE_SHIFT 15
# define R300_FPITX_OP_TEX 1
# define R300_FPITX_OP_KIL 2
# define R300_FPITX_OP_TXP 3
# define R300_FPITX_OP_TXB 4
# define R300_FPITX_OPCODE_MASK (7 << 15)
#define R300_US_TEX_INST_0 0x4620
# define R300_SRC_ADDR_SHIFT 0
# define R300_SRC_ADDR_MASK (31 << 0)
# define R300_DST_ADDR_SHIFT 6
# define R300_DST_ADDR_MASK (31 << 6)
# define R300_TEX_ID_SHIFT 11
# define R300_TEX_ID_MASK (15 << 11)
# define R300_TEX_INST_SHIFT 15
# define R300_TEX_OP_NOP 0
# define R300_TEX_OP_LD 1
# define R300_TEX_OP_KIL 2
# define R300_TEX_OP_TXP 3
# define R300_TEX_OP_TXB 4
# define R300_TEX_INST_MASK (7 << 15)
/* Output format from the unfied shader */
#define R500_US_OUT_FMT 0x46A4
# define R500_US_OUT_FMT_C4_8 (0 << 0)
# define R500_US_OUT_FMT_C4_10 (1 << 0)
# define R500_US_OUT_FMT_C4_10_GAMMA (2 << 0)
# define R500_US_OUT_FMT_C_16 (3 << 0)
# define R500_US_OUT_FMT_C2_16 (4 << 0)
# define R500_US_OUT_FMT_C4_16 (5 << 0)
# define R500_US_OUT_FMT_C_16_MPEG (6 << 0)
# define R500_US_OUT_FMT_C2_16_MPEG (7 << 0)
# define R500_US_OUT_FMT_C2_4 (8 << 0)
# define R500_US_OUT_FMT_C_3_3_2 (9 << 0)
# define R500_US_OUT_FMT_C_6_5_6 (10 << 0)
# define R500_US_OUT_FMT_C_11_11_10 (11 << 0)
# define R500_US_OUT_FMT_C_10_11_11 (12 << 0)
# define R500_US_OUT_FMT_C_2_10_10_10 (13 << 0)
#define R300_US_OUT_FMT 0x46A4
# define R300_US_OUT_FMT_C4_8 (0 << 0)
# define R300_US_OUT_FMT_C4_10 (1 << 0)
# define R300_US_OUT_FMT_C4_10_GAMMA (2 << 0)
# define R300_US_OUT_FMT_C_16 (3 << 0)
# define R300_US_OUT_FMT_C2_16 (4 << 0)
# define R300_US_OUT_FMT_C4_16 (5 << 0)
# define R300_US_OUT_FMT_C_16_MPEG (6 << 0)
# define R300_US_OUT_FMT_C2_16_MPEG (7 << 0)
# define R300_US_OUT_FMT_C2_4 (8 << 0)
# define R300_US_OUT_FMT_C_3_3_2 (9 << 0)
# define R300_US_OUT_FMT_C_6_5_6 (10 << 0)
# define R300_US_OUT_FMT_C_11_11_10 (11 << 0)
# define R300_US_OUT_FMT_C_10_11_11 (12 << 0)
# define R300_US_OUT_FMT_C_2_10_10_10 (13 << 0)
/* reserved */
# define R500_US_OUT_FMT_UNUSED (15 << 0)
# define R500_US_OUT_FMT_C_16_FP (16 << 0)
# define R500_US_OUT_FMT_C2_16_FP (17 << 0)
# define R500_US_OUT_FMT_C4_16_FP (18 << 0)
# define R500_US_OUT_FMT_C_32_FP (19 << 0)
# define R500_US_OUT_FMT_C2_32_FP (20 << 0)
# define R500_US_OUT_FMT_C4_32_FP (20 << 0)
# define R300_US_OUT_FMT_UNUSED (15 << 0)
# define R300_US_OUT_FMT_C_16_FP (16 << 0)
# define R300_US_OUT_FMT_C2_16_FP (17 << 0)
# define R300_US_OUT_FMT_C4_16_FP (18 << 0)
# define R300_US_OUT_FMT_C_32_FP (19 << 0)
# define R300_US_OUT_FMT_C2_32_FP (20 << 0)
# define R300_US_OUT_FMT_C4_32_FP (20 << 0)
/* ALU
* The ALU instructions register blocks are enumerated according to the order
@ -1752,147 +1747,189 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
* - Set FPI0/FPI2_SPECIAL_LRP
* Arbitrary LRP (including support for swizzling) requires vanilla MAD+MAD
*/
#define R300_PFS_INSTR1_0 0x46C0
# define R300_FPI1_SRC0C_SHIFT 0
# define R300_FPI1_SRC0C_MASK (31 << 0)
# define R300_FPI1_SRC0C_CONST (1 << 5)
# define R300_FPI1_SRC1C_SHIFT 6
# define R300_FPI1_SRC1C_MASK (31 << 6)
# define R300_FPI1_SRC1C_CONST (1 << 11)
# define R300_FPI1_SRC2C_SHIFT 12
# define R300_FPI1_SRC2C_MASK (31 << 12)
# define R300_FPI1_SRC2C_CONST (1 << 17)
# define R300_FPI1_SRC_MASK 0x0003ffff
# define R300_FPI1_DSTC_SHIFT 18
# define R300_FPI1_DSTC_MASK (31 << 18)
# define R300_FPI1_DSTC_REG_MASK_SHIFT 23
# define R300_FPI1_DSTC_REG_X (1 << 23)
# define R300_FPI1_DSTC_REG_Y (1 << 24)
# define R300_FPI1_DSTC_REG_Z (1 << 25)
# define R300_FPI1_DSTC_OUTPUT_MASK_SHIFT 26
# define R300_FPI1_DSTC_OUTPUT_X (1 << 26)
# define R300_FPI1_DSTC_OUTPUT_Y (1 << 27)
# define R300_FPI1_DSTC_OUTPUT_Z (1 << 28)
#define R300_US_ALU_RGB_ADDR_0 0x46C0
# define R300_ALU_SRC0C_SHIFT 0
# define R300_ALU_SRC0C_MASK (31 << 0)
# define R300_ALU_SRC0C_CONST (1 << 5)
# define R300_ALU_SRC1C_SHIFT 6
# define R300_ALU_SRC1C_MASK (31 << 6)
# define R300_ALU_SRC1C_CONST (1 << 11)
# define R300_ALU_SRC2C_SHIFT 12
# define R300_ALU_SRC2C_MASK (31 << 12)
# define R300_ALU_SRC2C_CONST (1 << 17)
# define R300_ALU_SRC_MASK 0x0003ffff
# define R300_ALU_DSTC_SHIFT 18
# define R300_ALU_DSTC_MASK (31 << 18)
# define R300_ALU_DSTC_REG_MASK_SHIFT 23
# define R300_ALU_DSTC_REG_X (1 << 23)
# define R300_ALU_DSTC_REG_Y (1 << 24)
# define R300_ALU_DSTC_REG_Z (1 << 25)
# define R300_ALU_DSTC_OUTPUT_MASK_SHIFT 26
# define R300_ALU_DSTC_OUTPUT_X (1 << 26)
# define R300_ALU_DSTC_OUTPUT_Y (1 << 27)
# define R300_ALU_DSTC_OUTPUT_Z (1 << 28)
#define R300_PFS_INSTR3_0 0x47C0
# define R300_FPI3_SRC0A_SHIFT 0
# define R300_FPI3_SRC0A_MASK (31 << 0)
# define R300_FPI3_SRC0A_CONST (1 << 5)
# define R300_FPI3_SRC1A_SHIFT 6
# define R300_FPI3_SRC1A_MASK (31 << 6)
# define R300_FPI3_SRC1A_CONST (1 << 11)
# define R300_FPI3_SRC2A_SHIFT 12
# define R300_FPI3_SRC2A_MASK (31 << 12)
# define R300_FPI3_SRC2A_CONST (1 << 17)
# define R300_FPI3_SRC_MASK 0x0003ffff
# define R300_FPI3_DSTA_SHIFT 18
# define R300_FPI3_DSTA_MASK (31 << 18)
# define R300_FPI3_DSTA_REG (1 << 23)
# define R300_FPI3_DSTA_OUTPUT (1 << 24)
# define R300_FPI3_DSTA_DEPTH (1 << 27)
#define R300_US_ALU_ALPHA_ADDR_0 0x47C0
# define R300_ALU_SRC0A_SHIFT 0
# define R300_ALU_SRC0A_MASK (31 << 0)
# define R300_ALU_SRC0A_CONST (1 << 5)
# define R300_ALU_SRC1A_SHIFT 6
# define R300_ALU_SRC1A_MASK (31 << 6)
# define R300_ALU_SRC1A_CONST (1 << 11)
# define R300_ALU_SRC2A_SHIFT 12
# define R300_ALU_SRC2A_MASK (31 << 12)
# define R300_ALU_SRC2A_CONST (1 << 17)
# define R300_ALU_SRC_MASK 0x0003ffff
# define R300_ALU_DSTA_SHIFT 18
# define R300_ALU_DSTA_MASK (31 << 18)
# define R300_ALU_DSTA_REG (1 << 23)
# define R300_ALU_DSTA_OUTPUT (1 << 24)
# define R300_ALU_DSTA_DEPTH (1 << 27)
#define R300_PFS_INSTR0_0 0x48C0
# define R300_FPI0_ARGC_SRC0C_XYZ 0
# define R300_FPI0_ARGC_SRC0C_XXX 1
# define R300_FPI0_ARGC_SRC0C_YYY 2
# define R300_FPI0_ARGC_SRC0C_ZZZ 3
# define R300_FPI0_ARGC_SRC1C_XYZ 4
# define R300_FPI0_ARGC_SRC1C_XXX 5
# define R300_FPI0_ARGC_SRC1C_YYY 6
# define R300_FPI0_ARGC_SRC1C_ZZZ 7
# define R300_FPI0_ARGC_SRC2C_XYZ 8
# define R300_FPI0_ARGC_SRC2C_XXX 9
# define R300_FPI0_ARGC_SRC2C_YYY 10
# define R300_FPI0_ARGC_SRC2C_ZZZ 11
# define R300_FPI0_ARGC_SRC0A 12
# define R300_FPI0_ARGC_SRC1A 13
# define R300_FPI0_ARGC_SRC2A 14
# define R300_FPI0_ARGC_SRC1C_LRP 15
# define R300_FPI0_ARGC_ZERO 20
# define R300_FPI0_ARGC_ONE 21
/* GUESS */
# define R300_FPI0_ARGC_HALF 22
# define R300_FPI0_ARGC_SRC0C_YZX 23
# define R300_FPI0_ARGC_SRC1C_YZX 24
# define R300_FPI0_ARGC_SRC2C_YZX 25
# define R300_FPI0_ARGC_SRC0C_ZXY 26
# define R300_FPI0_ARGC_SRC1C_ZXY 27
# define R300_FPI0_ARGC_SRC2C_ZXY 28
# define R300_FPI0_ARGC_SRC0CA_WZY 29
# define R300_FPI0_ARGC_SRC1CA_WZY 30
# define R300_FPI0_ARGC_SRC2CA_WZY 31
#define R300_US_ALU_RGB_INST_0 0x48C0
# define R300_ALU_ARGC_SRC0C_XYZ 0
# define R300_ALU_ARGC_SRC0C_XXX 1
# define R300_ALU_ARGC_SRC0C_YYY 2
# define R300_ALU_ARGC_SRC0C_ZZZ 3
# define R300_ALU_ARGC_SRC1C_XYZ 4
# define R300_ALU_ARGC_SRC1C_XXX 5
# define R300_ALU_ARGC_SRC1C_YYY 6
# define R300_ALU_ARGC_SRC1C_ZZZ 7
# define R300_ALU_ARGC_SRC2C_XYZ 8
# define R300_ALU_ARGC_SRC2C_XXX 9
# define R300_ALU_ARGC_SRC2C_YYY 10
# define R300_ALU_ARGC_SRC2C_ZZZ 11
# define R300_ALU_ARGC_SRC0A 12
# define R300_ALU_ARGC_SRC1A 13
# define R300_ALU_ARGC_SRC2A 14
# define R300_ALU_ARGC_SRCP_XYZ 15
# define R300_ALU_ARGC_SRCP_XXX 16
# define R300_ALU_ARGC_SRCP_YYY 17
# define R300_ALU_ARGC_SRCP_ZZZ 18
# define R300_ALU_ARGC_SRCP_WWW 19
# define R300_ALU_ARGC_ZERO 20
# define R300_ALU_ARGC_ONE 21
# define R300_ALU_ARGC_HALF 22
# define R300_ALU_ARGC_SRC0C_YZX 23
# define R300_ALU_ARGC_SRC1C_YZX 24
# define R300_ALU_ARGC_SRC2C_YZX 25
# define R300_ALU_ARGC_SRC0C_ZXY 26
# define R300_ALU_ARGC_SRC1C_ZXY 27
# define R300_ALU_ARGC_SRC2C_ZXY 28
# define R300_ALU_ARGC_SRC0CA_WZY 29
# define R300_ALU_ARGC_SRC1CA_WZY 30
# define R300_ALU_ARGC_SRC2CA_WZY 31
# define R300_FPI0_ARG0C_SHIFT 0
# define R300_FPI0_ARG0C_MASK (31 << 0)
# define R300_FPI0_ARG0C_NEG (1 << 5)
# define R300_FPI0_ARG0C_ABS (1 << 6)
# define R300_FPI0_ARG1C_SHIFT 7
# define R300_FPI0_ARG1C_MASK (31 << 7)
# define R300_FPI0_ARG1C_NEG (1 << 12)
# define R300_FPI0_ARG1C_ABS (1 << 13)
# define R300_FPI0_ARG2C_SHIFT 14
# define R300_FPI0_ARG2C_MASK (31 << 14)
# define R300_FPI0_ARG2C_NEG (1 << 19)
# define R300_FPI0_ARG2C_ABS (1 << 20)
# define R300_FPI0_SPECIAL_LRP (1 << 21)
# define R300_FPI0_OUTC_MAD (0 << 23)
# define R300_FPI0_OUTC_DP3 (1 << 23)
# define R300_FPI0_OUTC_DP4 (2 << 23)
# define R300_FPI0_OUTC_MIN (4 << 23)
# define R300_FPI0_OUTC_MAX (5 << 23)
# define R300_FPI0_OUTC_CMPH (7 << 23)
# define R300_FPI0_OUTC_CMP (8 << 23)
# define R300_FPI0_OUTC_FRC (9 << 23)
# define R300_FPI0_OUTC_REPL_ALPHA (10 << 23)
# define R300_FPI0_OUTC_SAT (1 << 30)
# define R300_FPI0_INSERT_NOP (1 << 31)
# define R300_ALU_ARG0C_SHIFT 0
# define R300_ALU_ARG0C_MASK (31 << 0)
# define R300_ALU_ARG0C_NOP (0 << 5)
# define R300_ALU_ARG0C_NEG (1 << 5)
# define R300_ALU_ARG0C_ABS (2 << 5)
# define R300_ALU_ARG0C_NAB (3 << 5)
# define R300_ALU_ARG1C_SHIFT 7
# define R300_ALU_ARG1C_MASK (31 << 7)
# define R300_ALU_ARG1C_NOP (0 << 12)
# define R300_ALU_ARG1C_NEG (1 << 12)
# define R300_ALU_ARG1C_ABS (2 << 12)
# define R300_ALU_ARG1C_NAB (3 << 12)
# define R300_ALU_ARG2C_SHIFT 14
# define R300_ALU_ARG2C_MASK (31 << 14)
# define R300_ALU_ARG2C_NOP (0 << 19)
# define R300_ALU_ARG2C_NEG (1 << 19)
# define R300_ALU_ARG2C_ABS (2 << 19)
# define R300_ALU_ARG2C_NAB (3 << 19)
# define R300_ALU_SRCP_1_MINUS_2_SRC0 (0 << 21)
# define R300_ALU_SRCP_SRC1_MINUS_SRC0 (1 << 21)
# define R300_ALU_SRCP_SRC1_PLUS_SRC0 (2 << 21)
# define R300_ALU_SRCP_1_MINUS_SRC0 (3 << 21)
#define R300_PFS_INSTR2_0 0x49C0
# define R300_FPI2_ARGA_SRC0C_X 0
# define R300_FPI2_ARGA_SRC0C_Y 1
# define R300_FPI2_ARGA_SRC0C_Z 2
# define R300_FPI2_ARGA_SRC1C_X 3
# define R300_FPI2_ARGA_SRC1C_Y 4
# define R300_FPI2_ARGA_SRC1C_Z 5
# define R300_FPI2_ARGA_SRC2C_X 6
# define R300_FPI2_ARGA_SRC2C_Y 7
# define R300_FPI2_ARGA_SRC2C_Z 8
# define R300_FPI2_ARGA_SRC0A 9
# define R300_FPI2_ARGA_SRC1A 10
# define R300_FPI2_ARGA_SRC2A 11
# define R300_FPI2_ARGA_SRC1A_LRP 15
# define R300_FPI2_ARGA_ZERO 16
# define R300_FPI2_ARGA_ONE 17
/* GUESS */
# define R300_FPI2_ARGA_HALF 18
# define R300_FPI2_ARG0A_SHIFT 0
# define R300_FPI2_ARG0A_MASK (31 << 0)
# define R300_FPI2_ARG0A_NEG (1 << 5)
/* GUESS */
# define R300_FPI2_ARG0A_ABS (1 << 6)
# define R300_FPI2_ARG1A_SHIFT 7
# define R300_FPI2_ARG1A_MASK (31 << 7)
# define R300_FPI2_ARG1A_NEG (1 << 12)
/* GUESS */
# define R300_FPI2_ARG1A_ABS (1 << 13)
# define R300_FPI2_ARG2A_SHIFT 14
# define R300_FPI2_ARG2A_MASK (31 << 14)
# define R300_FPI2_ARG2A_NEG (1 << 19)
/* GUESS */
# define R300_FPI2_ARG2A_ABS (1 << 20)
# define R300_FPI2_SPECIAL_LRP (1 << 21)
# define R300_FPI2_OUTA_MAD (0 << 23)
# define R300_FPI2_OUTA_DP4 (1 << 23)
# define R300_FPI2_OUTA_MIN (2 << 23)
# define R300_FPI2_OUTA_MAX (3 << 23)
# define R300_FPI2_OUTA_CMP (6 << 23)
# define R300_FPI2_OUTA_FRC (7 << 23)
# define R300_FPI2_OUTA_EX2 (8 << 23)
# define R300_FPI2_OUTA_LG2 (9 << 23)
# define R300_FPI2_OUTA_RCP (10 << 23)
# define R300_FPI2_OUTA_RSQ (11 << 23)
# define R300_FPI2_OUTA_SAT (1 << 30)
# define R300_FPI2_UNKNOWN_31 (1 << 31)
# define R300_ALU_OUTC_MAD (0 << 23)
# define R300_ALU_OUTC_DP3 (1 << 23)
# define R300_ALU_OUTC_DP4 (2 << 23)
# define R300_ALU_OUTC_D2A (3 << 23)
# define R300_ALU_OUTC_MIN (4 << 23)
# define R300_ALU_OUTC_MAX (5 << 23)
# define R300_ALU_OUTC_CMPH (7 << 23)
# define R300_ALU_OUTC_CMP (8 << 23)
# define R300_ALU_OUTC_FRC (9 << 23)
# define R300_ALU_OUTC_REPL_ALPHA (10 << 23)
# define R300_ALU_OUTC_MOD_NOP (0 << 27)
# define R300_ALU_OUTC_MOD_MUL2 (1 << 27)
# define R300_ALU_OUTC_MOD_MUL4 (2 << 27)
# define R300_ALU_OUTC_MOD_MUL8 (3 << 27)
# define R300_ALU_OUTC_MOD_DIV2 (4 << 27)
# define R300_ALU_OUTC_MOD_DIV4 (5 << 27)
# define R300_ALU_OUTC_MOD_DIV8 (6 << 27)
# define R300_ALU_OUTC_CLAMP (1 << 30)
# define R300_ALU_INSERT_NOP (1 << 31)
#define R300_US_ALU_ALPHA_INST_0 0x49C0
# define R300_ALU_ARGA_SRC0C_X 0
# define R300_ALU_ARGA_SRC0C_Y 1
# define R300_ALU_ARGA_SRC0C_Z 2
# define R300_ALU_ARGA_SRC1C_X 3
# define R300_ALU_ARGA_SRC1C_Y 4
# define R300_ALU_ARGA_SRC1C_Z 5
# define R300_ALU_ARGA_SRC2C_X 6
# define R300_ALU_ARGA_SRC2C_Y 7
# define R300_ALU_ARGA_SRC2C_Z 8
# define R300_ALU_ARGA_SRC0A 9
# define R300_ALU_ARGA_SRC1A 10
# define R300_ALU_ARGA_SRC2A 11
# define R300_ALU_ARGA_SRCP_X 12
# define R300_ALU_ARGA_SRCP_Y 13
# define R300_ALU_ARGA_SRCP_Z 14
# define R300_ALU_ARGA_SRCP_W 15
# define R300_ALU_ARGA_ZERO 16
# define R300_ALU_ARGA_ONE 17
# define R300_ALU_ARGA_HALF 18
# define R300_ALU_ARG0A_SHIFT 0
# define R300_ALU_ARG0A_MASK (31 << 0)
# define R300_ALU_ARG0A_NOP (0 << 5)
# define R300_ALU_ARG0A_NEG (1 << 5)
# define R300_ALU_ARG0A_ABS (2 << 5)
# define R300_ALU_ARG0A_NAB (3 << 5)
# define R300_ALU_ARG1A_SHIFT 7
# define R300_ALU_ARG1A_MASK (31 << 7)
# define R300_ALU_ARG1A_NOP (0 << 12)
# define R300_ALU_ARG1A_NEG (1 << 12)
# define R300_ALU_ARG1A_ABS (2 << 12)
# define R300_ALU_ARG1A_NAB (3 << 12)
# define R300_ALU_ARG2A_SHIFT 14
# define R300_ALU_ARG2A_MASK (31 << 14)
# define R300_ALU_ARG2A_NOP (0 << 19)
# define R300_ALU_ARG2A_NEG (1 << 19)
# define R300_ALU_ARG2A_ABS (2 << 19)
# define R300_ALU_ARG2A_NAB (3 << 19)
# define R300_ALU_SRCP_1_MINUS_2_SRC0 (0 << 21)
# define R300_ALU_SRCP_SRC1_MINUS_SRC0 (1 << 21)
# define R300_ALU_SRCP_SRC1_PLUS_SRC0 (2 << 21)
# define R300_ALU_SRCP_1_MINUS_SRC0 (3 << 21)
# define R300_ALU_OUTA_MAD (0 << 23)
# define R300_ALU_OUTA_DP4 (1 << 23)
# define R300_ALU_OUTA_MIN (2 << 23)
# define R300_ALU_OUTA_MAX (3 << 23)
# define R300_ALU_OUTA_CND (5 << 23)
# define R300_ALU_OUTA_CMP (6 << 23)
# define R300_ALU_OUTA_FRC (7 << 23)
# define R300_ALU_OUTA_EX2 (8 << 23)
# define R300_ALU_OUTA_LG2 (9 << 23)
# define R300_ALU_OUTA_RCP (10 << 23)
# define R300_ALU_OUTA_RSQ (11 << 23)
# define R300_ALU_OUTA_MOD_NOP (0 << 27)
# define R300_ALU_OUTA_MOD_MUL2 (1 << 27)
# define R300_ALU_OUTA_MOD_MUL4 (2 << 27)
# define R300_ALU_OUTA_MOD_MUL8 (3 << 27)
# define R300_ALU_OUTA_MOD_DIV2 (4 << 27)
# define R300_ALU_OUTA_MOD_DIV4 (5 << 27)
# define R300_ALU_OUTA_MOD_DIV8 (6 << 27)
# define R300_ALU_OUTA_CLAMP (1 << 30)
/* END: Fragment program instruction set */
/* Fog: Fog Blending Enable */
@ -1967,7 +2004,7 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
#define R300_PFS_PARAM_0_Y 0x4C04
#define R300_PFS_PARAM_0_Z 0x4C08
#define R300_PFS_PARAM_0_W 0x4C0C
/* GUESS: PARAM_31 is last, based on native limits reported by fglrx */
/* last consts */
#define R300_PFS_PARAM_31_X 0x4DF0
#define R300_PFS_PARAM_31_Y 0x4DF4
#define R300_PFS_PARAM_31_Z 0x4DF8
@ -3103,12 +3140,12 @@ enum {
# define R500_TEX_SEM_ACQUIRE (1 << 25)
# define R500_TEX_IGNORE_UNCOVERED (1 << 26)
# define R500_TEX_UNSCALED (1 << 27)
#define R500_US_W_FMT 0x46b4
# define R500_W_FMT_W0 (0 << 0)
# define R500_W_FMT_W24 (1 << 0)
# define R500_W_FMT_W24FP (2 << 0)
# define R500_W_SRC_US (0 << 2)
# define R500_W_SRC_RAS (1 << 2)
#define R300_US_W_FMT 0x46b4
# define R300_W_FMT_W0 (0 << 0)
# define R300_W_FMT_W24 (1 << 0)
# define R300_W_FMT_W24FP (2 << 0)
# define R300_W_SRC_US (0 << 2)
# define R300_W_SRC_RAS (1 << 2)
/* Draw a primitive from vertex data in arrays loaded via 3D_LOAD_VBPNTR.

28
src/mesa/drivers/dri/r300/r300_state.c
View file

@ -1445,21 +1445,21 @@ static void r300SetupTextures(GLcontext * ctx)
int opcode;
unsigned long val;
unit = fp->tex.inst[i] >> R300_FPITX_IMAGE_SHIFT;
unit = fp->tex.inst[i] >> R300_TEX_ID_SHIFT;
unit &= 15;
val = fp->tex.inst[i];
val &= ~R300_FPITX_IMAGE_MASK;
val &= ~R300_TEX_ID_MASK;
opcode =
(val & R300_FPITX_OPCODE_MASK) >> R300_FPITX_OPCODE_SHIFT;
if (opcode == R300_FPITX_OP_KIL) {
(val & R300_TEX_INST_MASK) >> R300_TEX_INST_SHIFT;
if (opcode == R300_TEX_OP_KIL) {
r300->hw.fpt.cmd[R300_FPT_INSTR_0 + i] = val;
} else {
if (tmu_mappings[unit] >= 0) {
val |=
tmu_mappings[unit] <<
R300_FPITX_IMAGE_SHIFT;
R300_TEX_ID_SHIFT;
r300->hw.fpt.cmd[R300_FPT_INSTR_0 + i] = val;
} else {
// We get here when the corresponding texture image is incomplete
@ -1470,7 +1470,7 @@ static void r300SetupTextures(GLcontext * ctx)
}
r300->hw.fpt.cmd[R300_FPT_CMD_0] =
cmdpacket0(R300_PFS_TEXI_0, fp->tex.length);
cmdpacket0(R300_US_TEX_INST_0, fp->tex.length);
}
if (RADEON_DEBUG & DEBUG_STATE)
@ -2371,25 +2371,25 @@ static void r300SetupPixelShader(r300ContextPtr rmesa)
}
R300_STATECHANGE(rmesa, fpi[0]);
rmesa->hw.fpi[0].cmd[R300_FPI_CMD_0] = cmdpacket0(R300_PFS_INSTR0_0, fp->alu_end + 1);
rmesa->hw.fpi[0].cmd[R300_FPI_CMD_0] = cmdpacket0(R300_US_ALU_RGB_INST_0, fp->alu_end + 1);
for (i = 0; i <= fp->alu_end; i++) {
rmesa->hw.fpi[0].cmd[R300_FPI_INSTR_0 + i] = fp->alu.inst[i].inst0;
}
R300_STATECHANGE(rmesa, fpi[1]);
rmesa->hw.fpi[1].cmd[R300_FPI_CMD_0] = cmdpacket0(R300_PFS_INSTR1_0, fp->alu_end + 1);
rmesa->hw.fpi[1].cmd[R300_FPI_CMD_0] = cmdpacket0(R300_US_ALU_RGB_ADDR_0, fp->alu_end + 1);
for (i = 0; i <= fp->alu_end; i++) {
rmesa->hw.fpi[1].cmd[R300_FPI_INSTR_0 + i] = fp->alu.inst[i].inst1;
}
R300_STATECHANGE(rmesa, fpi[2]);
rmesa->hw.fpi[2].cmd[R300_FPI_CMD_0] = cmdpacket0(R300_PFS_INSTR2_0, fp->alu_end + 1);
rmesa->hw.fpi[2].cmd[R300_FPI_CMD_0] = cmdpacket0(R300_US_ALU_ALPHA_INST_0, fp->alu_end + 1);
for (i = 0; i <= fp->alu_end; i++) {
rmesa->hw.fpi[2].cmd[R300_FPI_INSTR_0 + i] = fp->alu.inst[i].inst2;
}
R300_STATECHANGE(rmesa, fpi[3]);
rmesa->hw.fpi[3].cmd[R300_FPI_CMD_0] = cmdpacket0(R300_PFS_INSTR3_0, fp->alu_end + 1);
rmesa->hw.fpi[3].cmd[R300_FPI_CMD_0] = cmdpacket0(R300_US_ALU_ALPHA_ADDR_0, fp->alu_end + 1);
for (i = 0; i <= fp->alu_end; i++) {
rmesa->hw.fpi[3].cmd[R300_FPI_INSTR_0 + i] = fp->alu.inst[i].inst3;
}
@ -2406,10 +2406,10 @@ static void r300SetupPixelShader(r300ContextPtr rmesa)
for (i = 0, k = (4 - (fp->cur_node + 1)); i < 4; i++, k++) {
if (i < (fp->cur_node + 1)) {
rmesa->hw.fp.cmd[R300_FP_NODE0 + k] =
(fp->node[i].alu_offset << R300_PFS_NODE_ALU_OFFSET_SHIFT) |
(fp->node[i].alu_end << R300_PFS_NODE_ALU_END_SHIFT) |
(fp->node[i].tex_offset << R300_PFS_NODE_TEX_OFFSET_SHIFT) |
(fp->node[i].tex_end << R300_PFS_NODE_TEX_END_SHIFT) |
(fp->node[i].alu_offset << R300_ALU_START_SHIFT) |
(fp->node[i].alu_end << R300_ALU_SIZE_SHIFT) |
(fp->node[i].tex_offset << R300_TEX_START_SHIFT) |
(fp->node[i].tex_end << R300_TEX_SIZE_SHIFT) |
fp->node[i].flags;
} else {
rmesa->hw.fp.cmd[R300_FP_NODE0 + (3 - i)] = 0;