i965: Implement fast color clears using meta operations

This patch uses the infrastructure put in place by previous patches
to implement fast color clears and replicated color clears in terms of
meta operations.

This works all the way back to gen7 where fast clear was introduced and
adds support for fast clear on gen8.  It replaces the blorp path
completely and improves on a few cases.  Layered clears are now done
using instanced rendering and multiple render-target clears use a
MRT shader with rep16 writes.

Signed-off-by: Kristian Høgsberg <krh@bitplanet.net>
Acked-by: Kenneth Graunke <kenneth@whitecape.org>

1 files changed, 704 insertions, 0 deletions

diff --git a/src/mesa/drivers/dri/i965/brw_meta_fast_clear.c b/src/mesa/drivers/dri/i965/brw_meta_fast_clear.c
new file mode 100644
index 0000000..c6540f2
--- /dev/null
+++ b/src/mesa/drivers/dri/i965/brw_meta_fast_clear.c
@@ -0,0 +1,704 @@
+/*
+ * Copyright © 2014 Intel Corporation
+ *
+ * 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, sublicense,
+ * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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 "main/mtypes.h"
+#include "main/macros.h"
+#include "main/context.h"
+#include "main/objectlabel.h"
+#include "main/shaderapi.h"
+#include "main/arrayobj.h"
+#include "main/bufferobj.h"
+#include "main/buffers.h"
+#include "main/blend.h"
+#include "main/enable.h"
+#include "main/depth.h"
+#include "main/stencil.h"
+#include "main/varray.h"
+#include "main/uniforms.h"
+#include "main/fbobject.h"
+#include "main/texobj.h"
+
+#include "main/api_validate.h"
+#include "main/state.h"
+
+#include "vbo/vbo_context.h"
+
+#include "drivers/common/meta.h"
+
+#include "brw_defines.h"
+#include "brw_context.h"
+#include "brw_draw.h"
+#include "intel_fbo.h"
+#include "intel_batchbuffer.h"
+
+#include "brw_blorp.h"
+
+struct brw_fast_clear_state {
+   GLuint vao;
+   GLuint vbo;
+   GLuint shader_prog;
+   GLint color_location;
+};
+
+static bool
+brw_fast_clear_init(struct brw_context *brw)
+{
+   struct brw_fast_clear_state *clear;
+
+   if (brw->fast_clear_state) {
+      clear = brw->fast_clear_state;
+      _mesa_BindVertexArray(clear->vao);
+      _mesa_BindBuffer(GL_ARRAY_BUFFER, clear->vbo);
+      return true;
+   }
+
+   brw->fast_clear_state = clear = malloc(sizeof *clear);
+   if (clear == NULL)
+      return false;
+
+   memset(clear, 0, sizeof *clear);
+   _mesa_GenVertexArrays(1, &clear->vao);
+   _mesa_BindVertexArray(clear->vao);
+   _mesa_GenBuffers(1, &clear->vbo);
+   _mesa_BindBuffer(GL_ARRAY_BUFFER, clear->vbo);
+   _mesa_VertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, 0);
+   _mesa_EnableVertexAttribArray(0);
+
+   return true;
+}
+
+static void
+brw_bind_rep_write_shader(struct brw_context *brw, float *color)
+{
+   const char *vs_source =
+      "#extension GL_AMD_vertex_shader_layer : enable\n"
+      "#extension GL_ARB_draw_instanced : enable\n"
+      "attribute vec4 position;\n"
+      "uniform int layer;\n"
+      "void main()\n"
+      "{\n"
+      "   gl_Layer = gl_InstanceID;\n"
+      "   gl_Position = position;\n"
+      "}\n";
+   const char *fs_source =
+      "uniform vec4 color;\n"
+      "void main()\n"
+      "{\n"
+      "   gl_FragColor = color;\n"
+      "}\n";
+
+   GLuint vs, fs;
+   struct brw_fast_clear_state *clear = brw->fast_clear_state;
+   struct gl_context *ctx = &brw->ctx;
+
+   if (clear->shader_prog) {
+      _mesa_UseProgram(clear->shader_prog);
+      _mesa_Uniform4fv(clear->color_location, 1, color);
+      return;
+   }
+
+   vs = _mesa_meta_compile_shader_with_debug(ctx, GL_VERTEX_SHADER, vs_source);
+   fs = _mesa_meta_compile_shader_with_debug(ctx, GL_FRAGMENT_SHADER, fs_source);
+
+   clear->shader_prog = _mesa_CreateProgram();
+   _mesa_AttachShader(clear->shader_prog, fs);
+   _mesa_DeleteShader(fs);
+   _mesa_AttachShader(clear->shader_prog, vs);
+   _mesa_DeleteShader(vs);
+   _mesa_BindAttribLocation(clear->shader_prog, 0, "position");
+   _mesa_ObjectLabel(GL_PROGRAM, clear->shader_prog, -1, "meta clear");
+   _mesa_LinkProgram(clear->shader_prog);
+
+   clear->color_location =
+      _mesa_GetUniformLocation(clear->shader_prog, "color");
+
+   _mesa_UseProgram(clear->shader_prog);
+   _mesa_Uniform4fv(clear->color_location, 1, color);
+}
+
+void
+brw_meta_fast_clear_free(struct brw_context *brw)
+{
+   struct brw_fast_clear_state *clear = brw->fast_clear_state;
+   GET_CURRENT_CONTEXT(old_context);
+
+   if (clear == NULL)
+      return;
+
+   _mesa_make_current(&brw->ctx, NULL, NULL);
+
+   _mesa_DeleteVertexArrays(1, &clear->vao);
+   _mesa_DeleteBuffers(1, &clear->vbo);
+   _mesa_DeleteProgram(clear->shader_prog);
+   free(clear);
+
+   if (old_context)
+      _mesa_make_current(old_context, old_context->WinSysDrawBuffer, old_context->WinSysReadBuffer);
+   else
+      _mesa_make_current(NULL, NULL, NULL);
+}
+
+struct rect {
+   int x0, y0, x1, y1;
+};
+
+static void
+brw_draw_rectlist(struct gl_context *ctx, struct rect *rect, int num_instances)
+{
+   int start = 0, count = 3;
+   struct _mesa_prim prim;
+   float verts[6];
+
+   verts[0] = rect->x1;
+   verts[1] = rect->y1;
+   verts[2] = rect->x0;
+   verts[3] = rect->y1;
+   verts[4] = rect->x0;
+   verts[5] = rect->y0;
+
+   /* upload new vertex data */
+   _mesa_BufferData(GL_ARRAY_BUFFER_ARB, sizeof(verts), verts,
+                    GL_DYNAMIC_DRAW_ARB);
+
+   if (ctx->NewState)
+      _mesa_update_state(ctx);
+
+   vbo_bind_arrays(ctx);
+
+   memset(&prim, 0, sizeof prim);
+   prim.begin = 1;
+   prim.end = 1;
+   prim.mode = BRW_PRIM_OFFSET + _3DPRIM_RECTLIST;
+   prim.num_instances = num_instances;
+   prim.start = start;
+   prim.count = count;
+
+   /* Make sure our internal prim value doesn't clash with a valid GL value. */
+   assert(!_mesa_is_valid_prim_mode(ctx, prim.mode));
+
+   brw_draw_prims(ctx, &prim, 1, NULL,
+                  GL_TRUE, start, start + count - 1,
+                  NULL, NULL);
+}
+
+static void
+get_fast_clear_rect(struct brw_context *brw, struct gl_framebuffer *fb,
+                    struct intel_renderbuffer *irb, struct rect *rect)
+{
+   unsigned int x_align, y_align;
+   unsigned int x_scaledown, y_scaledown;
+
+   if (irb->mt->msaa_layout == INTEL_MSAA_LAYOUT_NONE) {
+      /* From the Ivy Bridge PRM, Vol2 Part1 11.7 "MCS Buffer for Render
+       * Target(s)", beneath the "Fast Color Clear" bullet (p327):
+       *
+       *     Clear pass must have a clear rectangle that must follow
+       *     alignment rules in terms of pixels and lines as shown in the
+       *     table below. Further, the clear-rectangle height and width
+       *     must be multiple of the following dimensions. If the height
+       *     and width of the render target being cleared do not meet these
+       *     requirements, an MCS buffer can be created such that it
+       *     follows the requirement and covers the RT.
+       *
+       * The alignment size in the table that follows is related to the
+       * alignment size returned by intel_get_non_msrt_mcs_alignment(), but
+       * with X alignment multiplied by 16 and Y alignment multiplied by 32.
+       */
+      intel_get_non_msrt_mcs_alignment(brw, irb->mt, &x_align, &y_align);
+      x_align *= 16;
+      y_align *= 32;
+
+      /* From the Ivy Bridge PRM, Vol2 Part1 11.7 "MCS Buffer for Render
+       * Target(s)", beneath the "Fast Color Clear" bullet (p327):
+       *
+       *     In order to optimize the performance MCS buffer (when bound to
+       *     1X RT) clear similarly to MCS buffer clear for MSRT case,
+       *     clear rect is required to be scaled by the following factors
+       *     in the horizontal and vertical directions:
+       *
+       * The X and Y scale down factors in the table that follows are each
+       * equal to half the alignment value computed above.
+       */
+      x_scaledown = x_align / 2;
+      y_scaledown = y_align / 2;
+
+      /* From BSpec: 3D-Media-GPGPU Engine > 3D Pipeline > Pixel > Pixel
+       * Backend > MCS Buffer for Render Target(s) [DevIVB+] > Table "Color
+       * Clear of Non-MultiSampled Render Target Restrictions":
+       *
+       *   Clear rectangle must be aligned to two times the number of
+       *   pixels in the table shown below due to 16x16 hashing across the
+       *   slice.
+       */
+      x_align *= 2;
+      y_align *= 2;
+   } else {
+      /* From the Ivy Bridge PRM, Vol2 Part1 11.7 "MCS Buffer for Render
+       * Target(s)", beneath the "MSAA Compression" bullet (p326):
+       *
+       *     Clear pass for this case requires that scaled down primitive
+       *     is sent down with upper left co-ordinate to coincide with
+       *     actual rectangle being cleared. For MSAA, clear rectangle’s
+       *     height and width need to as show in the following table in
+       *     terms of (width,height) of the RT.
+       *
+       *     MSAA  Width of Clear Rect  Height of Clear Rect
+       *      4X     Ceil(1/8*width)      Ceil(1/2*height)
+       *      8X     Ceil(1/2*width)      Ceil(1/2*height)
+       *
+       * The text "with upper left co-ordinate to coincide with actual
+       * rectangle being cleared" is a little confusing--it seems to imply
+       * that to clear a rectangle from (x,y) to (x+w,y+h), one needs to
+       * feed the pipeline using the rectangle (x,y) to
+       * (x+Ceil(w/N),y+Ceil(h/2)), where N is either 2 or 8 depending on
+       * the number of samples.  Experiments indicate that this is not
+       * quite correct; actually, what the hardware appears to do is to
+       * align whatever rectangle is sent down the pipeline to the nearest
+       * multiple of 2x2 blocks, and then scale it up by a factor of N
+       * horizontally and 2 vertically.  So the resulting alignment is 4
+       * vertically and either 4 or 16 horizontally, and the scaledown
+       * factor is 2 vertically and either 2 or 8 horizontally.
+       */
+      switch (irb->mt->num_samples) {
+      case 4:
+         x_scaledown = 8;
+         break;
+      case 8:
+         x_scaledown = 2;
+         break;
+      default:
+         assert(!"Unexpected sample count for fast clear");
+         break;
+      }
+      y_scaledown = 2;
+      x_align = x_scaledown * 2;
+      y_align = y_scaledown * 2;
+   }
+
+   rect->x0 = fb->_Xmin;
+   rect->x1 = fb->_Xmax;
+   if (fb->Name != 0) {
+      rect->y0 = fb->_Ymin;
+      rect->y1 = fb->_Ymax;
+   } else {
+      rect->y0 = fb->Height - fb->_Ymax;
+      rect->y1 = fb->Height - fb->_Ymin;
+   }
+
+   rect->x0 = ROUND_DOWN_TO(rect->x0,  x_align) / x_scaledown;
+   rect->y0 = ROUND_DOWN_TO(rect->y0, y_align) / y_scaledown;
+   rect->x1 = ALIGN(rect->x1, x_align) / x_scaledown;
+   rect->y1 = ALIGN(rect->y1, y_align) / y_scaledown;
+}
+
+static void
+get_buffer_rect(struct brw_context *brw, struct gl_framebuffer *fb,
+                struct intel_renderbuffer *irb, struct rect *rect)
+{
+   rect->x0 = fb->_Xmin;
+   rect->x1 = fb->_Xmax;
+   if (fb->Name != 0) {
+      rect->y0 = fb->_Ymin;
+      rect->y1 = fb->_Ymax;
+   } else {
+      rect->y0 = fb->Height - fb->_Ymax;
+      rect->y1 = fb->Height - fb->_Ymin;
+   }
+}
+
+/**
+ * Determine if fast color clear supports the given clear color.
+ *
+ * Fast color clear can only clear to color values of 1.0 or 0.0.  At the
+ * moment we only support floating point, unorm, and snorm buffers.
+ */
+static bool
+is_color_fast_clear_compatible(struct brw_context *brw,
+                               mesa_format format,
+                               const union gl_color_union *color)
+{
+   if (_mesa_is_format_integer_color(format))
+      return false;
+
+   for (int i = 0; i < 4; i++) {
+      if (color->f[i] != 0.0 && color->f[i] != 1.0 &&
+          _mesa_format_has_color_component(format, i)) {
+         return false;
+      }
+   }
+   return true;
+}
+
+/**
+ * Convert the given color to a bitfield suitable for ORing into DWORD 7 of
+ * SURFACE_STATE.
+ */
+static uint32_t
+compute_fast_clear_color_bits(const union gl_color_union *color)
+{
+   uint32_t bits = 0;
+   for (int i = 0; i < 4; i++) {
+      /* Testing for non-0 works for integer and float colors */
+      if (color->f[i] != 0.0)
+         bits |= 1 << (GEN7_SURFACE_CLEAR_COLOR_SHIFT + (3 - i));
+   }
+   return bits;
+}
+
+static const uint32_t fast_clear_color[4] = { ~0, ~0, ~0, ~0 };
+
+static void
+set_fast_clear_op(struct brw_context *brw, uint32_t op)
+{
+   /* Set op and dirty BRW_NEW_FRAGMENT_PROGRAM to make sure we re-emit
+    * 3DSTATE_PS.
+    */
+   brw->wm.fast_clear_op = op;
+   brw->state.dirty.brw |= BRW_NEW_FRAGMENT_PROGRAM;
+}
+
+static void
+use_rectlist(struct brw_context *brw, bool enable)
+{
+   /* Set custom state to let us use _3DPRIM_RECTLIST and the replicated
+    * rendertarget write.  When we enable reclist mode, we disable the
+    * viewport transform, disable clipping, enable the rep16 write
+    * optimization and disable simd8 dispatch in the PS.
+    */
+   brw->sf.viewport_transform_enable = !enable;
+   brw->use_rep_send = enable;
+   brw->no_simd8 = enable;
+
+   /* Dirty state to make sure we reemit the state packages affected by the
+    * custom state.  We dirty BRW_NEW_FRAGMENT_PROGRAM to emit 3DSTATE_PS for
+    * disabling simd8 dispatch, _NEW_LIGHT to emit 3DSTATE_SF for disabling
+    * the viewport transform and 3DSTATE_CLIP to disable clipping for the
+    * reclist primitive.  This is a little messy - it would be nicer to
+    * BRW_NEW_FAST_CLEAR flag or so, but we're out of brw state bits.  Dirty
+    * _NEW_BUFFERS to make sure we emit new SURFACE_STATE with the new fast
+    * clear color value.
+    */
+   brw->state.dirty.mesa |= _NEW_LIGHT | _NEW_BUFFERS;
+   brw->state.dirty.brw |= BRW_NEW_FRAGMENT_PROGRAM;
+}
+
+bool
+brw_meta_fast_clear(struct brw_context *brw, struct gl_framebuffer *fb,
+                    GLbitfield buffers, bool partial_clear)
+{
+   struct gl_context *ctx = &brw->ctx;
+   mesa_format format;
+   enum { FAST_CLEAR, REP_CLEAR, PLAIN_CLEAR } clear_type;
+   GLbitfield plain_clear_buffers, meta_save, rep_clear_buffers, fast_clear_buffers;
+   struct rect fast_clear_rect, clear_rect;
+   int layers;
+
+   fast_clear_buffers = rep_clear_buffers = plain_clear_buffers = 0;
+
+   /* First we loop through the color draw buffers and determine which ones
+    * can be fast cleared, which ones can use the replicated write and which
+    * ones have to fall back to regular color clear.
+    */
+   for (unsigned buf = 0; buf < fb->_NumColorDrawBuffers; buf++) {
+      struct gl_renderbuffer *rb = fb->_ColorDrawBuffers[buf];
+      struct intel_renderbuffer *irb = intel_renderbuffer(rb);
+      int index = fb->_ColorDrawBufferIndexes[buf];
+
+      /* Only clear the buffers present in the provided mask */
+      if (((1 << index) & buffers) == 0)
+         continue;
+
+      /* If this is an ES2 context or GL_ARB_ES2_compatibility is supported,
+       * the framebuffer can be complete with some attachments missing.  In
+       * this case the _ColorDrawBuffers pointer will be NULL.
+       */
+      if (rb == NULL)
+         continue;
+
+      clear_type = FAST_CLEAR;
+
+      /* We don't have fast clear until gen7. */
+      if (brw->gen < 7)
+         clear_type = REP_CLEAR;
+
+      if (irb->mt->fast_clear_state == INTEL_FAST_CLEAR_STATE_NO_MCS)
+         clear_type = REP_CLEAR;
+
+      /* We can't do scissored fast clears because of the restrictions on the
+       * fast clear rectangle size.
+       */
+      if (partial_clear)
+         clear_type = REP_CLEAR;
+
+      /* Fast clear is only supported for colors where all components are
+       * either 0 or 1.
+       */
+      format = _mesa_get_render_format(ctx, irb->mt->format);
+      if (!is_color_fast_clear_compatible(brw, format, &ctx->Color.ClearColor))
+         clear_type = REP_CLEAR;
+
+      /* From the SNB PRM (Vol4_Part1):
+       *
+       *     "Replicated data (Message Type = 111) is only supported when
+       *      accessing tiled memory.  Using this Message Type to access
+       *      linear (untiled) memory is UNDEFINED."
+       */
+      if (irb->mt->tiling == I915_TILING_NONE) {
+         perf_debug("falling back to plain clear because buffers are untiled\n");
+         clear_type = PLAIN_CLEAR;
+      }
+
+      /* Constant color writes ignore everything in blend and color calculator
+       * state.  This is not documented.
+       */
+      GLubyte *color_mask = ctx->Color.ColorMask[buf];
+      for (int i = 0; i < 4; i++) {
+         if (_mesa_format_has_color_component(irb->mt->format, i) &&
+             !color_mask[i]) {
+            perf_debug("falling back to plain clear because of color mask\n");
+            clear_type = PLAIN_CLEAR;
+         }
+      }
+
+      /* Allocate the MCS for non MSRT surfaces now if we're doing a fast
+       * clear and we don't have the MCS yet.  On failure, fall back to
+       * replicated clear.
+       */
+      if (clear_type == FAST_CLEAR && irb->mt->mcs_mt == NULL)
+         if (!intel_miptree_alloc_non_msrt_mcs(brw, irb->mt))
+            clear_type = REP_CLEAR;
+
+      switch (clear_type) {
+      case FAST_CLEAR:
+         irb->mt->fast_clear_color_value =
+            compute_fast_clear_color_bits(&ctx->Color.ClearColor);
+         irb->need_downsample = true;
+
+         /* If the buffer is already in INTEL_FAST_CLEAR_STATE_CLEAR, the
+          * clear is redundant and can be skipped.  Only skip after we've
+          * updated the fast clear color above though.
+          */
+         if (irb->mt->fast_clear_state == INTEL_FAST_CLEAR_STATE_CLEAR)
+            continue;
+
+         /* Set fast_clear_state to RESOLVED so we don't try resolve them when
+          * we draw, in case the mt is also bound as a texture.
+          */
+         irb->mt->fast_clear_state = INTEL_FAST_CLEAR_STATE_RESOLVED;
+         irb->need_downsample = true;
+         fast_clear_buffers |= 1 << index;
+         get_fast_clear_rect(brw, fb, irb, &fast_clear_rect);
+         break;
+
+      case REP_CLEAR:
+         rep_clear_buffers |= 1 << index;
+         get_buffer_rect(brw, fb, irb, &clear_rect);
+         break;
+
+      case PLAIN_CLEAR:
+         plain_clear_buffers |= 1 << index;
+         get_buffer_rect(brw, fb, irb, &clear_rect);
+         continue;
+      }
+   }
+
+   if (!(fast_clear_buffers | rep_clear_buffers)) {
+      if (plain_clear_buffers)
+         /* If we only have plain clears, skip the meta save/restore. */
+         goto out;
+      else
+         /* Nothing left to do.  This happens when we hit the redundant fast
+          * clear case above and nothing else.
+          */
+         return true;
+   }
+
+   meta_save =
+      MESA_META_ALPHA_TEST |
+      MESA_META_BLEND |
+      MESA_META_DEPTH_TEST |
+      MESA_META_RASTERIZATION |
+      MESA_META_SHADER |
+      MESA_META_STENCIL_TEST |
+      MESA_META_VERTEX |
+      MESA_META_VIEWPORT |
+      MESA_META_CLIP |
+      MESA_META_CLAMP_FRAGMENT_COLOR |
+      MESA_META_MULTISAMPLE |
+      MESA_META_OCCLUSION_QUERY |
+      MESA_META_DRAW_BUFFERS;
+
+   _mesa_meta_begin(ctx, meta_save);
+
+   if (!brw_fast_clear_init(brw)) {
+      /* This is going to be hard to recover from, most likely out of memory.
+       * Bail and let meta try and (probably) fail for us.
+       */
+      plain_clear_buffers = buffers;
+      goto bail_to_meta;
+   }
+
+   /* Clears never have the color clamped. */
+   if (ctx->Extensions.ARB_color_buffer_float)
+      _mesa_ClampColor(GL_CLAMP_FRAGMENT_COLOR, GL_FALSE);
+
+   _mesa_set_enable(ctx, GL_DEPTH_TEST, GL_FALSE);
+   _mesa_DepthMask(GL_FALSE);
+   _mesa_set_enable(ctx, GL_STENCIL_TEST, GL_FALSE);
+
+   use_rectlist(brw, true);
+
+   layers = MAX2(1, fb->MaxNumLayers);
+   if (fast_clear_buffers) {
+      _mesa_meta_drawbuffers_from_bitfield(fast_clear_buffers);
+      brw_bind_rep_write_shader(brw, (float *) fast_clear_color);
+      set_fast_clear_op(brw, GEN7_PS_RENDER_TARGET_FAST_CLEAR_ENABLE);
+      brw_draw_rectlist(ctx, &fast_clear_rect, layers);
+      set_fast_clear_op(brw, 0);
+   }
+
+   if (rep_clear_buffers) {
+      _mesa_meta_drawbuffers_from_bitfield(rep_clear_buffers);
+      brw_bind_rep_write_shader(brw, ctx->Color.ClearColor.f);
+      brw_draw_rectlist(ctx, &clear_rect, layers);
+   }
+
+   /* Now set the mts we cleared to INTEL_FAST_CLEAR_STATE_CLEAR so we'll
+    * resolve them eventually.
+    */
+   for (unsigned buf = 0; buf < fb->_NumColorDrawBuffers; buf++) {
+      struct gl_renderbuffer *rb = fb->_ColorDrawBuffers[buf];
+      struct intel_renderbuffer *irb = intel_renderbuffer(rb);
+      int index = fb->_ColorDrawBufferIndexes[buf];
+
+      if ((1 << index) & fast_clear_buffers)
+         irb->mt->fast_clear_state = INTEL_FAST_CLEAR_STATE_CLEAR;
+   }
+
+ bail_to_meta:
+   /* Dirty _NEW_BUFFERS so we reemit SURFACE_STATE which sets the fast clear
+    * color before resolve and sets irb->mt->fast_clear_state to UNRESOLVED if
+    * we render to it.
+    */
+   brw->state.dirty.mesa |= _NEW_BUFFERS;
+
+
+   /* Set the custom state back to normal and dirty the same bits as above */
+   use_rectlist(brw, false);
+
+   _mesa_meta_end(ctx);
+
+   /* From BSpec: Render Target Fast Clear:
+    *
+    *     After Render target fast clear, pipe-control with color cache
+    *     write-flush must be issued before sending any DRAW commands on that
+    *     render target.
+    */
+   intel_batchbuffer_emit_mi_flush(brw);
+
+   /* If we had to fall back to plain clear for any buffers, clear those now
+    * by calling into meta.
+    */
+ out:
+   if (plain_clear_buffers)
+      _mesa_meta_glsl_Clear(&brw->ctx, plain_clear_buffers);
+
+   return true;
+}
+
+static void
+get_resolve_rect(struct brw_context *brw,
+                 struct intel_mipmap_tree *mt, struct rect *rect)
+{
+   unsigned x_align, y_align;
+   unsigned x_scaledown, y_scaledown;
+
+   /* From the Ivy Bridge PRM, Vol2 Part1 11.9 "Render Target Resolve":
+    *
+    *     A rectangle primitive must be scaled down by the following factors
+    *     with respect to render target being resolved.
+    *
+    * The scaledown factors in the table that follows are related to the
+    * alignment size returned by intel_get_non_msrt_mcs_alignment(), but with
+    * X and Y alignment each divided by 2.
+    */
+
+   intel_get_non_msrt_mcs_alignment(brw, mt, &x_align, &y_align);
+   x_scaledown = x_align / 2;
+   y_scaledown = y_align / 2;
+   rect->x0 = rect->y0 = 0;
+   rect->x1 = ALIGN(mt->logical_width0, x_scaledown) / x_scaledown;
+   rect->y1 = ALIGN(mt->logical_height0, y_scaledown) / y_scaledown;
+}
+
+void
+brw_meta_resolve_color(struct brw_context *brw,
+                       struct intel_mipmap_tree *mt)
+{
+   struct gl_context *ctx = &brw->ctx;
+   GLuint fbo, rbo;
+   struct rect rect;
+
+   _mesa_meta_begin(ctx, MESA_META_ALL);
+
+   _mesa_GenFramebuffers(1, &fbo);
+   rbo = brw_get_rb_for_slice(brw, mt, 0, 0, false);
+
+   _mesa_BindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo);
+   _mesa_FramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER,
+                                 GL_COLOR_ATTACHMENT0,
+                                 GL_RENDERBUFFER, rbo);
+   _mesa_DrawBuffer(GL_COLOR_ATTACHMENT0);
+
+   brw_fast_clear_init(brw);
+
+   use_rectlist(brw, true);
+
+   brw_bind_rep_write_shader(brw, (float *) fast_clear_color);
+
+   set_fast_clear_op(brw, GEN7_PS_RENDER_TARGET_RESOLVE_ENABLE);
+
+   mt->fast_clear_state = INTEL_FAST_CLEAR_STATE_RESOLVED;
+   get_resolve_rect(brw, mt, &rect);
+
+   brw_draw_rectlist(ctx, &rect, 1);
+
+   set_fast_clear_op(brw, 0);
+   use_rectlist(brw, false);
+
+   _mesa_DeleteRenderbuffers(1, &rbo);
+   _mesa_DeleteFramebuffers(1, &fbo);
+
+   _mesa_meta_end(ctx);
+
+   intel_batchbuffer_emit_mi_flush(brw);
+
+   /* We're typically called from intel_update_state() and we're supposed to
+    * return with the state all updated to what it was before
+    * brw_meta_resolve_color() was called.  The meta rendering will have
+    * messed up the state and we need to call _mesa_update_state() again to
+    * get back to where we were supposed to be when resolve was called.
+    */
+   if (ctx->NewState)
+      _mesa_update_state(ctx);
+}