From: Tvrtko Ursulin <[email protected]>

Converting the SDMA v5.2 ring helpers to use the variadic
amdgpu_ring_write().

Signed-off-by: Tvrtko Ursulin <[email protected]>
Cc: Christian König <[email protected]>
Cc: Sunil Khatri <[email protected]>
---
 drivers/gpu/drm/amd/amdgpu/sdma_v5_2.c | 151 +++++++++++++------------
 1 file changed, 80 insertions(+), 71 deletions(-)

diff --git a/drivers/gpu/drm/amd/amdgpu/sdma_v5_2.c 
b/drivers/gpu/drm/amd/amdgpu/sdma_v5_2.c
index 69b88db32117..55c1cc0e03b5 100644
--- a/drivers/gpu/drm/amd/amdgpu/sdma_v5_2.c
+++ b/drivers/gpu/drm/amd/amdgpu/sdma_v5_2.c
@@ -143,10 +143,11 @@ static unsigned sdma_v5_2_ring_init_cond_exec(struct 
amdgpu_ring *ring,
 {
        unsigned ret;
 
-       amdgpu_ring_write(ring, SDMA_PKT_HEADER_OP(SDMA_OP_COND_EXE));
-       amdgpu_ring_write(ring, lower_32_bits(addr));
-       amdgpu_ring_write(ring, upper_32_bits(addr));
-       amdgpu_ring_write(ring, 1);
+       amdgpu_ring_write(ring,
+                         SDMA_PKT_HEADER_OP(SDMA_OP_COND_EXE),
+                         lower_32_bits(addr),
+                         upper_32_bits(addr),
+                         1);
        /* this is the offset we need patch later */
        ret = ring->wptr & ring->buf_mask;
        /* insert dummy here and patch it later */
@@ -278,14 +279,15 @@ static void sdma_v5_2_ring_emit_ib(struct amdgpu_ring 
*ring,
         */
        amdgpu_sdma_ring_insert_nop(ring, (2 - lower_32_bits(ring->wptr)) & 7);
 
-       amdgpu_ring_write(ring, SDMA_PKT_HEADER_OP(SDMA_OP_INDIRECT) |
-                         SDMA_PKT_INDIRECT_HEADER_VMID(vmid & 0xf));
-       /* base must be 32 byte aligned */
-       amdgpu_ring_write(ring, lower_32_bits(ib->gpu_addr) & 0xffffffe0);
-       amdgpu_ring_write(ring, upper_32_bits(ib->gpu_addr));
-       amdgpu_ring_write(ring, ib->length_dw);
-       amdgpu_ring_write(ring, lower_32_bits(csa_mc_addr));
-       amdgpu_ring_write(ring, upper_32_bits(csa_mc_addr));
+       amdgpu_ring_write(ring,
+                         SDMA_PKT_HEADER_OP(SDMA_OP_INDIRECT) |
+                         SDMA_PKT_INDIRECT_HEADER_VMID(vmid & 0xf),
+                         /* base must be 32 byte aligned */
+                         lower_32_bits(ib->gpu_addr) & 0xffffffe0,
+                         upper_32_bits(ib->gpu_addr),
+                         ib->length_dw,
+                         lower_32_bits(csa_mc_addr),
+                         upper_32_bits(csa_mc_addr));
 }
 
 /**
@@ -303,14 +305,15 @@ static void sdma_v5_2_ring_emit_mem_sync(struct 
amdgpu_ring *ring)
                            SDMA_GCR_GLI_INV(1);
 
        /* flush entire cache L0/L1/L2, this can be optimized by performance 
requirement */
-       amdgpu_ring_write(ring, SDMA_PKT_HEADER_OP(SDMA_OP_GCR_REQ));
-       amdgpu_ring_write(ring, SDMA_PKT_GCR_REQ_PAYLOAD1_BASE_VA_31_7(0));
-       amdgpu_ring_write(ring, 
SDMA_PKT_GCR_REQ_PAYLOAD2_GCR_CONTROL_15_0(gcr_cntl) |
-                       SDMA_PKT_GCR_REQ_PAYLOAD2_BASE_VA_47_32(0));
-       amdgpu_ring_write(ring, SDMA_PKT_GCR_REQ_PAYLOAD3_LIMIT_VA_31_7(0) |
-                       SDMA_PKT_GCR_REQ_PAYLOAD3_GCR_CONTROL_18_16(gcr_cntl >> 
16));
-       amdgpu_ring_write(ring, SDMA_PKT_GCR_REQ_PAYLOAD4_LIMIT_VA_47_32(0) |
-                       SDMA_PKT_GCR_REQ_PAYLOAD4_VMID(0));
+       amdgpu_ring_write(ring,
+                         SDMA_PKT_HEADER_OP(SDMA_OP_GCR_REQ),
+                         SDMA_PKT_GCR_REQ_PAYLOAD1_BASE_VA_31_7(0),
+                         SDMA_PKT_GCR_REQ_PAYLOAD2_GCR_CONTROL_15_0(gcr_cntl) |
+                         SDMA_PKT_GCR_REQ_PAYLOAD2_BASE_VA_47_32(0),
+                         SDMA_PKT_GCR_REQ_PAYLOAD3_LIMIT_VA_31_7(0) |
+                         SDMA_PKT_GCR_REQ_PAYLOAD3_GCR_CONTROL_18_16(gcr_cntl 
>> 16),
+                         SDMA_PKT_GCR_REQ_PAYLOAD4_LIMIT_VA_47_32(0) |
+                         SDMA_PKT_GCR_REQ_PAYLOAD4_VMID(0));
 }
 
 /**
@@ -331,14 +334,15 @@ static void sdma_v5_2_ring_emit_hdp_flush(struct 
amdgpu_ring *ring)
        } else {
                ref_and_mask = nbio_hf_reg->ref_and_mask_sdma0 << ring->me;
 
-               amdgpu_ring_write(ring, SDMA_PKT_HEADER_OP(SDMA_OP_POLL_REGMEM) 
|
+               amdgpu_ring_write(ring,
+                                 SDMA_PKT_HEADER_OP(SDMA_OP_POLL_REGMEM) |
                                  SDMA_PKT_POLL_REGMEM_HEADER_HDP_FLUSH(1) |
-                                 SDMA_PKT_POLL_REGMEM_HEADER_FUNC(3)); /* == */
-               amdgpu_ring_write(ring, 
(adev->nbio.funcs->get_hdp_flush_done_offset(adev)) << 2);
-               amdgpu_ring_write(ring, 
(adev->nbio.funcs->get_hdp_flush_req_offset(adev)) << 2);
-               amdgpu_ring_write(ring, ref_and_mask); /* reference */
-               amdgpu_ring_write(ring, ref_and_mask); /* mask */
-               amdgpu_ring_write(ring, 
SDMA_PKT_POLL_REGMEM_DW5_RETRY_COUNT(0xfff) |
+                                 SDMA_PKT_POLL_REGMEM_HEADER_FUNC(3), /* == */
+                                 
adev->nbio.funcs->get_hdp_flush_done_offset(adev) << 2,
+                                 
adev->nbio.funcs->get_hdp_flush_req_offset(adev) << 2,
+                                 ref_and_mask, /* reference */
+                                 ref_and_mask, /* mask */
+                                 SDMA_PKT_POLL_REGMEM_DW5_RETRY_COUNT(0xfff) |
                                  SDMA_PKT_POLL_REGMEM_DW5_INTERVAL(10)); /* 
retry count, poll interval */
        }
 }
