/**************************************************************************
*
* Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
* All Rights Reserved.
*
* 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, sub license, 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 NON-INFRINGEMENT.
* IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS 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 "i915_reg.h"
#include "i915_context.h"
#include "i915_batch.h"
#include "i915_debug.h"
#include "i915_fpc.h"
#include "i915_resource.h"
#include "pipe/p_context.h"
#include "pipe/p_defines.h"
#include "pipe/p_format.h"
#include "util/u_format.h"
#include "util/u_math.h"
#include "util/u_memory.h"
struct i915_tracked_hw_state {
const char *name;
void (*validate)(struct i915_context *, unsigned *batch_space);
void (*emit)(struct i915_context *);
unsigned dirty, batch_space;
};
static void
validate_flush(struct i915_context *i915, unsigned *batch_space)
{
*batch_space = i915->flush_dirty ? 1 : 0;
}
static void
emit_flush(struct i915_context *i915)
{
/* Cache handling is very cheap atm. State handling can request to flushes:
* - I915_FLUSH_CACHE which is a flush everything request and
* - I915_PIPELINE_FLUSH which is specifically for the draw_offset flush.
* Because the cache handling is so dumb, no explicit "invalidate map cache".
* Also, the first is a strict superset of the latter, so the following logic
* works. */
if (i915->flush_dirty & I915_FLUSH_CACHE)
OUT_BATCH(MI_FLUSH | FLUSH_MAP_CACHE);
else if (i915->flush_dirty & I915_PIPELINE_FLUSH)
OUT_BATCH(MI_FLUSH | INHIBIT_FLUSH_RENDER_CACHE);
}
uint32_t invariant_state[] = {
_3DSTATE_AA_CMD | AA_LINE_ECAAR_WIDTH_ENABLE | AA_LINE_ECAAR_WIDTH_1_0 |
AA_LINE_REGION_WIDTH_ENABLE | AA_LINE_REGION_WIDTH_1_0,
_3DSTATE_DFLT_DIFFUSE_CMD, 0,
_3DSTATE_DFLT_SPEC_CMD, 0,
_3DSTATE_DFLT_Z_CMD, 0,
_3DSTATE_COORD_SET_BINDINGS |
CSB_TCB(0, 0) |
CSB_TCB(1, 1) |
CSB_TCB(2, 2) |
CSB_TCB(3, 3) |
CSB_TCB(4, 4) |
CSB_TCB(5, 5) |
CSB_TCB(6, 6) |
CSB_TCB(7, 7),
_3DSTATE_RASTER_RULES_CMD |
ENABLE_POINT_RASTER_RULE |
OGL_POINT_RASTER_RULE |
ENABLE_LINE_STRIP_PROVOKE_VRTX |
ENABLE_TRI_FAN_PROVOKE_VRTX |
LINE_STRIP_PROVOKE_VRTX(1) |
TRI_FAN_PROVOKE_VRTX(2) |
ENABLE_TEXKILL_3D_4D |
TEXKILL_4D,
_3DSTATE_DEPTH_SUBRECT_DISABLE,
/* disable indirect state for now
*/
_3DSTATE_LOAD_INDIRECT | 0, 0};
static void
emit_invariant(struct i915_context *i915)
{
i915_winsys_batchbuffer_write(i915->batch, invariant_state,
Elements(invariant_state)*sizeof(uint32_t));
}
static void
validate_immediate(struct i915_context *i915, unsigned *batch_space)
{
unsigned dirty = (1 << I915_IMMEDIATE_S0 | 1 << I915_IMMEDIATE_S1 |
1 << I915_IMMEDIATE_S2 | 1 << I915_IMMEDIATE_S3 |
1 << I915_IMMEDIATE_S3 | 1 << I915_IMMEDIATE_S4 |
1 << I915_IMMEDIATE_S5 | 1 << I915_IMMEDIATE_S6) &
i915->immediate_dirty;
if (i915->immediate_dirty & (1 << I915_IMMEDIATE_S0) && i915->vbo)
i915->validation_buffers[i915->num_validation_buffers++] = i915->vbo;
*batch_space = 1 + util_bitcount(dirty);
}
static void
emit_immediate(struct i915_context *i915)
{
/* remove unwanted bits and S7 */
unsigned dirty = (1 << I915_IMMEDIATE_S0 | 1 << I915_IMMEDIATE_S1 |
1 << I915_IMMEDIATE_S2 | 1 << I915_IMMEDIATE_S3 |
1 << I915_IMMEDIATE_S3 | 1 << I915_IMMEDIATE_S4 |
1 << I915_IMMEDIATE_S5 | 1 << I915_IMMEDIATE_S6) &
i915->immediate_dirty;
int i, num = util_bitcount(dirty);
assert(num && num <= I915_MAX_IMMEDIATE);
OUT_BATCH(_3DSTATE_LOAD_STATE_IMMEDIATE_1 |
dirty << 4 | (num - 1));
if (i915->immediate_dirty & (1 << I915_IMMEDIATE_S0)) {
if (i915->vbo)
OUT_RELOC(i915->vbo, I915_USAGE_VERTEX,
i915->current.immediate[I915_IMMEDIATE_S0]);
else
OUT_BATCH(0);
}
for (i = 1; i < I915_MAX_IMMEDIATE; i++) {
if (dirty & (1 << i)) {
/* Fixup blend function for A8 dst buffers.
* When we blend to an A8 buffer, the GPU thinks it's a G8 buffer,
* and therefore we need to use the color factor for alphas. */
if ((i == I915_IMMEDIATE_S6) &&
(i915->current.target_fixup_format == PIPE_FORMAT_A8_UNORM)) {
uint32_t imm = i915->current.immediate[i];
uint32_t srcRGB = (imm >> S6_CBUF_SRC_BLEND_FACT_SHIFT) & BLENDFACT_MASK;
if (srcRGB == BLENDFACT_DST_ALPHA)
srcRGB = BLENDFACT_DST_COLR;
else if (srcRGB == BLENDFACT_INV_DST_ALPHA)
srcRGB = BLENDFACT_INV_DST_COLR;
imm &= ~SRC_BLND_FACT(BLENDFACT_MASK);
imm |= SRC_BLND_FACT(srcRGB);
OUT_BATCH(imm);
} else {
OUT_BATCH(i915->current.immediate[i]);
}
}
}
}
static void
validate_dynamic(struct i915_context *i915, unsigned *batch_space)
{
*batch_space = util_bitcount(i915->dynamic_dirty & ((1 << I915_MAX_DYNAMIC) - 1));
}
static void
emit_dynamic(struct i915_context *i915)
{
int i;
for (i = 0; i < I915_MAX_DYNAMIC; i++) {
if (i915->dynamic_dirty & (1 << i))
OUT_BATCH(i915->current.dynamic[i]);
}
}
static void
validate_static(struct i915_context *i915, unsigned *batch_space)
{
*batch_space = 0;
if (i915->current.cbuf_bo && (i915->static_dirty & I915_DST_BUF_COLOR)) {
i915->validation_buffers[i915->num_validation_buffers++]
= i915->current.cbuf_bo;
*batch_space += 3;
}
if (i915->current.depth_bo && (i915->static_dirty & I915_DST_BUF_DEPTH)) {
i915->validation_buffers[i915->num_validation_buffers++]
= i915->current.depth_bo;
*batch_space += 3;
}
if (i915->static_dirty & I915_DST_VARS)
*batch_space += 2;
if (i915->static_dirty & I915_DST_RECT)
*batch_space += 5;
}
static void
emit_static(struct i915_context *i915)
{
if (i915->current.cbuf_bo && (i915->static_dirty & I915_DST_BUF_COLOR)) {
OUT_BATCH(_3DSTATE_BUF_INFO_CMD);
OUT_BATCH(i915->current.cbuf_flags);
OUT_RELOC(i915->current.cbuf_bo,
I915_USAGE_RENDER,
0);
}
/* What happens if no zbuf??
*/
if (i915->current.depth_bo && (i915->static_dirty & I915_DST_BUF_DEPTH)) {
OUT_BATCH(_3DSTATE_BUF_INFO_CMD);
OUT_BATCH(i915->current.depth_flags);
OUT_RELOC(i915->current.depth_bo,
I915_USAGE_RENDER,
0);
}
if (i915->static_dirty & I915_DST_VARS) {
OUT_BATCH(_3DSTATE_DST_BUF_VARS_CMD);
OUT_BATCH(i915->current.dst_buf_vars);
}
}
static void
validate_map(struct i915_context *i915, unsigned *batch_space)
{
const uint enabled = i915->current.sampler_enable_flags;
uint unit;
struct i915_texture *tex;
*batch_space = i915->current.sampler_enable_nr ?
2 + 3*i915->current.sampler_enable_nr : 0;
for (unit = 0; unit < I915_TEX_UNITS; unit++) {
if (enabled & (1 << unit)) {
tex = i915_texture(i915->fragment_sampler_views[unit]->texture);
i915->validation_buffers[i915->num_validation_buffers++] = tex->buffer;
}
}
}
static void
emit_map(struct i915_context *i915)
{
const uint nr = i915->current.sampler_enable_nr;
if (nr) {
const uint enabled = i915->current.sampler_enable_flags;
uint unit;
uint count = 0;
OUT_BATCH(_3DSTATE_MAP_STATE | (3 * nr));
OUT_BATCH(enabled);
for (unit = 0; unit < I915_TEX_UNITS; unit++) {
if (enabled & (1 << unit)) {
struct i915_texture *texture = i915_texture(i915->fragment_sampler_views[unit]->texture);
struct i915_winsys_buffer *buf = texture->buffer;
assert(buf);
count++;
OUT_RELOC(buf, I915_USAGE_SAMPLER, 0);
OUT_BATCH(i915->current.texbuffer[unit][0]); /* MS3 */
OUT_BATCH(i915->current.texbuffer[unit][1]); /* MS4 */
}
}
assert(count == nr);
}
}
static void
validate_sampler(struct i915_context *i915, unsigned *batch_space)
{
*batch_space = i915->current.sampler_enable_nr ?
2 + 3*i915->current.sampler_enable_nr : 0;
}
static void
emit_sampler(struct i915_context *i915)
{
if (i915->current.sampler_enable_nr) {
int i;
OUT_BATCH( _3DSTATE_SAMPLER_STATE |
(3 * i915->current.sampler_enable_nr) );
OUT_BATCH( i915->current.sampler_enable_flags );
for (i = 0; i < I915_TEX_UNITS; i++) {
if (i915->current.sampler_enable_flags & (1<<i)) {
OUT_BATCH( i915->current.sampler[i][0] );
OUT_BATCH( i915->current.sampler[i][1] );
OUT_BATCH( i915->current.sampler[i][2] );
}
}
}
}
static boolean is_tex_instruction(uint32_t* instruction)
{
uint32_t op = instruction[0] &0xFF000000;
return ( (op == T0_TEXLD) ||
(op == T0_TEXLDP) ||
(op == T0_TEXLDB));
}
static uint32_t tex_sampler(uint32_t* instruction)
{
return ( instruction[0] & T0_SAMPLER_NR_MASK);
}
static uint additional_constants(struct i915_context *i915)
{
int i;
for (i = 0 ; i < i915->fs->program_len; i+=3) {
if ( is_tex_instruction(i915->fs->program + i)) {
int sampler = tex_sampler(i915->fs->program + i);
assert(sampler < I915_TEX_UNITS);
if ( i915->current.sampler_srgb[sampler] )
return 1;
}
}
return 0;
}
static void
validate_constants(struct i915_context *i915, unsigned *batch_space)
{
int nr = i915->fs->num_constants ?
2 + 4*i915->fs->num_constants : 0;
nr += 4*additional_constants(i915);
*batch_space = nr;
}
static void
emit_constants(struct i915_context *i915)
{
/* Collate the user-defined constants with the fragment shader's
* immediates according to the constant_flags[] array.
*/
const uint nr = i915->fs->num_constants + additional_constants(i915);
assert(nr < I915_MAX_CONSTANT);
if (nr) {
const float srgb_constants[4] = {1.0/1.055, 0.055/1.055, 2.4, 0.0822};
uint i;
OUT_BATCH( _3DSTATE_PIXEL_SHADER_CONSTANTS | (nr * 4) );
OUT_BATCH((1 << nr) - 1);
for (i = 0; i < nr; i++) {
const uint *c;
if (i915->fs->constant_flags[i] == I915_CONSTFLAG_USER) {
/* grab user-defined constant */
c = (uint *) i915_buffer(i915->constants[PIPE_SHADER_FRAGMENT])->data;
c += 4 * i;
}
else if (i < i915->fs->num_constants) {
/* emit program constant */
c = (uint *) i915->fs->constants[i];
} else {
/* emit constants for sRGB */
/* save const position in context for use in shader emit */
i915->current.srgb_const_offset = i;
c = (uint *) srgb_constants;
}
#if 0 /* debug */
{
float *f = (float *) c;
printf("Const %2d: %f %f %f %f %s\n", i, f[0], f[1], f[2], f[3],
(i915->fs->constant_flags[i] == I915_CONSTFLAG_USER
? "user" : "immediate"));
}
#endif
OUT_BATCH(*c++);
OUT_BATCH(*c++);
OUT_BATCH(*c++);
OUT_BATCH(*c++);
}
}
}
static void
validate_program(struct i915_context *i915, unsigned *batch_space)
{
uint additional_size = 0, i;
additional_size += i915->current.target_fixup_format ? 3 : 0;
for (i = 0 ; i < i915->fs->program_len; i+=3)
if ( is_tex_instruction(i915->fs->program + i) &&
i915->current.sampler_srgb[tex_sampler(i915->fs->program+i)] )
additional_size += 3 * 8 /* 8 instructions for srgb emulation */;
/* we need more batch space if we want to emulate rgba framebuffers
* or sRGB textures */
*batch_space = i915->fs->decl_len + i915->fs->program_len + additional_size;
}
static void emit_instruction(struct i915_context *i915,
int op,
int dst_mask,
int dst_reg,
int src0_reg,
int src1_reg,
int src2_reg)
{
OUT_BATCH(op |
dst_mask |
0 | /* saturate */
A0_DEST(dst_reg) |
A0_SRC0(src0_reg)
);
OUT_BATCH(A1_SRC0(src0_reg) | A1_SRC1(src1_reg));
OUT_BATCH(A2_SRC1(src1_reg) | A2_SRC2(src2_reg));
}
static void
emit_srgb_fixup(struct i915_context *i915,
uint *program)
{
int dst_reg =
(program[0] & UREG_TYPE_NR_MASK) >> UREG_A0_DEST_SHIFT_LEFT;
int dst_mask = program[0] & A0_DEST_CHANNEL_ALL;
int cst_idx = i915->current.srgb_const_offset;
int cst0_reg = swizzle(UREG(REG_TYPE_CONST, cst_idx), X, X, X, X);
int cst1_reg = swizzle(UREG(REG_TYPE_CONST, cst_idx), Y, Y, Y, Y);
int cst2_reg = swizzle(UREG(REG_TYPE_CONST, cst_idx), Z, Z, Z, Z);
int t1_reg = UREG(REG_TYPE_R, 1);
int t1x_reg = swizzle(UREG(REG_TYPE_R, 1), X, X, X, X);
int t1y_reg = swizzle(UREG(REG_TYPE_R, 1), Y, Y, Y, Y);
int t1z_reg = swizzle(UREG(REG_TYPE_R, 1), Z, Z, Z, Z);
emit_instruction(i915, A0_MAD, A0_DEST_CHANNEL_ALL, t1_reg, dst_reg, cst0_reg, cst1_reg);
emit_instruction(i915, A0_LOG, A0_DEST_CHANNEL_X, t1_reg, t1x_reg, 0, 0);
emit_instruction(i915, A0_LOG, A0_DEST_CHANNEL_Y, t1_reg, t1y_reg, 0, 0);
emit_instruction(i915, A0_LOG, A0_DEST_CHANNEL_Z, t1_reg, t1z_reg, 0, 0);
emit_instruction(i915, A0_MUL, A0_DEST_CHANNEL_ALL, t1_reg, t1_reg, cst2_reg, 0);
emit_instruction(i915, A0_EXP, dst_mask & A0_DEST_CHANNEL_X, dst_reg, t1x_reg, 0, 0);
emit_instruction(i915, A0_EXP, dst_mask & A0_DEST_CHANNEL_Y, dst_reg, t1y_reg, 0, 0);
emit_instruction(i915, A0_EXP, dst_mask & A0_DEST_CHANNEL_Z, dst_reg, t1z_reg, 0, 0);
}
static void
emit_program(struct i915_context *i915)
{
uint additional_size = 0;
uint i;
/* count how much additional space we'll need */
validate_program(i915, &additional_size);
additional_size -= i915->fs->decl_len + i915->fs->program_len;
/* we should always have, at least, a pass-through program */
assert(i915->fs->program_len > 0);
/* output the declarations */
{
/* first word has the size, we have to adjust that */
uint size = (i915->fs->decl[0]);
size += additional_size;
OUT_BATCH(size);
}
for (i = 1 ; i < i915->fs->decl_len; i++)
OUT_BATCH(i915->fs->decl[i]);
/* output the program */
assert(i915->fs->program_len % 3 == 0);
for (i = 0 ; i < i915->fs->program_len; i+=3) {
OUT_BATCH(i915->fs->program[i]);
OUT_BATCH(i915->fs->program[i+1]);
OUT_BATCH(i915->fs->program[i+2]);
/* TEX fixup for sRGB */
if ( is_tex_instruction(i915->fs->program+i) &&
i915->current.sampler_srgb[tex_sampler(i915->fs->program+i)] )
emit_srgb_fixup(i915, i915->fs->program);
}
/* we emit an additional mov with swizzle to fake RGBA framebuffers */
if (i915->current.target_fixup_format) {
/* mov out_color, out_color.zyxw */
OUT_BATCH(A0_MOV |
(REG_TYPE_OC << A0_DEST_TYPE_SHIFT) |
A0_DEST_CHANNEL_ALL |
(REG_TYPE_OC << A0_SRC0_TYPE_SHIFT) |
(T_DIFFUSE << A0_SRC0_NR_SHIFT));
OUT_BATCH(i915->current.fixup_swizzle);
OUT_BATCH(0);
}
}
static void
emit_draw_rect(struct i915_context *i915)
{
if (i915->static_dirty & I915_DST_RECT) {
OUT_BATCH(_3DSTATE_DRAW_RECT_CMD);
OUT_BATCH(DRAW_RECT_DIS_DEPTH_OFS);
OUT_BATCH(i915->current.draw_offset);
OUT_BATCH(i915->current.draw_size);
OUT_BATCH(i915->current.draw_offset);
}
}
static boolean
i915_validate_state(struct i915_context *i915, unsigned *batch_space)
{
unsigned tmp;
i915->num_validation_buffers = 0;
if (i915->hardware_dirty & I915_HW_INVARIANT)
*batch_space = Elements(invariant_state);
else
*batch_space = 0;
#if 0
static int counter_total = 0;
#define VALIDATE_ATOM(atom, hw_dirty) \
if (i915->hardware_dirty & hw_dirty) { \
static int counter_##atom = 0;\
validate_##atom(i915, &tmp); \
*batch_space += tmp;\
counter_##atom += tmp;\
counter_total += tmp;\
printf("%s: \t%d/%d \t%2.2f\n",#atom, counter_##atom, counter_total, counter_##atom*100.f/counter_total);}
#else
#define VALIDATE_ATOM(atom, hw_dirty) \
if (i915->hardware_dirty & hw_dirty) { \
validate_##atom(i915, &tmp); \
*batch_space += tmp; }
#endif
VALIDATE_ATOM(flush, I915_HW_FLUSH);
VALIDATE_ATOM(immediate, I915_HW_IMMEDIATE);
VALIDATE_ATOM(dynamic, I915_HW_DYNAMIC);
VALIDATE_ATOM(static, I915_HW_STATIC);
VALIDATE_ATOM(map, I915_HW_MAP);
VALIDATE_ATOM(sampler, I915_HW_SAMPLER);
VALIDATE_ATOM(constants, I915_HW_CONSTANTS);
VALIDATE_ATOM(program, I915_HW_PROGRAM);
#undef VALIDATE_ATOM
if (i915->num_validation_buffers == 0)
return TRUE;
if (!i915_winsys_validate_buffers(i915->batch, i915->validation_buffers,
i915->num_validation_buffers))
return FALSE;
return TRUE;
}
/* Push the state into the sarea and/or texture memory.
*/
void
i915_emit_hardware_state(struct i915_context *i915 )
{
unsigned batch_space;
uintptr_t save_ptr;
assert(i915->dirty == 0);
if (I915_DBG_ON(DBG_ATOMS))
i915_dump_hardware_dirty(i915, __FUNCTION__);
if (!i915_validate_state(i915, &batch_space)) {
FLUSH_BATCH(NULL);
assert(i915_validate_state(i915, &batch_space));
}
if(!BEGIN_BATCH(batch_space)) {
FLUSH_BATCH(NULL);
assert(i915_validate_state(i915, &batch_space));
assert(BEGIN_BATCH(batch_space));
}
save_ptr = (uintptr_t)i915->batch->ptr;
#define EMIT_ATOM(atom, hw_dirty) \
if (i915->hardware_dirty & hw_dirty) \
emit_##atom(i915);
EMIT_ATOM(flush, I915_HW_FLUSH);
EMIT_ATOM(invariant, I915_HW_INVARIANT);
EMIT_ATOM(immediate, I915_HW_IMMEDIATE);
EMIT_ATOM(dynamic, I915_HW_DYNAMIC);
EMIT_ATOM(static, I915_HW_STATIC);
EMIT_ATOM(map, I915_HW_MAP);
EMIT_ATOM(sampler, I915_HW_SAMPLER);
EMIT_ATOM(constants, I915_HW_CONSTANTS);
EMIT_ATOM(program, I915_HW_PROGRAM);
EMIT_ATOM(draw_rect, I915_HW_STATIC);
#undef EMIT_ATOM
I915_DBG(DBG_EMIT, "%s: used %d dwords, %d dwords reserved\n", __FUNCTION__,
((uintptr_t)i915->batch->ptr - save_ptr) / 4,
batch_space);
assert(((uintptr_t)i915->batch->ptr - save_ptr) / 4 == batch_space);
i915->hardware_dirty = 0;
i915->immediate_dirty = 0;
i915->dynamic_dirty = 0;
i915->static_dirty = 0;
i915->flush_dirty = 0;
}