X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Fsoftpipe%2Fsp_flush.c;h=a2733e95878f52f386f82653696b75076c79822b;hb=f32c9c210875b2ce4878f97b84bdd4739bd489f9;hp=1071011db0ef1bff225eea5977a33f33cecef545;hpb=695cc370a280a637f411f5ff3877b3fd1c05e424;p=mesa.git

diff --git a/src/gallium/drivers/softpipe/sp_flush.c b/src/gallium/drivers/softpipe/sp_flush.c
index 1071011db0e..a2733e95878 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,9 +50,9 @@ softpipe_flush( struct pipe_context *pipe,
 
    draw_flush(softpipe->draw);
 
-   if (flags & PIPE_FLUSH_TEXTURE_CACHE) {
-      for (i = 0; i < softpipe->num_sampler_views; i++) {
-         sp_flush_tex_tile_cache(softpipe->tex_cache[i]);
+   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]);
       }
       for (i = 0; i < softpipe->num_vertex_sampler_views; i++) {
          sp_flush_tex_tile_cache(softpipe->vertex_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
@@ -103,9 +96,16 @@ softpipe_flush( struct pipe_context *pipe,
       ++frame_no;
    }
 #endif
-   
+
    if (fence)
-      *fence = NULL;
+      *fence = (void*)(intptr_t)1;
+}
+
+void
+softpipe_flush_wrapped( struct pipe_context *pipe,
+                        struct pipe_fence_handle **fence )
+{
+   softpipe_flush(pipe, SP_FLUSH_TEXTURE_CACHE, fence);
 }
 
 
@@ -120,8 +120,8 @@ softpipe_flush( struct pipe_context *pipe,
 boolean
 softpipe_flush_resource(struct pipe_context *pipe,
                         struct pipe_resource *texture,
-                        unsigned face,
                         unsigned level,
+                        int layer,
                         unsigned flush_flags,
                         boolean read_only,
                         boolean cpu_access,
@@ -129,21 +129,18 @@ softpipe_flush_resource(struct pipe_context *pipe,
 {
    unsigned referenced;
 
-   referenced = pipe->is_resource_referenced(pipe, texture, face, level);
+   referenced = softpipe_is_resource_referenced(pipe, texture, level, layer);
 
-   if ((referenced & PIPE_REFERENCED_FOR_WRITE) ||
-       ((referenced & PIPE_REFERENCED_FOR_READ) && !read_only)) {
+   if ((referenced & SP_REFERENCED_FOR_WRITE) ||
+       ((referenced & SP_REFERENCED_FOR_READ) && !read_only)) {
 
       /*
        * TODO: The semantics of these flush flags are too obtuse. They should
        * disappear and the pipe driver should just ensure that all visible
        * side-effects happen when they need to happen.
        */
-      if (referenced & PIPE_REFERENCED_FOR_WRITE)
-         flush_flags |= PIPE_FLUSH_RENDER_CACHE;
-
-      if (referenced & PIPE_REFERENCED_FOR_READ)
-         flush_flags |= PIPE_FLUSH_TEXTURE_CACHE;
+      if (referenced & SP_REFERENCED_FOR_READ)
+         flush_flags |= SP_FLUSH_TEXTURE_CACHE;
 
       if (cpu_access) {
          /*
@@ -155,14 +152,15 @@ 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) {
             /*
              * This is for illustrative purposes only, as softpipe does not
              * have fences.
              */
-            pipe->screen->fence_finish(pipe->screen, fence, 0);
+            pipe->screen->fence_finish(pipe->screen, fence,
+                                       PIPE_TIMEOUT_INFINITE);
             pipe->screen->fence_reference(pipe->screen, &fence, NULL);
          }
       } else {
@@ -170,7 +168,7 @@ softpipe_flush_resource(struct pipe_context *pipe,
           * Just flush.
           */
 
-         pipe->flush(pipe, flush_flags, NULL);
+         softpipe_flush(pipe, flush_flags, NULL);
       }
    }