@@ -359,33 +363,35 @@ static void sdma_v5_2_ring_emit_fence(struct amdgpu_ring 
*ring, u64 addr, u64 se
                                      unsigned flags)
 {
        bool write64bit = flags & AMDGPU_FENCE_FLAG_64BIT;
-       /* write the fence */
-       amdgpu_ring_write(ring, SDMA_PKT_HEADER_OP(SDMA_OP_FENCE) |
-                         SDMA_PKT_FENCE_HEADER_MTYPE(0x3)); /* Ucached(UC) */
-       /* zero in first two bits */
+
        BUG_ON(addr & 0x3);
-       amdgpu_ring_write(ring, lower_32_bits(addr));
-       amdgpu_ring_write(ring, upper_32_bits(addr));
-       amdgpu_ring_write(ring, lower_32_bits(seq));
+
+       /* write the fence */
+       amdgpu_ring_write(ring,
+                         SDMA_PKT_HEADER_OP(SDMA_OP_FENCE) |
+                         SDMA_PKT_FENCE_HEADER_MTYPE(0x3), /* Ucached(UC) */
+                         lower_32_bits(addr),
+                         upper_32_bits(addr),
+                         lower_32_bits(seq));
 
        /* optionally write high bits as well */
        if (write64bit) {
                addr += 4;
-               amdgpu_ring_write(ring, SDMA_PKT_HEADER_OP(SDMA_OP_FENCE) |
-                                 SDMA_PKT_FENCE_HEADER_MTYPE(0x3));
-               /* zero in first two bits */
-               BUG_ON(addr & 0x3);
-               amdgpu_ring_write(ring, lower_32_bits(addr));
-               amdgpu_ring_write(ring, upper_32_bits(addr));
-               amdgpu_ring_write(ring, upper_32_bits(seq));
+               amdgpu_ring_write(ring,
+                                 SDMA_PKT_HEADER_OP(SDMA_OP_FENCE) |
+                                 SDMA_PKT_FENCE_HEADER_MTYPE(0x3),
+                                 lower_32_bits(addr),
+                                 upper_32_bits(addr),
+                                 upper_32_bits(seq));
        }
 
        if ((flags & AMDGPU_FENCE_FLAG_INT)) {
                uint32_t ctx = ring->is_mes_queue ?
                        (ring->hw_queue_id | AMDGPU_FENCE_MES_QUEUE_FLAG) : 0;
                /* generate an interrupt */
-               amdgpu_ring_write(ring, SDMA_PKT_HEADER_OP(SDMA_OP_TRAP));
-               amdgpu_ring_write(ring, 
SDMA_PKT_TRAP_INT_CONTEXT_INT_CONTEXT(ctx));
+               amdgpu_ring_write(ring,
+                                 SDMA_PKT_HEADER_OP(SDMA_OP_TRAP),
+                                 SDMA_PKT_TRAP_INT_CONTEXT_INT_CONTEXT(ctx));
        }
 }
 
