tu: Implement multiview clear/resolve interactions

[mesa.git] / src / freedreno / vulkan / tu_cs.h

diff --git a/src/freedreno/vulkan/tu_cs.h b/src/freedreno/vulkan/tu_cs.h
index f5c331cdd30e9a9adc87ce70f4f697f1e96316dd..77be4319a11a01e0787c7bdae3fa8484fc5a171e 100644 (file)
--- a/src/freedreno/vulkan/tu_cs.h
+++ b/src/freedreno/vulkan/tu_cs.h
@@ -25,7 +25,7 @@
 
 #include "tu_private.h"
 
-#include "registers/adreno_pm4.xml.h"
+#include "adreno_pm4.xml.h"
 
 void
 tu_cs_init(struct tu_cs *cs,
@@ -52,20 +52,67 @@ VkResult
 tu_cs_alloc(struct tu_cs *cs,
             uint32_t count,
             uint32_t size,
-            struct ts_cs_memory *memory);
+            struct tu_cs_memory *memory);
 
 struct tu_cs_entry
 tu_cs_end_sub_stream(struct tu_cs *cs, struct tu_cs *sub_cs);
 
+static inline struct tu_draw_state
+tu_cs_end_draw_state(struct tu_cs *cs, struct tu_cs *sub_cs)
+{
+   struct tu_cs_entry entry = tu_cs_end_sub_stream(cs, sub_cs);
+   return (struct tu_draw_state) {
+      .iova = entry.bo->iova + entry.offset,
+      .size = entry.size / sizeof(uint32_t),
+   };
+}
+
 VkResult
 tu_cs_reserve_space(struct tu_cs *cs, uint32_t reserved_size);
 
+static inline struct tu_draw_state
+tu_cs_draw_state(struct tu_cs *sub_cs, struct tu_cs *cs, uint32_t size)
+{
+   struct tu_cs_memory memory;
+
+   /* TODO: clean this up */
+   tu_cs_alloc(sub_cs, size, 1, &memory);
+   tu_cs_init_external(cs, memory.map, memory.map + size);
+   tu_cs_begin(cs);
+   tu_cs_reserve_space(cs, size);
+
+   return (struct tu_draw_state) {
+      .iova = memory.iova,
+      .size = size,
+   };
+}
+
 void
 tu_cs_reset(struct tu_cs *cs);
 
 VkResult
 tu_cs_add_entries(struct tu_cs *cs, struct tu_cs *target);
 
+/**
+ * Get the size of the command packets emitted since the last call to
+ * tu_cs_add_entry.
+ */
+static inline uint32_t
+tu_cs_get_size(const struct tu_cs *cs)
+{
+   return cs->cur - cs->start;
+}
+
+/**
+ * Return true if there is no command packet emitted since the last call to
+ * tu_cs_add_entry.
+ */
+static inline uint32_t
+tu_cs_is_empty(const struct tu_cs *cs)
+{
+   return tu_cs_get_size(cs) == 0;
+}
+
 /**
  * Discard all entries.  This allows \a cs to be reused while keeping the
  * existing BOs and command packets intact.
@@ -223,6 +270,17 @@ tu_cs_emit_ib(struct tu_cs *cs, const struct tu_cs_entry *entry)
    tu_cs_emit(cs, entry->size / sizeof(uint32_t));
 }
 
+/* for compute which isn't using SET_DRAW_STATE */
+static inline void
+tu_cs_emit_state_ib(struct tu_cs *cs, struct tu_draw_state state)
+{
+   if (state.size) {
+      tu_cs_emit_pkt7(cs, CP_INDIRECT_BUFFER, 3);
+      tu_cs_emit_qw(cs, state.iova);
+      tu_cs_emit(cs, state.size);
+   }
+}
+
 /**
  * Emit a CP_INDIRECT_BUFFER command packet for each entry in the target
  * command stream.
@@ -238,41 +296,34 @@ tu_cs_emit_call(struct tu_cs *cs, const struct tu_cs *target)
 /* Helpers for bracketing a large sequence of commands of unknown size inside
  * a CP_COND_REG_EXEC packet.
  */
-
-struct tu_cond_exec_state {
-   uint32_t *dword_ptr;
-   uint32_t max_dwords;
-};
-
-static inline VkResult
-tu_cond_exec_start(struct tu_device *dev, struct tu_cs *cs,
-                   struct tu_cond_exec_state *state,
-                   uint32_t condition, uint32_t max_dwords)
+static inline void
+tu_cond_exec_start(struct tu_cs *cs, uint32_t cond_flags)
 {
-   /* Reserve enough space so that both the condition packet and the actual
-    * condition will fit in the same IB.
-    */
-   VkResult result = tu_cs_reserve_space(cs, max_dwords + 3);
-   if (result != VK_SUCCESS)
-      return result;
+   assert(cs->mode == TU_CS_MODE_GROW);
+   assert(!cs->cond_flags && cond_flags);
 
-   state->max_dwords = max_dwords;
    tu_cs_emit_pkt7(cs, CP_COND_REG_EXEC, 2);
-   tu_cs_emit(cs, condition);
-   state->dword_ptr = cs->cur;
+   tu_cs_emit(cs, cond_flags);
+
+   cs->cond_flags = cond_flags;
+   cs->cond_dwords = cs->cur;
+
    /* Emit dummy DWORD field here */
    tu_cs_emit(cs, CP_COND_REG_EXEC_1_DWORDS(0));
-
-   return VK_SUCCESS;
 }
+#define CP_COND_EXEC_0_RENDER_MODE_GMEM \
+   (CP_COND_REG_EXEC_0_MODE(RENDER_MODE) | CP_COND_REG_EXEC_0_GMEM)
+#define CP_COND_EXEC_0_RENDER_MODE_SYSMEM \
+   (CP_COND_REG_EXEC_0_MODE(RENDER_MODE) | CP_COND_REG_EXEC_0_SYSMEM)
 
 static inline void
-tu_cond_exec_end(struct tu_cs *cs, struct tu_cond_exec_state *state)
+tu_cond_exec_end(struct tu_cs *cs)
 {
+   assert(cs->cond_flags);
+
+   cs->cond_flags = 0;
    /* Subtract one here to account for the DWORD field itself. */
-   uint32_t actual_dwords = cs->cur - state->dword_ptr - 1;
-   assert(actual_dwords <= state->max_dwords);
-   *state->dword_ptr = actual_dwords;
+   *cs->cond_dwords = cs->cur - cs->cond_dwords - 1;
 }
 
 #define fd_reg_pair tu_reg_value
@@ -328,8 +379,8 @@ tu_cond_exec_end(struct tu_cs *cs, struct tu_cond_exec_state *state)
    STATIC_ASSERT(count > 0);                            \
    STATIC_ASSERT(count <= 16);                          \
                                                         \
-   tu_cs_emit_pkt4(cs, regs[0].reg, count);             \
-   uint32_t *p = cs->cur;                               \
+   tu_cs_emit_pkt4((cs), regs[0].reg, count);             \
+   uint32_t *p = (cs)->cur;                               \
    __ONE_REG( 0, regs);                                 \
    __ONE_REG( 1, regs);                                 \
    __ONE_REG( 2, regs);                                 \
@@ -346,7 +397,7 @@ tu_cond_exec_end(struct tu_cs *cs, struct tu_cond_exec_state *state)
    __ONE_REG(13, regs);                                 \
    __ONE_REG(14, regs);                                 \
    __ONE_REG(15, regs);                                 \
-   cs->cur = p;                                         \
+   (cs)->cur = p;                                         \
    } while (0)
 
 #endif /* TU_CS_H */