gallium: remove flags from the flush function

The drivers have been changed so that they behave as if all of the flags
were set. This is already implicit in most hardware drivers and required
for multiple contexts.

Some state trackers were also abusing the PIPE_FLUSH_RENDER_CACHE flag
to decide whether flush_frontbuffer should be called.
New flag ST_FLUSH_FRONT has been added to st_api.h as a replacement.

32 files changed, 111 insertions, 138 deletions

diff --git a/src/gallium/drivers/cell/ppu/cell_flush.c b/src/gallium/drivers/cell/ppu/cell_flush.c
index 8275c9dc9c..463f4d03eb 100644
--- a/src/gallium/drivers/cell/ppu/cell_flush.c
+++ b/src/gallium/drivers/cell/ppu/cell_flush.c
@@ -38,19 +38,16 @@
  * Called via pipe->flush()
  */
 void
-cell_flush(struct pipe_context *pipe, unsigned flags,
+cell_flush(struct pipe_context *pipe,
            struct pipe_fence_handle **fence)
 {
    struct cell_context *cell = cell_context(pipe);
 
    if (fence) {
       *fence = NULL;
-      /* XXX: Implement real fencing */
-      flags |= CELL_FLUSH_WAIT;
    }
 
-   if (flags & (PIPE_FLUSH_SWAPBUFFERS | PIPE_FLUSH_RENDER_CACHE))
-      flags |= CELL_FLUSH_WAIT;
+   flags |= CELL_FLUSH_WAIT;
 
    draw_flush( cell->draw );
    cell_flush_int(cell, flags);
diff --git a/src/gallium/drivers/failover/fo_context.c b/src/gallium/drivers/failover/fo_context.c
index b536dc4afa..0fefec9aae 100644
--- a/src/gallium/drivers/failover/fo_context.c
+++ b/src/gallium/drivers/failover/fo_context.c
@@ -79,7 +79,7 @@ static void failover_draw_vbo( struct pipe_context *pipe,
    if (failover->mode == FO_SW) {
 
       if (failover->dirty) {
-         failover->hw->flush( failover->hw, ~0, NULL );
+         failover->hw->flush( failover->hw, NULL );
 	 failover_state_emit( failover );
       }
 
@@ -89,7 +89,7 @@ static void failover_draw_vbo( struct pipe_context *pipe,
        * intervening flush.  Unlikely to be much performance impact to
        * this:
        */
-      failover->sw->flush( failover->sw, ~0, NULL );
+      failover->sw->flush( failover->sw, NULL );
    }
 }
 
diff --git a/src/gallium/drivers/galahad/glhd_context.c b/src/gallium/drivers/galahad/glhd_context.c
index 1dc652c6bd..813a21e2ee 100644
--- a/src/gallium/drivers/galahad/glhd_context.c
+++ b/src/gallium/drivers/galahad/glhd_context.c
@@ -761,14 +761,12 @@ galahad_clear_depth_stencil(struct pipe_context *_pipe,
 
 static void
 galahad_flush(struct pipe_context *_pipe,
-               unsigned flags,
                struct pipe_fence_handle **fence)
 {
    struct galahad_context *glhd_pipe = galahad_context(_pipe);
    struct pipe_context *pipe = glhd_pipe->pipe;
 
    pipe->flush(pipe,
-               flags,
                fence);
 }
 
diff --git a/src/gallium/drivers/i915/i915_flush.c b/src/gallium/drivers/i915/i915_flush.c
index f2044d661e..87966d9807 100644
--- a/src/gallium/drivers/i915/i915_flush.c
+++ b/src/gallium/drivers/i915/i915_flush.c
@@ -39,7 +39,6 @@
 
 
 static void i915_flush_pipe( struct pipe_context *pipe,
-                             unsigned flags,
                              struct pipe_fence_handle **fence )
 {
    struct i915_context *i915 = i915_context(pipe);
@@ -50,6 +49,7 @@ static void i915_flush_pipe( struct pipe_context *pipe,
    /* Do we need to emit an MI_FLUSH command to flush the hardware
     * caches?
     */
+   /* XXX These flags are now implicit. All of them. */
    if (flags & (PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_TEXTURE_CACHE)) {
       unsigned flush = MI_FLUSH;
       
diff --git a/src/gallium/drivers/i965/brw_pipe_flush.c b/src/gallium/drivers/i965/brw_pipe_flush.c
index 0ae1a6be9e..3b4a99beed 100644
--- a/src/gallium/drivers/i965/brw_pipe_flush.c
+++ b/src/gallium/drivers/i965/brw_pipe_flush.c
@@ -38,7 +38,6 @@ void brw_context_flush( struct brw_context *brw )
 
 static void
 brw_flush( struct pipe_context *pipe,
-           unsigned flags, 
            struct pipe_fence_handle **fence )
 {
    brw_context_flush( brw_context( pipe ) );
diff --git a/src/gallium/drivers/identity/id_context.c b/src/gallium/drivers/identity/id_context.c
index 5c865f8a22..2a9d736015 100644
--- a/src/gallium/drivers/identity/id_context.c
+++ b/src/gallium/drivers/identity/id_context.c
@@ -668,14 +668,12 @@ identity_clear_depth_stencil(struct pipe_context *_pipe,
 
 static void
 identity_flush(struct pipe_context *_pipe,
-               unsigned flags,
                struct pipe_fence_handle **fence)
 {
    struct identity_context *id_pipe = identity_context(_pipe);
    struct pipe_context *pipe = id_pipe->pipe;
 
    pipe->flush(pipe,
-               flags,
                fence);
 }
 
diff --git a/src/gallium/drivers/llvmpipe/lp_context.c b/src/gallium/drivers/llvmpipe/lp_context.c
index 644201ddf7..8a5655d499 100644
--- a/src/gallium/drivers/llvmpipe/lp_context.c
+++ b/src/gallium/drivers/llvmpipe/lp_context.c
@@ -136,10 +136,9 @@ static void llvmpipe_destroy( struct pipe_context *pipe )
 
 static void
 do_flush( struct pipe_context *pipe,
-          unsigned flags,
           struct pipe_fence_handle **fence)
 {
-   llvmpipe_flush(pipe, flags, fence, __FUNCTION__);
+   llvmpipe_flush(pipe, fence, __FUNCTION__);
 }
 
 
diff --git a/src/gallium/drivers/llvmpipe/lp_flush.c b/src/gallium/drivers/llvmpipe/lp_flush.c
index 2a3ba904fe..42430550ea 100644
--- a/src/gallium/drivers/llvmpipe/lp_flush.c
+++ b/src/gallium/drivers/llvmpipe/lp_flush.c
@@ -40,12 +40,10 @@
 
 
 /**
- * \param flags  bitmask of PIPE_FLUSH_x flags
  * \param fence  if non-null, returns pointer to a fence which can be waited on
  */
 void
 llvmpipe_flush( struct pipe_context *pipe,
-                unsigned flags,
                 struct pipe_fence_handle **fence,
                 const char *reason)
 {
@@ -54,7 +52,7 @@ llvmpipe_flush( struct pipe_context *pipe,
    draw_flush(llvmpipe->draw);
 
    /* ask the setup module to flush */
-   lp_setup_flush(llvmpipe->setup, flags, fence, reason);
+   lp_setup_flush(llvmpipe->setup, fence, reason);
 
 
    if (llvmpipe_variant_count > 1000) {
@@ -65,23 +63,21 @@ llvmpipe_flush( struct pipe_context *pipe,
 
    /* Enable to dump BMPs of the color/depth buffers each frame */
    if (0) {
-      if (flags & PIPE_FLUSH_FRAME) {
-         static unsigned frame_no = 1;
-         char filename[256];
-         unsigned i;
-
-         for (i = 0; i < llvmpipe->framebuffer.nr_cbufs; i++) {
-            util_snprintf(filename, sizeof(filename), "cbuf%u_%u", i, frame_no);
-            debug_dump_surface_bmp(&llvmpipe->pipe, filename, llvmpipe->framebuffer.cbufs[i]);
-         }
-
-         if (0) {
-            util_snprintf(filename, sizeof(filename), "zsbuf_%u", frame_no);
-            debug_dump_surface_bmp(&llvmpipe->pipe, filename, llvmpipe->framebuffer.zsbuf);
-         }
-
-         ++frame_no;
+      static unsigned frame_no = 1;
+      char filename[256];
+      unsigned i;
+
+      for (i = 0; i < llvmpipe->framebuffer.nr_cbufs; i++) {
+         util_snprintf(filename, sizeof(filename), "cbuf%u_%u", i, frame_no);
+         debug_dump_surface_bmp(&llvmpipe->pipe, filename, llvmpipe->framebuffer.cbufs[i]);
+      }
+
+      if (0) {
+         util_snprintf(filename, sizeof(filename), "zsbuf_%u", frame_no);
+         debug_dump_surface_bmp(&llvmpipe->pipe, filename, llvmpipe->framebuffer.zsbuf);
       }
+
+      ++frame_no;
    }
 }
 
@@ -90,7 +86,7 @@ llvmpipe_finish( struct pipe_context *pipe,
                  const char *reason )
 {
    struct pipe_fence_handle *fence = NULL;
-   llvmpipe_flush(pipe, 0, &fence, reason);
+   llvmpipe_flush(pipe, &fence, reason);
    if (fence) {
       pipe->screen->fence_finish(pipe->screen, fence, PIPE_TIMEOUT_INFINITE);
       pipe->screen->fence_reference(pipe->screen, &fence, NULL);
@@ -110,7 +106,6 @@ llvmpipe_flush_resource(struct pipe_context *pipe,
                         struct pipe_resource *resource,
                         unsigned level,
                         int layer,
-                        unsigned flush_flags,
                         boolean read_only,
                         boolean cpu_access,
                         boolean do_not_block,
@@ -136,7 +131,7 @@ llvmpipe_flush_resource(struct pipe_context *pipe,
           * Just flush.
           */
 
-         llvmpipe_flush(pipe, flush_flags, NULL, reason);
+         llvmpipe_flush(pipe, NULL, reason);
       }
    }
 
diff --git a/src/gallium/drivers/llvmpipe/lp_flush.h b/src/gallium/drivers/llvmpipe/lp_flush.h
index 579d24c68a..efff94c8c0 100644
--- a/src/gallium/drivers/llvmpipe/lp_flush.h
+++ b/src/gallium/drivers/llvmpipe/lp_flush.h
@@ -36,7 +36,6 @@ struct pipe_resource;
 
 void
 llvmpipe_flush(struct pipe_context *pipe,
-               unsigned flags,
                struct pipe_fence_handle **fence,
                const char *reason);
 
@@ -49,7 +48,6 @@ llvmpipe_flush_resource(struct pipe_context *pipe,
                         struct pipe_resource *resource,
                         unsigned level,
                         int layer,
-                        unsigned flush_flags,
                         boolean read_only,
                         boolean cpu_access,
                         boolean do_not_block,
diff --git a/src/gallium/drivers/llvmpipe/lp_query.c b/src/gallium/drivers/llvmpipe/lp_query.c
index 84c66dd36e..1e2401fa84 100644
--- a/src/gallium/drivers/llvmpipe/lp_query.c
+++ b/src/gallium/drivers/llvmpipe/lp_query.c
@@ -69,7 +69,7 @@ llvmpipe_destroy_query(struct pipe_context *pipe, struct pipe_query *q)
     */
    if (pq->fence) {
       if (!lp_fence_issued(pq->fence))
-         llvmpipe_flush(pipe, 0, NULL, __FUNCTION__);
+         llvmpipe_flush(pipe, NULL, __FUNCTION__);
 
       if (!lp_fence_signalled(pq->fence))
          lp_fence_wait(pq->fence);
@@ -99,7 +99,7 @@ llvmpipe_get_query_result(struct pipe_context *pipe,
 
    if (!lp_fence_signalled(pq->fence)) {
       if (!lp_fence_issued(pq->fence))
-         llvmpipe_flush(pipe, 0, NULL, __FUNCTION__);
+         llvmpipe_flush(pipe, NULL, __FUNCTION__);
          
       if (!wait)
          return FALSE;
diff --git a/src/gallium/drivers/llvmpipe/lp_setup.c b/src/gallium/drivers/llvmpipe/lp_setup.c
index 41d8fa6d12..3813e0ed97 100644
--- a/src/gallium/drivers/llvmpipe/lp_setup.c
+++ b/src/gallium/drivers/llvmpipe/lp_setup.c
@@ -333,12 +333,8 @@ fail:
 }
 
 
-/**
- * \param flags  bitmask of PIPE_FLUSH_x flags
- */
 void
 lp_setup_flush( struct lp_setup_context *setup,
-                unsigned flags,
                 struct pipe_fence_handle **fence,
                 const char *reason)
 {
@@ -469,7 +465,7 @@ lp_setup_clear( struct lp_setup_context *setup,
                 unsigned flags )
 {
    if (!lp_setup_try_clear( setup, color, depth, stencil, flags )) {
-      lp_setup_flush(setup, 0, NULL, __FUNCTION__);
+      lp_setup_flush(setup, NULL, __FUNCTION__);
 
       if (!lp_setup_try_clear( setup, color, depth, stencil, flags ))
          assert(0);
@@ -1114,7 +1110,7 @@ lp_setup_end_query(struct lp_setup_context *setup, struct llvmpipe_query *pq)
       if (!lp_scene_bin_everywhere(setup->scene,
                                    LP_RAST_OP_END_QUERY,
                                    dummy)) {
-         lp_setup_flush(setup, 0, NULL, __FUNCTION__);
+         lp_setup_flush(setup, NULL, __FUNCTION__);
       }
    }
    else {
diff --git a/src/gallium/drivers/llvmpipe/lp_setup.h b/src/gallium/drivers/llvmpipe/lp_setup.h
index 0d6e161a21..8655259d27 100644
--- a/src/gallium/drivers/llvmpipe/lp_setup.h
+++ b/src/gallium/drivers/llvmpipe/lp_setup.h
@@ -64,7 +64,6 @@ lp_setup_clear(struct lp_setup_context *setup,
 
 void
 lp_setup_flush( struct lp_setup_context *setup,
-                unsigned flags,
                 struct pipe_fence_handle **fence,
                 const char *reason);
 
diff --git a/src/gallium/drivers/llvmpipe/lp_surface.c b/src/gallium/drivers/llvmpipe/lp_surface.c
index e7e46a628a..f49638acf0 100644
--- a/src/gallium/drivers/llvmpipe/lp_surface.c
+++ b/src/gallium/drivers/llvmpipe/lp_surface.c
@@ -69,7 +69,6 @@ lp_resource_copy(struct pipe_context *pipe,
 
    llvmpipe_flush_resource(pipe,
                            dst, dst_level, dstz,
-                           0, /* flush_flags */
                            FALSE, /* read_only */
                            TRUE, /* cpu_access */
                            FALSE, /* do_not_block */
@@ -77,7 +76,6 @@ lp_resource_copy(struct pipe_context *pipe,
 
    llvmpipe_flush_resource(pipe,
                            src, src_level, src_box->z,
-                           0, /* flush_flags */
                            TRUE, /* read_only */
                            TRUE, /* cpu_access */
                            FALSE, /* do_not_block */
diff --git a/src/gallium/drivers/llvmpipe/lp_texture.c b/src/gallium/drivers/llvmpipe/lp_texture.c
index 2e6a4bd7dc..fa4ce5bf2a 100644
--- a/src/gallium/drivers/llvmpipe/lp_texture.c
+++ b/src/gallium/drivers/llvmpipe/lp_texture.c
@@ -575,7 +575,6 @@ llvmpipe_get_transfer(struct pipe_context *pipe,
       if (!llvmpipe_flush_resource(pipe, resource,
                                    level,
                                    box->depth > 1 ? -1 : box->z,
-                                   0, /* flush_flags */
                                    read_only,
                                    TRUE, /* cpu_access */
                                    do_not_block,
diff --git a/src/gallium/drivers/noop/noop_pipe.c b/src/gallium/drivers/noop/noop_pipe.c
index 9bcc1e6b45..496b7f5ec6 100644
--- a/src/gallium/drivers/noop/noop_pipe.c
+++ b/src/gallium/drivers/noop/noop_pipe.c
@@ -260,7 +260,7 @@ static void noop_resource_copy_region(struct pipe_context *ctx,
 /*
  * context
  */
-static void noop_flush(struct pipe_context *ctx, unsigned flags,
+static void noop_flush(struct pipe_context *ctx,
 			struct pipe_fence_handle **fence)
 {
 }
diff --git a/src/gallium/drivers/nv50/nv50_context.c b/src/gallium/drivers/nv50/nv50_context.c
index 912367b839..c6bd0b15cb 100644
--- a/src/gallium/drivers/nv50/nv50_context.c
+++ b/src/gallium/drivers/nv50/nv50_context.c
@@ -30,25 +30,25 @@
 #include "nouveau/nouveau_reloc.h"
 
 static void
-nv50_flush(struct pipe_context *pipe, unsigned flags,
+nv50_flush(struct pipe_context *pipe,
            struct pipe_fence_handle **fence)
 {
    struct nv50_context *nv50 = nv50_context(pipe);
    struct nouveau_channel *chan = nv50->screen->base.channel;
 
-   if (flags & PIPE_FLUSH_TEXTURE_CACHE) {
+   /* XXX This flag wasn't set by the state tracker anyway. */
+   /*if (flags & PIPE_FLUSH_TEXTURE_CACHE) {
       BEGIN_RING(chan, RING_3D_(NV50_GRAPH_WAIT_FOR_IDLE), 1);
       OUT_RING  (chan, 0);
       BEGIN_RING(chan, RING_3D(TEX_CACHE_CTL), 1);
       OUT_RING  (chan, 0x20);
-   }
+   }*/
 
    if (fence)
       nouveau_fence_ref(nv50->screen->base.fence.current,
                         (struct nouveau_fence **)fence);
 
-   if (flags & (PIPE_FLUSH_SWAPBUFFERS | PIPE_FLUSH_FRAME))
-      FIRE_RING(chan);
+   FIRE_RING(chan);
 }
 
 void
diff --git a/src/gallium/drivers/nvc0/nvc0_context.c b/src/gallium/drivers/nvc0/nvc0_context.c
index d6de979b13..881d102dab 100644
--- a/src/gallium/drivers/nvc0/nvc0_context.c
+++ b/src/gallium/drivers/nvc0/nvc0_context.c
@@ -30,29 +30,30 @@
 #include "nouveau/nouveau_reloc.h"
 
 static void
-nvc0_flush(struct pipe_context *pipe, unsigned flags,
+nvc0_flush(struct pipe_context *pipe,
            struct pipe_fence_handle **fence)
 {
    struct nvc0_context *nvc0 = nvc0_context(pipe);
    struct nouveau_channel *chan = nvc0->screen->base.channel;
 
-   if (flags & PIPE_FLUSH_TEXTURE_CACHE) {
+   /* XXX This flag wasn't set by the state tracker anyway. */
+   /*if (flags & PIPE_FLUSH_TEXTURE_CACHE) {
       BEGIN_RING(chan, RING_3D(SERIALIZE), 1);
       OUT_RING  (chan, 0);
       BEGIN_RING(chan, RING_3D(TEX_CACHE_CTL), 1);
       OUT_RING  (chan, 0x00);
-   } else
-   if ((flags & PIPE_FLUSH_RENDER_CACHE) && !(flags & PIPE_FLUSH_FRAME)) {
+   } else*/
+   /* XXX FLUSH_FRAME is now implicit. */
+   /*if ((flags & PIPE_FLUSH_RENDER_CACHE) && !(flags & PIPE_FLUSH_FRAME)) {
       BEGIN_RING(chan, RING_3D(SERIALIZE), 1);
       OUT_RING  (chan, 0);
-   }
+   }*/
 
    if (fence)
       nouveau_fence_ref(nvc0->screen->base.fence.current,
                         (struct nouveau_fence **)fence);
 
-   if (flags & (PIPE_FLUSH_SWAPBUFFERS | PIPE_FLUSH_FRAME))
-      FIRE_RING(chan);
+   FIRE_RING(chan);
 }
 
 static void
diff --git a/src/gallium/drivers/nvfx/nvfx_context.c b/src/gallium/drivers/nvfx/nvfx_context.c
index 6c8934d3a4..2bcb93d93e 100644
--- a/src/gallium/drivers/nvfx/nvfx_context.c
+++ b/src/gallium/drivers/nvfx/nvfx_context.c
@@ -7,7 +7,7 @@
 #include "nvfx_resource.h"
 
 static void
-nvfx_flush(struct pipe_context *pipe, unsigned flags,
+nvfx_flush(struct pipe_context *pipe,
 	   struct pipe_fence_handle **fence)
 {
 	struct nvfx_context *nvfx = nvfx_context(pipe);
@@ -16,12 +16,13 @@ nvfx_flush(struct pipe_context *pipe, unsigned flags,
 	struct nouveau_grobj *eng3d = screen->eng3d;
 
 	/* XXX: we need to actually be intelligent here */
-	if (flags & PIPE_FLUSH_TEXTURE_CACHE) {
+        /* XXX This flag wasn't set by the state tracker anyway. */
+        /*if (flags & PIPE_FLUSH_TEXTURE_CACHE) {
 		BEGIN_RING(chan, eng3d, 0x1fd8, 1);
 		OUT_RING(chan, 2);
 		BEGIN_RING(chan, eng3d, 0x1fd8, 1);
 		OUT_RING(chan, 1);
-	}
+        }*/
 
 	FIRE_RING(chan);
 	if (fence)
diff --git a/src/gallium/drivers/nvfx/nvfx_state_emit.c b/src/gallium/drivers/nvfx/nvfx_state_emit.c
index 40ae4f5bd2..ae9c31418c 100644
--- a/src/gallium/drivers/nvfx/nvfx_state_emit.c
+++ b/src/gallium/drivers/nvfx/nvfx_state_emit.c
@@ -426,7 +426,7 @@ nvfx_state_validate_swtnl(struct nvfx_context *nvfx)
 			NOUVEAU_ERR("hw->swtnl 0x%08x\n", nvfx->fallback_swtnl);
 			warned = TRUE;
 		}
-		nvfx->pipe.flush(&nvfx->pipe, 0, NULL);
+                nvfx->pipe.flush(&nvfx->pipe, NULL);
 		nvfx->dirty |= (NVFX_NEW_VIEWPORT |
 				NVFX_NEW_VERTPROG |
 				NVFX_NEW_ARRAYS);
diff --git a/src/gallium/drivers/r300/r300_flush.c b/src/gallium/drivers/r300/r300_flush.c
index fa0926868b..b3d0d344ec 100644
--- a/src/gallium/drivers/r300/r300_flush.c
+++ b/src/gallium/drivers/r300/r300_flush.c
@@ -94,10 +94,8 @@ void r300_flush(struct pipe_context *pipe,
 }
 
 static void r300_flush_wrapped(struct pipe_context *pipe,
-                               unsigned flags,
                                struct pipe_fence_handle **fence)
 {
-    /* don't use the flags param, it means something else */
     r300_flush(pipe, 0, fence);
 }
 
diff --git a/src/gallium/drivers/r300/r300_transfer.c b/src/gallium/drivers/r300/r300_transfer.c
index 928c86be0c..65c5095be6 100644
--- a/src/gallium/drivers/r300/r300_transfer.c
+++ b/src/gallium/drivers/r300/r300_transfer.c
@@ -73,7 +73,7 @@ static void r300_copy_into_tiled_texture(struct pipe_context *ctx,
                               &r300transfer->linear_texture->b.b.b, 0, &src_box);
 
     /* XXX remove this. */
-    ctx->flush(ctx, 0, NULL);
+    r300_flush(ctx, 0, NULL);
 }
 
 struct pipe_transfer*
diff --git a/src/gallium/drivers/r600/r600_pipe.c b/src/gallium/drivers/r600/r600_pipe.c
index d8e057fe5d..8303b7224a 100644
--- a/src/gallium/drivers/r600/r600_pipe.c
+++ b/src/gallium/drivers/r600/r600_pipe.c
@@ -48,7 +48,7 @@
 /*
  * pipe_context
  */
-static void r600_flush(struct pipe_context *ctx, unsigned flags,
+static void r600_flush(struct pipe_context *ctx,
 			struct pipe_fence_handle **fence)
 {
 	struct r600_pipe_context *rctx = (struct r600_pipe_context *)ctx;
diff --git a/src/gallium/drivers/r600/r600_query.c b/src/gallium/drivers/r600/r600_query.c
index 343403f92f..181ea3f9e4 100644
--- a/src/gallium/drivers/r600/r600_query.c
+++ b/src/gallium/drivers/r600/r600_query.c
@@ -62,7 +62,7 @@ static boolean r600_get_query_result(struct pipe_context *ctx,
 	struct r600_query *rquery = (struct r600_query *)query;
 
 	if (rquery->num_results) {
-		ctx->flush(ctx, 0, NULL);
+                ctx->flush(ctx, NULL);
 	}
 	return r600_context_query_result(&rctx->ctx, (struct r600_query *)query, wait, vresult);
 }
diff --git a/src/gallium/drivers/r600/r600_texture.c b/src/gallium/drivers/r600/r600_texture.c
index f527c07adc..86a9defa9a 100644
--- a/src/gallium/drivers/r600/r600_texture.c
+++ b/src/gallium/drivers/r600/r600_texture.c
@@ -68,7 +68,7 @@ static void r600_copy_from_staging_texture(struct pipe_context *ctx, struct r600
 				  rtransfer->staging_texture,
 				  0, &sbox);
 
-	ctx->flush(ctx, 0, NULL);
+        ctx->flush(ctx, NULL);
 }
 
 unsigned r600_texture_get_offset(struct r600_resource_texture *rtex,
@@ -635,7 +635,7 @@ struct pipe_transfer* r600_texture_get_transfer(struct pipe_context *ctx,
 		if (usage & PIPE_TRANSFER_READ) {
 			r600_copy_to_staging_texture(ctx, trans);
 			/* Always referenced in the blit. */
-			ctx->flush(ctx, 0, NULL);
+                        ctx->flush(ctx, NULL);
 		}
 		return &trans->transfer;
 	}
diff --git a/src/gallium/drivers/rbug/rbug_context.c b/src/gallium/drivers/rbug/rbug_context.c
index f5e2d5f4d6..bd0eae9ac4 100644
--- a/src/gallium/drivers/rbug/rbug_context.c
+++ b/src/gallium/drivers/rbug/rbug_context.c
@@ -801,14 +801,12 @@ rbug_clear_depth_stencil(struct pipe_context *_pipe,
 
 static void
 rbug_flush(struct pipe_context *_pipe,
-           unsigned flags,
            struct pipe_fence_handle **fence)
 {
    struct rbug_context *rb_pipe = rbug_context(_pipe);
    struct pipe_context *pipe = rb_pipe->pipe;
 
    pipe->flush(pipe,
-               flags,
                fence);
 }
 
diff --git a/src/gallium/drivers/rbug/rbug_core.c b/src/gallium/drivers/rbug/rbug_core.c
index eb772d19d0..b80bcd4228 100644
--- a/src/gallium/drivers/rbug/rbug_core.c
+++ b/src/gallium/drivers/rbug/rbug_core.c
@@ -498,7 +498,7 @@ rbug_context_flush(struct rbug_rbug *tr_rbug, struct rbug_header *header, uint32
    /* protect the pipe context */
    pipe_mutex_lock(rb_context->call_mutex);
 
-   rb_context->pipe->flush(rb_context->pipe, flush->flags, NULL);
+   rb_context->pipe->flush(rb_context->pipe, NULL);
 
    pipe_mutex_unlock(rb_context->call_mutex);
    pipe_mutex_unlock(rb_screen->list_mutex);
diff --git a/src/gallium/drivers/softpipe/sp_context.c b/src/gallium/drivers/softpipe/sp_context.c
index 5ea2ee5821..ce22f64622 100644
--- a/src/gallium/drivers/softpipe/sp_context.c
+++ b/src/gallium/drivers/softpipe/sp_context.c
@@ -255,7 +255,7 @@ softpipe_create_context( struct pipe_screen *screen,
    softpipe->pipe.draw_stream_output = softpipe_draw_stream_output;
 
    softpipe->pipe.clear = softpipe_clear;
-   softpipe->pipe.flush = softpipe_flush;
+   softpipe->pipe.flush = softpipe_flush_wrapped;
 
    softpipe->pipe.render_condition = softpipe_render_condition;
 
diff --git a/src/gallium/drivers/softpipe/sp_flush.c b/src/gallium/drivers/softpipe/sp_flush.c
index edbce6a297..720fea83cb 100644
--- a/src/gallium/drivers/softpipe/sp_flush.c
+++ b/src/gallium/drivers/softpipe/sp_flush.c
@@ -42,7 +42,7 @@
 
 void
 softpipe_flush( struct pipe_context *pipe,
-		unsigned flags,
+                unsigned flags,
                 struct pipe_fence_handle **fence )
 {
    struct softpipe_context *softpipe = softpipe_context(pipe);
@@ -50,7 +50,7 @@ softpipe_flush( struct pipe_context *pipe,
 
    draw_flush(softpipe->draw);
 
-   if (flags & PIPE_FLUSH_TEXTURE_CACHE) {
+   if (flags & SP_FLUSH_TEXTURE_CACHE) {
       for (i = 0; i < softpipe->num_fragment_sampler_views; i++) {
          sp_flush_tex_tile_cache(softpipe->fragment_tex_cache[i]);
       }
@@ -62,34 +62,27 @@ softpipe_flush( struct pipe_context *pipe,
       }
    }
 
-   if (flags & PIPE_FLUSH_SWAPBUFFERS) {
-      /* If this is a swapbuffers, just flush color buffers.
-       *
-       * The zbuffer changes are not discarded, but held in the cache
-       * in the hope that a later clear will wipe them out.
-       */
-      for (i = 0; i < softpipe->framebuffer.nr_cbufs; i++)
-         if (softpipe->cbuf_cache[i])
-            sp_flush_tile_cache(softpipe->cbuf_cache[i]);
-
-      /* Need this call for hardware buffers before swapbuffers.
-       *
-       * there should probably be another/different flush-type function
-       * that's called before swapbuffers because we don't always want
-       * to unmap surfaces when flushing.
-       */
-      softpipe_unmap_transfers(softpipe);
-   }
-   else if (flags & PIPE_FLUSH_RENDER_CACHE) {
-      for (i = 0; i < softpipe->framebuffer.nr_cbufs; i++)
-         if (softpipe->cbuf_cache[i])
-            sp_flush_tile_cache(softpipe->cbuf_cache[i]);
-
-      if (softpipe->zsbuf_cache)
-         sp_flush_tile_cache(softpipe->zsbuf_cache);
-     
-      softpipe->dirty_render_cache = FALSE;
-   }
+   /* If this is a swapbuffers, just flush color buffers.
+    *
+    * The zbuffer changes are not discarded, but held in the cache
+    * in the hope that a later clear will wipe them out.
+    */
+   for (i = 0; i < softpipe->framebuffer.nr_cbufs; i++)
+      if (softpipe->cbuf_cache[i])
+         sp_flush_tile_cache(softpipe->cbuf_cache[i]);
+
+   if (softpipe->zsbuf_cache)
+      sp_flush_tile_cache(softpipe->zsbuf_cache);
+
+   softpipe->dirty_render_cache = FALSE;
+
+   /* Need this call for hardware buffers before swapbuffers.
+    *
+    * there should probably be another/different flush-type function
+    * that's called before swapbuffers because we don't always want
+    * to unmap surfaces when flushing.
+    */
+   softpipe_unmap_transfers(softpipe);
 
    /* Enable to dump BMPs of the color/depth buffers each frame */
 #if 0
@@ -108,6 +101,13 @@ softpipe_flush( struct pipe_context *pipe,
       *fence = NULL;
 }
 
+void
+softpipe_flush_wrapped( struct pipe_context *pipe,
+                        struct pipe_fence_handle **fence )
+{
+   softpipe_flush(pipe, SP_FLUSH_TEXTURE_CACHE, fence);
+}
+
 
 /**
  * Flush context if necessary.
@@ -139,11 +139,8 @@ softpipe_flush_resource(struct pipe_context *pipe,
        * disappear and the pipe driver should just ensure that all visible
        * side-effects happen when they need to happen.
        */
-      if (referenced & SP_REFERENCED_FOR_WRITE)
-         flush_flags |= PIPE_FLUSH_RENDER_CACHE;
-
       if (referenced & SP_REFERENCED_FOR_READ)
-         flush_flags |= PIPE_FLUSH_TEXTURE_CACHE;
+         flush_flags |= SP_FLUSH_TEXTURE_CACHE;
 
       if (cpu_access) {
          /*
@@ -155,7 +152,7 @@ softpipe_flush_resource(struct pipe_context *pipe,
          if (do_not_block)
             return FALSE;
 
-         pipe->flush(pipe, flush_flags, &fence);
+         softpipe_flush(pipe, flush_flags, &fence);
 
          if (fence) {
             /*
@@ -171,7 +168,7 @@ softpipe_flush_resource(struct pipe_context *pipe,
           * Just flush.
           */
 
-         pipe->flush(pipe, flush_flags, NULL);
+         softpipe_flush(pipe, flush_flags, NULL);
       }
    }
 
diff --git a/src/gallium/drivers/softpipe/sp_flush.h b/src/gallium/drivers/softpipe/sp_flush.h
index 22a5ceeb9e..ab01c249ab 100644
--- a/src/gallium/drivers/softpipe/sp_flush.h
+++ b/src/gallium/drivers/softpipe/sp_flush.h
@@ -33,10 +33,17 @@
 struct pipe_context;
 struct pipe_fence_handle;
 
+#define SP_FLUSH_TEXTURE_CACHE  0x2
+
 void
-softpipe_flush(struct pipe_context *pipe, unsigned flags,
+softpipe_flush(struct pipe_context *pipe,
+               unsigned flags,
                struct pipe_fence_handle **fence);
 
+void
+softpipe_flush_wrapped( struct pipe_context *pipe,
+                        struct pipe_fence_handle **fence );
+
 boolean
 softpipe_flush_resource(struct pipe_context *pipe,
                         struct pipe_resource *texture,
diff --git a/src/gallium/drivers/svga/svga_pipe_draw.c b/src/gallium/drivers/svga/svga_pipe_draw.c
index d98b9b0e00..fda5c28433 100644
--- a/src/gallium/drivers/svga/svga_pipe_draw.c
+++ b/src/gallium/drivers/svga/svga_pipe_draw.c
@@ -161,7 +161,7 @@ svga_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *info)
       /* We're switching between SW and HW drawing.  Do a flush to avoid
        * mixing HW and SW rendering with the same vertex buffer.
        */
-      pipe->flush(pipe, ~0, NULL);
+      pipe->flush(pipe, NULL);
       svga->prev_draw_swtnl = svga->state.sw.need_swtnl;
    }
 
diff --git a/src/gallium/drivers/svga/svga_pipe_flush.c b/src/gallium/drivers/svga/svga_pipe_flush.c
index 9357d827f2..4578c136cb 100644
--- a/src/gallium/drivers/svga/svga_pipe_flush.c
+++ b/src/gallium/drivers/svga/svga_pipe_flush.c
@@ -32,7 +32,6 @@
 
 
 static void svga_flush( struct pipe_context *pipe,
-                        unsigned flags,
                         struct pipe_fence_handle **fence )
 {
    struct svga_context *svga = svga_context(pipe);
@@ -45,29 +44,27 @@ static void svga_flush( struct pipe_context *pipe,
     */
    svga_context_flush(svga, fence);
 
-   SVGA_DBG(DEBUG_DMA|DEBUG_PERF, "%s flags %x fence_ptr %p\n",
-            __FUNCTION__, flags, fence ? *fence : 0x0);
+   SVGA_DBG(DEBUG_DMA|DEBUG_PERF, "%s fence_ptr %p\n",
+            __FUNCTION__, fence ? *fence : 0x0);
 
    /* Enable to dump BMPs of the color/depth buffers each frame */
    if (0) {
-      if (flags & PIPE_FLUSH_FRAME) {
-         struct pipe_framebuffer_state *fb = &svga->curr.framebuffer;
-         static unsigned frame_no = 1;
-         char filename[256];
-         unsigned i;
+      struct pipe_framebuffer_state *fb = &svga->curr.framebuffer;
+      static unsigned frame_no = 1;
+      char filename[256];
+      unsigned i;
 
-         for (i = 0; i < fb->nr_cbufs; i++) {
-            util_snprintf(filename, sizeof(filename), "cbuf%u_%04u", i, frame_no);
-            debug_dump_surface_bmp(&svga->pipe, filename, fb->cbufs[i]);
-         }
-
-         if (0 && fb->zsbuf) {
-            util_snprintf(filename, sizeof(filename), "zsbuf_%04u", frame_no);
-            debug_dump_surface_bmp(&svga->pipe, filename, fb->zsbuf);
-         }
+      for (i = 0; i < fb->nr_cbufs; i++) {
+         util_snprintf(filename, sizeof(filename), "cbuf%u_%04u", i, frame_no);
+         debug_dump_surface_bmp(&svga->pipe, filename, fb->cbufs[i]);
+      }
 
-         ++frame_no;
+      if (0 && fb->zsbuf) {
+         util_snprintf(filename, sizeof(filename), "zsbuf_%04u", frame_no);
+         debug_dump_surface_bmp(&svga->pipe, filename, fb->zsbuf);
       }
+
+      ++frame_no;
    }
 }
 
diff --git a/src/gallium/drivers/trace/tr_context.c b/src/gallium/drivers/trace/tr_context.c
index 6123873cac..4db7619c42 100644
--- a/src/gallium/drivers/trace/tr_context.c
+++ b/src/gallium/drivers/trace/tr_context.c
@@ -1184,7 +1184,6 @@ trace_context_clear_depth_stencil(struct pipe_context *_pipe,
 
 static INLINE void
 trace_context_flush(struct pipe_context *_pipe,
-                    unsigned flags,
                     struct pipe_fence_handle **fence)
 {
    struct trace_context *tr_ctx = trace_context(_pipe);
@@ -1193,9 +1192,8 @@ trace_context_flush(struct pipe_context *_pipe,
    trace_dump_call_begin("pipe_context", "flush");
 
    trace_dump_arg(ptr, pipe);
-   trace_dump_arg(uint, flags);
 
-   pipe->flush(pipe, flags, fence);
+   pipe->flush(pipe, fence);
 
    if(fence)
       trace_dump_ret(ptr, *fence);