@@ -920,12 +926,13 @@ static int sdma_v5_2_ring_test_ring(struct amdgpu_ring 
*ring)
                return r;
        }
 
-       amdgpu_ring_write(ring, SDMA_PKT_HEADER_OP(SDMA_OP_WRITE) |
-                         SDMA_PKT_HEADER_SUB_OP(SDMA_SUBOP_WRITE_LINEAR));
-       amdgpu_ring_write(ring, lower_32_bits(gpu_addr));
-       amdgpu_ring_write(ring, upper_32_bits(gpu_addr));
-       amdgpu_ring_write(ring, SDMA_PKT_WRITE_UNTILED_DW_3_COUNT(0));
-       amdgpu_ring_write(ring, 0xDEADBEEF);
+       amdgpu_ring_write(ring,
+                         SDMA_PKT_HEADER_OP(SDMA_OP_WRITE) |
+                         SDMA_PKT_HEADER_SUB_OP(SDMA_SUBOP_WRITE_LINEAR),
+                         lower_32_bits(gpu_addr),
+                         upper_32_bits(gpu_addr),
+                         SDMA_PKT_WRITE_UNTILED_DW_3_COUNT(0),
+                         0xDEADBEEF);
        amdgpu_ring_commit(ring);
 
        for (i = 0; i < adev->usec_timeout; i++) {
@@ -1171,15 +1178,16 @@ static void sdma_v5_2_ring_emit_pipeline_sync(struct 
amdgpu_ring *ring)
        uint64_t addr = ring->fence_drv.gpu_addr;
 
        /* wait for idle */
-       amdgpu_ring_write(ring, SDMA_PKT_HEADER_OP(SDMA_OP_POLL_REGMEM) |
+       amdgpu_ring_write(ring,
+                         SDMA_PKT_HEADER_OP(SDMA_OP_POLL_REGMEM) |
                          SDMA_PKT_POLL_REGMEM_HEADER_HDP_FLUSH(0) |
                          SDMA_PKT_POLL_REGMEM_HEADER_FUNC(3) | /* equal */
-                         SDMA_PKT_POLL_REGMEM_HEADER_MEM_POLL(1));
-       amdgpu_ring_write(ring, addr & 0xfffffffc);
-       amdgpu_ring_write(ring, upper_32_bits(addr) & 0xffffffff);
-       amdgpu_ring_write(ring, seq); /* reference */
-       amdgpu_ring_write(ring, 0xffffffff); /* mask */
-       amdgpu_ring_write(ring, SDMA_PKT_POLL_REGMEM_DW5_RETRY_COUNT(0xfff) |
+                         SDMA_PKT_POLL_REGMEM_HEADER_MEM_POLL(1),
+                         addr & 0xfffffffc,
+                         upper_32_bits(addr) & 0xffffffff,
+                         seq, /* reference */
+                         0xffffffff, /* mask */
+                         SDMA_PKT_POLL_REGMEM_DW5_RETRY_COUNT(0xfff) |
                          SDMA_PKT_POLL_REGMEM_DW5_INTERVAL(4)); /* retry 
count, poll interval */
 }
 
@@ -1213,10 +1221,9 @@ static void sdma_v5_2_ring_emit_vm_flush(struct 
amdgpu_ring *ring,
                          
SDMA_PKT_VM_INVALIDATION_HEADER_OP(SDMA_OP_POLL_REGMEM) |
                          
SDMA_PKT_VM_INVALIDATION_HEADER_SUB_OP(SDMA_SUBOP_VM_INVALIDATION) |
                          
SDMA_PKT_VM_INVALIDATION_HEADER_GFX_ENG_ID(ring->vm_inv_eng) |
-                         SDMA_PKT_VM_INVALIDATION_HEADER_MM_ENG_ID(0x1f));
-       amdgpu_ring_write(ring, req);
-       amdgpu_ring_write(ring, 0xFFFFFFFF);
-       amdgpu_ring_write(ring,
+                         SDMA_PKT_VM_INVALIDATION_HEADER_MM_ENG_ID(0x1f),
+                         req,
+                         0xFFFFFFFF,
                          
SDMA_PKT_VM_INVALIDATION_ADDRESSRANGEHI_INVALIDATEACK(1 << vmid) |
                          
SDMA_PKT_VM_INVALIDATION_ADDRESSRANGEHI_ADDRESSRANGEHI(0x1F));
 }
