radeonsi: rename a few R600/r600_ -> SI_/si_

[mesa.git] / src / gallium / drivers / radeonsi / si_cp_dma.c

diff --git a/src/gallium/drivers/radeonsi/si_cp_dma.c b/src/gallium/drivers/radeonsi/si_cp_dma.c
index 7e3d825aca40623c51a07060ac08723bc992d934..ffdb78c3e404f20e60cc7444d5dfaa0666507a6a 100644 (file)
--- a/src/gallium/drivers/radeonsi/si_cp_dma.c
+++ b/src/gallium/drivers/radeonsi/si_cp_dma.c
@@ -61,7 +61,7 @@ static inline unsigned cp_dma_max_byte_count(struct si_context *sctx)
  */
 static void si_emit_cp_dma(struct si_context *sctx, uint64_t dst_va,
                           uint64_t src_va, unsigned size, unsigned flags,
-                          enum r600_coherency coher)
+                          enum si_coherency coher)
 {
        struct radeon_winsys_cs *cs = sctx->b.gfx_cs;
        uint32_t header = 0, command = 0;
@@ -123,31 +123,31 @@ static void si_emit_cp_dma(struct si_context *sctx, uint64_t dst_va,
         * indices. If we wanted to execute CP DMA in PFP, this packet
         * should precede it.
         */
-       if (coher == R600_COHERENCY_SHADER && flags & CP_DMA_SYNC) {
+       if (coher == SI_COHERENCY_SHADER && flags & CP_DMA_SYNC) {
                radeon_emit(cs, PKT3(PKT3_PFP_SYNC_ME, 0, 0));
                radeon_emit(cs, 0);
        }
 }
 
-static unsigned get_flush_flags(struct si_context *sctx, enum r600_coherency coher)
+static unsigned get_flush_flags(struct si_context *sctx, enum si_coherency coher)
 {
        switch (coher) {
        default:
-       case R600_COHERENCY_NONE:
+       case SI_COHERENCY_NONE:
                return 0;
-       case R600_COHERENCY_SHADER:
+       case SI_COHERENCY_SHADER:
                return SI_CONTEXT_INV_SMEM_L1 |
                       SI_CONTEXT_INV_VMEM_L1 |
                       (sctx->b.chip_class == SI ? SI_CONTEXT_INV_GLOBAL_L2 : 0);
-       case R600_COHERENCY_CB_META:
+       case SI_COHERENCY_CB_META:
                return SI_CONTEXT_FLUSH_AND_INV_CB;
        }
 }
 
-static unsigned get_tc_l2_flag(struct si_context *sctx, enum r600_coherency coher)
+static unsigned get_tc_l2_flag(struct si_context *sctx, enum si_coherency coher)
 {
-       if ((sctx->b.chip_class >= GFX9 && coher == R600_COHERENCY_CB_META) ||
-           (sctx->b.chip_class >= CIK && coher == R600_COHERENCY_SHADER))
+       if ((sctx->b.chip_class >= GFX9 && coher == SI_COHERENCY_CB_META) ||
+           (sctx->b.chip_class >= CIK && coher == SI_COHERENCY_SHADER))
                return CP_DMA_USE_L2;
 
        return 0;
@@ -204,11 +204,10 @@ static void si_cp_dma_prepare(struct si_context *sctx, struct pipe_resource *dst
                *packet_flags |= CP_DMA_SYNC;
 }
 
-void si_clear_buffer(struct pipe_context *ctx, struct pipe_resource *dst,
+void si_clear_buffer(struct si_context *sctx, struct pipe_resource *dst,
                     uint64_t offset, uint64_t size, unsigned value,
-                    enum r600_coherency coher)
+                    enum si_coherency coher)
 {
-       struct si_context *sctx = (struct si_context*)ctx;
        struct radeon_winsys *ws = sctx->b.ws;
        struct r600_resource *rdst = r600_resource(dst);
        unsigned tc_l2_flag = get_tc_l2_flag(sctx, coher);
@@ -243,7 +242,7 @@ void si_clear_buffer(struct pipe_context *ctx, struct pipe_resource *dst,
              * of them are moved to SDMA thanks to this. */
             !ws->cs_is_buffer_referenced(sctx->b.gfx_cs, rdst->buf,
                                          RADEON_USAGE_READWRITE))) {
-               sctx->b.dma_clear_buffer(ctx, dst, offset, dma_clear_size, value);
+               sctx->b.dma_clear_buffer(sctx, dst, offset, dma_clear_size, value);
 
                offset += dma_clear_size;
                size -= dma_clear_size;
@@ -275,7 +274,7 @@ void si_clear_buffer(struct pipe_context *ctx, struct pipe_resource *dst,
                        rdst->TC_L2_dirty = true;
 
                /* If it's not a framebuffer fast clear... */
-               if (coher == R600_COHERENCY_SHADER)
+               if (coher == SI_COHERENCY_SHADER)
                        sctx->b.num_cp_dma_calls++;
        }
 
@@ -287,7 +286,7 @@ void si_clear_buffer(struct pipe_context *ctx, struct pipe_resource *dst,
                assert(dst->target == PIPE_BUFFER);
                assert(size < 4);
 
-               pipe_buffer_write(ctx, dst, offset, size, &value);
+               pipe_buffer_write(&sctx->b.b, dst, offset, size, &value);
        }
 }
 
@@ -322,11 +321,11 @@ static void si_pipe_clear_buffer(struct pipe_context *ctx,
                        union pipe_color_union clear_value;
 
                        memcpy(&clear_value, clear_value_ptr, clear_value_size);
-                       si_blitter_begin(ctx, SI_DISABLE_RENDER_COND);
+                       si_blitter_begin(sctx, SI_DISABLE_RENDER_COND);
                        util_blitter_clear_buffer(sctx->blitter, dst, offset,
                                                  size, clear_value_size / 4,
                                                  &clear_value);
-                       si_blitter_end(ctx);
+                       si_blitter_end(sctx);
                        return;
                }
        }
@@ -347,8 +346,8 @@ static void si_pipe_clear_buffer(struct pipe_context *ctx,
                dword_value = *(uint32_t*)clear_value_ptr;
        }
 
-       si_clear_buffer(ctx, dst, offset, size, dword_value,
-                       R600_COHERENCY_SHADER);
+       si_clear_buffer(sctx, dst, offset, size, dword_value,
+                       SI_COHERENCY_SHADER);
 }
 
 /**
@@ -374,7 +373,7 @@ static void si_cp_dma_realign_engine(struct si_context *sctx, unsigned size,
                r600_resource_reference(&sctx->scratch_buffer, NULL);
                sctx->scratch_buffer = (struct r600_resource*)
                        si_aligned_buffer_create(&sctx->screen->b,
-                                                  R600_RESOURCE_FLAG_UNMAPPABLE,
+                                                  SI_RESOURCE_FLAG_UNMAPPABLE,
                                                   PIPE_USAGE_DEFAULT,
                                                   scratch_size, 256);
                if (!sctx->scratch_buffer)
@@ -389,7 +388,7 @@ static void si_cp_dma_realign_engine(struct si_context *sctx, unsigned size,
 
        va = sctx->scratch_buffer->gpu_address;
        si_emit_cp_dma(sctx, va, va + SI_CPDMA_ALIGNMENT, size, dma_flags,
-                      R600_COHERENCY_SHADER);
+                      SI_COHERENCY_SHADER);
 }
 
 /**
@@ -405,8 +404,8 @@ void si_copy_buffer(struct si_context *sctx,
        uint64_t main_dst_offset, main_src_offset;
        unsigned skipped_size = 0;
        unsigned realign_size = 0;
-       unsigned tc_l2_flag = get_tc_l2_flag(sctx, R600_COHERENCY_SHADER);
-       unsigned flush_flags = get_flush_flags(sctx, R600_COHERENCY_SHADER);
+       unsigned tc_l2_flag = get_tc_l2_flag(sctx, SI_COHERENCY_SHADER);
+       unsigned flush_flags = get_flush_flags(sctx, SI_COHERENCY_SHADER);
        bool is_first = true;
 
        if (!size)
@@ -463,7 +462,7 @@ void si_copy_buffer(struct si_context *sctx,
                                  user_flags, &is_first, &dma_flags);
 
                si_emit_cp_dma(sctx, main_dst_offset, main_src_offset,
-                              byte_count, dma_flags, R600_COHERENCY_SHADER);
+                              byte_count, dma_flags, SI_COHERENCY_SHADER);
 
                size -= byte_count;
                main_src_offset += byte_count;
@@ -479,7 +478,7 @@ void si_copy_buffer(struct si_context *sctx,
                                  &is_first, &dma_flags);
 
                si_emit_cp_dma(sctx, dst_offset, src_offset, skipped_size,
-                              dma_flags, R600_COHERENCY_SHADER);
+                              dma_flags, SI_COHERENCY_SHADER);
        }
 
        /* Finally, realign the engine if the size wasn't aligned. */