#include "brw_context.h"
#include "brw_state.h"
-#include "intel_batchbuffer.h"
+#include "brw_batchbuffer.h"
+#include "brw_debug.h"
-/* This is used to initialize brw->state.atoms[]. We could use this
- * list directly except for a single atom, brw_constant_buffer, which
- * has a .dirty value which changes according to the parameters of the
- * current fragment and vertex programs, and so cannot be a static
- * value.
- */
const struct brw_tracked_state *atoms[] =
{
- &brw_check_fallback,
-
- &brw_wm_input_sizes,
+/* &brw_wm_input_sizes, */
&brw_vs_prog,
&brw_gs_prog,
&brw_clip_prog,
&brw_cc_unit,
&brw_vs_surfaces, /* must do before unit */
- &brw_wm_constant_surface, /* must do before wm surfaces/bind bo */
+ /*&brw_wm_constant_surface,*/ /* must do before wm surfaces/bind bo */
&brw_wm_surfaces, /* must do before samplers and unit */
&brw_wm_samplers,
&brw_blend_constant_color,
&brw_depthbuffer,
-
&brw_polygon_stipple,
- &brw_polygon_stipple_offset,
-
&brw_line_stipple,
- &brw_aa_line_parameters,
&brw_psp_urb_cbs,
&brw_index_buffer,
&brw_vertices,
- &brw_constant_buffer
+ &brw_curbe_buffer
};
/* Clear the last round of validated bos */
for (i = 0; i < brw->state.validated_bo_count; i++) {
- dri_bo_unreference(brw->state.validated_bos[i]);
- brw->state.validated_bos[i] = NULL;
+ bo_reference(&brw->state.validated_bos[i], NULL);
}
brw->state.validated_bo_count = 0;
}
-struct dirty_bit_map {
- uint32_t bit;
- char *name;
- uint32_t count;
-};
-
-#define DEFINE_BIT(name) {name, #name, 0}
-
-static struct dirty_bit_map mesa_bits[] = {
- DEFINE_BIT(_NEW_MODELVIEW),
- DEFINE_BIT(_NEW_PROJECTION),
- DEFINE_BIT(_NEW_TEXTURE_MATRIX),
- DEFINE_BIT(_NEW_COLOR_MATRIX),
- DEFINE_BIT(_NEW_ACCUM),
- DEFINE_BIT(_NEW_COLOR),
- DEFINE_BIT(_NEW_DEPTH),
- DEFINE_BIT(_NEW_EVAL),
- DEFINE_BIT(_NEW_FOG),
- DEFINE_BIT(_NEW_HINT),
- DEFINE_BIT(_NEW_LIGHT),
- DEFINE_BIT(_NEW_LINE),
- DEFINE_BIT(_NEW_PIXEL),
- DEFINE_BIT(_NEW_POINT),
- DEFINE_BIT(_NEW_POLYGON),
- DEFINE_BIT(_NEW_POLYGONSTIPPLE),
- DEFINE_BIT(_NEW_SCISSOR),
- DEFINE_BIT(_NEW_STENCIL),
- DEFINE_BIT(_NEW_TEXTURE),
- DEFINE_BIT(_NEW_TRANSFORM),
- DEFINE_BIT(_NEW_VIEWPORT),
- DEFINE_BIT(_NEW_PACKUNPACK),
- DEFINE_BIT(_NEW_ARRAY),
- DEFINE_BIT(_NEW_RENDERMODE),
- DEFINE_BIT(_NEW_BUFFERS),
- DEFINE_BIT(_NEW_MULTISAMPLE),
- DEFINE_BIT(_NEW_TRACK_MATRIX),
- DEFINE_BIT(_NEW_PROGRAM),
- DEFINE_BIT(_NEW_PROGRAM_CONSTANTS),
- {0, 0, 0}
-};
-
-static struct dirty_bit_map brw_bits[] = {
- DEFINE_BIT(BRW_NEW_URB_FENCE),
- DEFINE_BIT(BRW_NEW_FRAGMENT_PROGRAM),
- DEFINE_BIT(BRW_NEW_VERTEX_PROGRAM),
- DEFINE_BIT(BRW_NEW_INPUT_DIMENSIONS),
- DEFINE_BIT(BRW_NEW_CURBE_OFFSETS),
- DEFINE_BIT(BRW_NEW_REDUCED_PRIMITIVE),
- DEFINE_BIT(BRW_NEW_PRIMITIVE),
- DEFINE_BIT(BRW_NEW_CONTEXT),
- DEFINE_BIT(BRW_NEW_WM_INPUT_DIMENSIONS),
- DEFINE_BIT(BRW_NEW_PSP),
- DEFINE_BIT(BRW_NEW_FENCE),
- DEFINE_BIT(BRW_NEW_INDICES),
- DEFINE_BIT(BRW_NEW_INDEX_BUFFER),
- DEFINE_BIT(BRW_NEW_VERTICES),
- DEFINE_BIT(BRW_NEW_BATCH),
- DEFINE_BIT(BRW_NEW_DEPTH_BUFFER),
- {0, 0, 0}
-};
-
-static struct dirty_bit_map cache_bits[] = {
- DEFINE_BIT(CACHE_NEW_CC_VP),
- DEFINE_BIT(CACHE_NEW_CC_UNIT),
- DEFINE_BIT(CACHE_NEW_WM_PROG),
- DEFINE_BIT(CACHE_NEW_SAMPLER_DEFAULT_COLOR),
- DEFINE_BIT(CACHE_NEW_SAMPLER),
- DEFINE_BIT(CACHE_NEW_WM_UNIT),
- DEFINE_BIT(CACHE_NEW_SF_PROG),
- DEFINE_BIT(CACHE_NEW_SF_VP),
- DEFINE_BIT(CACHE_NEW_SF_UNIT),
- DEFINE_BIT(CACHE_NEW_VS_UNIT),
- DEFINE_BIT(CACHE_NEW_VS_PROG),
- DEFINE_BIT(CACHE_NEW_GS_UNIT),
- DEFINE_BIT(CACHE_NEW_GS_PROG),
- DEFINE_BIT(CACHE_NEW_CLIP_VP),
- DEFINE_BIT(CACHE_NEW_CLIP_UNIT),
- DEFINE_BIT(CACHE_NEW_CLIP_PROG),
- DEFINE_BIT(CACHE_NEW_SURFACE),
- DEFINE_BIT(CACHE_NEW_SURF_BIND),
- {0, 0, 0}
-};
-
-
-static void
-brw_update_dirty_count(struct dirty_bit_map *bit_map, int32_t bits)
-{
- int i;
-
- for (i = 0; i < 32; i++) {
- if (bit_map[i].bit == 0)
- return;
-
- if (bit_map[i].bit & bits)
- bit_map[i].count++;
- }
-}
-
-static void
-brw_print_dirty_count(struct dirty_bit_map *bit_map, int32_t bits)
-{
- int i;
-
- for (i = 0; i < 32; i++) {
- if (bit_map[i].bit == 0)
- return;
-
- fprintf(stderr, "0x%08x: %12d (%s)\n",
- bit_map[i].bit, bit_map[i].count, bit_map[i].name);
- }
-}
/***********************************************************************
* Emit all state:
*/
-void brw_validate_state( struct brw_context *brw )
+enum pipe_error brw_validate_state( struct brw_context *brw )
{
- GLcontext *ctx = &brw->intel.ctx;
- struct intel_context *intel = &brw->intel;
struct brw_state_flags *state = &brw->state.dirty;
GLuint i;
+ int ret;
brw_clear_validated_bos(brw);
+ brw_add_validated_bo(brw, brw->batch->buf);
- state->mesa |= brw->intel.NewGLState;
- brw->intel.NewGLState = 0;
-
- brw_add_validated_bo(brw, intel->batch->buf);
-
- if (brw->emit_state_always) {
+ if (brw->flags.always_emit_state) {
state->mesa |= ~0;
state->brw |= ~0;
state->cache |= ~0;
}
- if (brw->fragment_program != ctx->FragmentProgram._Current) {
- brw->fragment_program = ctx->FragmentProgram._Current;
- brw->state.dirty.brw |= BRW_NEW_FRAGMENT_PROGRAM;
- }
-
- if (brw->vertex_program != ctx->VertexProgram._Current) {
- brw->vertex_program = ctx->VertexProgram._Current;
- brw->state.dirty.brw |= BRW_NEW_VERTEX_PROGRAM;
- }
-
if (state->mesa == 0 &&
state->cache == 0 &&
state->brw == 0)
- return;
+ return 0;
if (brw->state.dirty.brw & BRW_NEW_CONTEXT)
brw_clear_batch_cache(brw);
- brw->intel.Fallback = 0;
-
/* do prepare stage for all atoms */
for (i = 0; i < Elements(atoms); i++) {
const struct brw_tracked_state *atom = atoms[i];
- if (brw->intel.Fallback)
- break;
-
if (check_state(state, &atom->dirty)) {
if (atom->prepare) {
- atom->prepare(brw);
+ ret = atom->prepare(brw);
+ if (ret)
+ return ret;
}
}
}
* If this fails, we can experience GPU lock-ups.
*/
{
- const struct brw_fragment_program *fp;
- fp = brw_fragment_program_const(brw->fragment_program);
+ const struct brw_fragment_shader *fp = brw->curr.fragment_shader;
if (fp) {
- assert((fp->tex_units_used & ctx->Texture._EnabledUnits)
- == fp->tex_units_used);
+ assert(fp->info.file_max[TGSI_FILE_SAMPLER] < (int)brw->curr.num_samplers);
+ /*assert(fp->info.texture_max <= brw->curr.num_textures);*/
}
}
+
+ return 0;
}
-void brw_upload_state(struct brw_context *brw)
+enum pipe_error brw_upload_state(struct brw_context *brw)
{
struct brw_state_flags *state = &brw->state.dirty;
+ int ret;
int i;
- static int dirty_count = 0;
brw_clear_validated_bos(brw);
- if (INTEL_DEBUG) {
+ if (BRW_DEBUG) {
/* Debug version which enforces various sanity checks on the
* state flags which are generated and checked to help ensure
* state atoms are ordered correctly in the list.
*/
struct brw_state_flags examined, prev;
- _mesa_memset(&examined, 0, sizeof(examined));
+ memset(&examined, 0, sizeof(examined));
prev = *state;
- for (i = 0; i < Elements(atoms); i++) {
+ for (i = 0; i < Elements(atoms); i++) {
const struct brw_tracked_state *atom = atoms[i];
struct brw_state_flags generated;
atom->dirty.brw ||
atom->dirty.cache);
- if (brw->intel.Fallback)
- break;
-
if (check_state(state, &atom->dirty)) {
if (atom->emit) {
- atom->emit( brw );
+ ret = atom->emit( brw );
+ if (ret)
+ return ret;
}
}
for (i = 0; i < Elements(atoms); i++) {
const struct brw_tracked_state *atom = atoms[i];
- if (brw->intel.Fallback)
- break;
-
if (check_state(state, &atom->dirty)) {
if (atom->emit) {
- atom->emit( brw );
+ ret = atom->emit( brw );
+ if (ret)
+ return ret;
}
}
}
}
- if (INTEL_DEBUG & DEBUG_STATE) {
- brw_update_dirty_count(mesa_bits, state->mesa);
- brw_update_dirty_count(brw_bits, state->brw);
- brw_update_dirty_count(cache_bits, state->cache);
- if (dirty_count++ % 1000 == 0) {
- brw_print_dirty_count(mesa_bits, state->mesa);
- brw_print_dirty_count(brw_bits, state->brw);
- brw_print_dirty_count(cache_bits, state->cache);
- fprintf(stderr, "\n");
- }
+ if (BRW_DEBUG & DEBUG_STATE) {
+ brw_update_dirty_counts( state->mesa,
+ state->brw,
+ state->cache );
}
-
- if (!brw->intel.Fallback)
- memset(state, 0, sizeof(*state));
+
+ /* Clear dirty flags:
+ */
+ memset(state, 0, sizeof(*state));
+ return 0;
}