@@ -1224,23 +1231,25 @@ static void sdma_v5_2_ring_emit_vm_flush(struct 
amdgpu_ring *ring,
 static void sdma_v5_2_ring_emit_wreg(struct amdgpu_ring *ring,
                                     uint32_t reg, uint32_t val)
 {
-       amdgpu_ring_write(ring, SDMA_PKT_HEADER_OP(SDMA_OP_SRBM_WRITE) |
-                         SDMA_PKT_SRBM_WRITE_HEADER_BYTE_EN(0xf));
-       amdgpu_ring_write(ring, reg);
-       amdgpu_ring_write(ring, val);
+       amdgpu_ring_write(ring,
+                         SDMA_PKT_HEADER_OP(SDMA_OP_SRBM_WRITE) |
+                         SDMA_PKT_SRBM_WRITE_HEADER_BYTE_EN(0xf),
+                         reg,
+                         val);
 }
 
 static void sdma_v5_2_ring_emit_reg_wait(struct amdgpu_ring *ring, uint32_t 
reg,
                                         uint32_t val, uint32_t mask)
 {
-       amdgpu_ring_write(ring, SDMA_PKT_HEADER_OP(SDMA_OP_POLL_REGMEM) |
+       amdgpu_ring_write(ring,
+                         SDMA_PKT_HEADER_OP(SDMA_OP_POLL_REGMEM) |
                          SDMA_PKT_POLL_REGMEM_HEADER_HDP_FLUSH(0) |
-                         SDMA_PKT_POLL_REGMEM_HEADER_FUNC(3)); /* equal */
-       amdgpu_ring_write(ring, reg << 2);
-       amdgpu_ring_write(ring, 0);
-       amdgpu_ring_write(ring, val); /* reference */
-       amdgpu_ring_write(ring, mask); /* mask */
-       amdgpu_ring_write(ring, SDMA_PKT_POLL_REGMEM_DW5_RETRY_COUNT(0xfff) |
+                         SDMA_PKT_POLL_REGMEM_HEADER_FUNC(3), /* equal */
+                         reg << 2,
+                         0,
+                         val, /* reference */
+                         mask, /* mask */
+                         SDMA_PKT_POLL_REGMEM_DW5_RETRY_COUNT(0xfff) |
                          SDMA_PKT_POLL_REGMEM_DW5_INTERVAL(10));
 }
 
-- 
2.47.1

Reply via email to