Merge branch 'mesa_7_7_branch'

[mesa.git] / src / mesa / drivers / dri / intel / intel_batchbuffer.h

diff --git a/src/mesa/drivers/dri/intel/intel_batchbuffer.h b/src/mesa/drivers/dri/intel/intel_batchbuffer.h
index 1aa86ae3f074193533bfd2cfcb4e26a9f661360f..b052b724d8425e9140a0a4477b42943aeff965d9 100644 (file)
--- a/src/mesa/drivers/dri/intel/intel_batchbuffer.h
+++ b/src/mesa/drivers/dri/intel/intel_batchbuffer.h
@@ -1,33 +1,37 @@
 #ifndef INTEL_BATCHBUFFER_H
 #define INTEL_BATCHBUFFER_H
 
-#include "mtypes.h"
+#include "main/mtypes.h"
 
-#include "dri_bufmgr.h"
-
-struct intel_context;
+#include "intel_context.h"
+#include "intel_bufmgr.h"
+#include "intel_reg.h"
 
 #define BATCH_SZ 16384
 #define BATCH_RESERVED 16
 
-#define INTEL_BATCH_NO_CLIPRECTS 0x1
-#define INTEL_BATCH_CLIPRECTS    0x2
 
 struct intel_batchbuffer
 {
    struct intel_context *intel;
 
    dri_bo *buf;
-   dri_fence *last_fence;
-   GLuint flags;
+
+   GLubyte *buffer;
 
    GLubyte *map;
    GLubyte *ptr;
 
    GLuint size;
 
+   /** Tracking of BEGIN_BATCH()/OUT_BATCH()/ADVANCE_BATCH() debugging */
+   struct {
+      GLuint total;
+      GLubyte *start_ptr;
+   } emit;
+
    GLuint dirty_state;
-   GLuint id;
+   GLuint reserved_space;
 };
 
 struct intel_batchbuffer *intel_batchbuffer_alloc(struct intel_context
@@ -36,9 +40,11 @@ struct intel_batchbuffer *intel_batchbuffer_alloc(struct intel_context
 void intel_batchbuffer_free(struct intel_batchbuffer *batch);
 
 
-void intel_batchbuffer_finish(struct intel_batchbuffer *batch);
+void _intel_batchbuffer_flush(struct intel_batchbuffer *batch,
+                             const char *file, int line);
 
-void intel_batchbuffer_flush(struct intel_batchbuffer *batch);
+#define intel_batchbuffer_flush(batch) \
+       _intel_batchbuffer_flush(batch, __FILE__, __LINE__)
 
 void intel_batchbuffer_reset(struct intel_batchbuffer *batch);
 
@@ -48,24 +54,27 @@ void intel_batchbuffer_reset(struct intel_batchbuffer *batch);
  * intel_buffer_dword() calls.
  */
 void intel_batchbuffer_data(struct intel_batchbuffer *batch,
-                            const void *data, GLuint bytes, GLuint flags);
+                            const void *data, GLuint bytes);
 
 void intel_batchbuffer_release_space(struct intel_batchbuffer *batch,
                                      GLuint bytes);
 
 GLboolean intel_batchbuffer_emit_reloc(struct intel_batchbuffer *batch,
                                        dri_bo *buffer,
-                                       GLuint flags, GLuint offset);
+                                      uint32_t read_domains,
+                                      uint32_t write_domain,
+                                      uint32_t offset);
+void intel_batchbuffer_emit_mi_flush(struct intel_batchbuffer *batch);
 
 /* Inline functions - might actually be better off with these
  * non-inlined.  Certainly better off switching all command packets to
  * be passed as structs rather than dwords, but that's a little bit of
  * work...
  */
-static INLINE GLuint
+static INLINE GLint
 intel_batchbuffer_space(struct intel_batchbuffer *batch)
 {
-   return (batch->size - BATCH_RESERVED) - (batch->ptr - batch->map);
+   return (batch->size - batch->reserved_space) - (batch->ptr - batch->map);
 }
 
 
@@ -80,32 +89,41 @@ intel_batchbuffer_emit_dword(struct intel_batchbuffer *batch, GLuint dword)
 
 static INLINE void
 intel_batchbuffer_require_space(struct intel_batchbuffer *batch,
-                                GLuint sz, GLuint flags)
+                                GLuint sz)
 {
    assert(sz < batch->size - 8);
-   if (intel_batchbuffer_space(batch) < sz ||
-       (batch->flags != 0 && flags != 0 && batch->flags != flags))
+   if (intel_batchbuffer_space(batch) < sz)
       intel_batchbuffer_flush(batch);
-
-   batch->flags |= flags;
 }
 
 /* Here are the crusty old macros, to be removed:
  */
 #define BATCH_LOCALS
 
-#define BEGIN_BATCH(n, flags) do {                             \
-   intel_batchbuffer_require_space(intel->batch, (n)*4, flags);        \
+#define BEGIN_BATCH(n) do {                            \
+   intel_batchbuffer_require_space(intel->batch, (n)*4); \
+   assert(intel->batch->emit.start_ptr == NULL);                       \
+   intel->batch->emit.total = (n) * 4;                                 \
+   intel->batch->emit.start_ptr = intel->batch->ptr;                   \
 } while (0)
 
-#define OUT_BATCH(d)  intel_batchbuffer_emit_dword(intel->batch, d)
+#define OUT_BATCH(d) intel_batchbuffer_emit_dword(intel->batch, d)
 
-#define OUT_RELOC(buf, flags, delta) do {                              \
-   assert((delta) >= 0);                                               \
-   intel_batchbuffer_emit_reloc(intel->batch, buf, flags, delta);      \
+#define OUT_RELOC(buf, read_domains, write_domain, delta) do {         \
+   assert((unsigned) (delta) < buf->size);                             \
+   intel_batchbuffer_emit_reloc(intel->batch, buf,                     \
+                               read_domains, write_domain, delta);     \
 } while (0)
 
-#define ADVANCE_BATCH() do { } while(0)
-
+#define ADVANCE_BATCH() do {                                           \
+   unsigned int _n = intel->batch->ptr - intel->batch->emit.start_ptr; \
+   assert(intel->batch->emit.start_ptr != NULL);                       \
+   if (_n != intel->batch->emit.total) {                               \
+      fprintf(stderr, "ADVANCE_BATCH: %d of %d dwords emitted\n",      \
+             _n, intel->batch->emit.total);                            \
+      abort();                                                         \
+   }                                                                   \
+   intel->batch->emit.start_ptr = NULL;                                        \
+} while(0)
 
 #endif