src/gallium/drivers/radeonsi/si_pm4.c

   1 /*
   2  * Copyright 2012 Advanced Micro Devices, Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * on the rights to use, copy, modify, merge, publish, distribute, sub
   8  * license, and/or sell copies of the Software, and to permit persons to whom
   9  * the Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  18  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  21  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *      Christian König <christian.koenig@amd.com>
  25  */
  26
  27 #include "radeon/r600_cs.h"
  28 #include "util/u_memory.h"
  29 #include "si_pipe.h"
  30 #include "sid.h"
  31
  32 void si_pm4_cmd_begin(struct si_pm4_state *state, unsigned opcode)
  33 {
  34         state->last_opcode = opcode;
  35         state->last_pm4 = state->ndw++;
  36 }
  37
  38 void si_pm4_cmd_add(struct si_pm4_state *state, uint32_t dw)
  39 {
  40         state->pm4[state->ndw++] = dw;
  41 }
  42
  43 void si_pm4_cmd_end(struct si_pm4_state *state, bool predicate)
  44 {
  45         unsigned count;
  46         count = state->ndw - state->last_pm4 - 2;
  47         state->pm4[state->last_pm4] =
  48                 PKT3(state->last_opcode, count, predicate);
  49
  50         assert(state->ndw <= SI_PM4_MAX_DW);
  51 }
  52
  53 void si_pm4_set_reg(struct si_pm4_state *state, unsigned reg, uint32_t val)
  54 {
  55         unsigned opcode;
  56
  57         if (reg >= SI_CONFIG_REG_OFFSET && reg < SI_CONFIG_REG_END) {
  58                 opcode = PKT3_SET_CONFIG_REG;
  59                 reg -= SI_CONFIG_REG_OFFSET;
  60
  61         } else if (reg >= SI_SH_REG_OFFSET && reg < SI_SH_REG_END) {
  62                 opcode = PKT3_SET_SH_REG;
  63                 reg -= SI_SH_REG_OFFSET;
  64
  65         } else if (reg >= SI_CONTEXT_REG_OFFSET && reg < SI_CONTEXT_REG_END) {
  66                 opcode = PKT3_SET_CONTEXT_REG;
  67                 reg -= SI_CONTEXT_REG_OFFSET;
  68
  69         } else if (reg >= CIK_UCONFIG_REG_OFFSET && reg < CIK_UCONFIG_REG_END) {
  70                 opcode = PKT3_SET_UCONFIG_REG;
  71                 reg -= CIK_UCONFIG_REG_OFFSET;
  72
  73         } else {
  74                 R600_ERR("Invalid register offset %08x!\n", reg);
  75                 return;
  76         }
  77
  78         reg >>= 2;
  79
  80         if (opcode != state->last_opcode || reg != (state->last_reg + 1)) {
  81                 si_pm4_cmd_begin(state, opcode);
  82                 si_pm4_cmd_add(state, reg);
  83         }
  84
  85         state->last_reg = reg;
  86         si_pm4_cmd_add(state, val);
  87         si_pm4_cmd_end(state, false);
  88 }
  89
  90 void si_pm4_add_bo(struct si_pm4_state *state,
  91                    struct r600_resource *bo,
  92                    enum radeon_bo_usage usage,
  93                    enum radeon_bo_priority priority)
  94 {
  95         unsigned idx = state->nbo++;
  96         assert(idx < SI_PM4_MAX_BO);
  97
  98         r600_resource_reference(&state->bo[idx], bo);
  99         state->bo_usage[idx] = usage;
 100         state->bo_priority[idx] = priority;
 101 }
 102
 103 void si_pm4_clear_state(struct si_pm4_state *state)
 104 {
 105         for (int i = 0; i < state->nbo; ++i)
 106                 r600_resource_reference(&state->bo[i], NULL);
 107         r600_resource_reference(&state->indirect_buffer, NULL);
 108         state->nbo = 0;
 109         state->ndw = 0;
 110 }
 111
 112 void si_pm4_free_state(struct si_context *sctx,
 113                        struct si_pm4_state *state,
 114                        unsigned idx)
 115 {
 116         if (!state)
 117                 return;
 118
 119         if (idx != ~0 && sctx->emitted.array[idx] == state) {
 120                 sctx->emitted.array[idx] = NULL;
 121         }
 122
 123         si_pm4_clear_state(state);
 124         FREE(state);
 125 }
 126
 127 void si_pm4_emit(struct si_context *sctx, struct si_pm4_state *state)
 128 {
 129         struct radeon_winsys_cs *cs = sctx->b.gfx.cs;
 130
 131         for (int i = 0; i < state->nbo; ++i) {
 132                 radeon_add_to_buffer_list(&sctx->b, &sctx->b.gfx, state->bo[i],
 133                                       state->bo_usage[i], state->bo_priority[i]);
 134         }
 135
 136         if (!state->indirect_buffer) {
 137                 radeon_emit_array(cs, state->pm4, state->ndw);
 138         } else {
 139                 struct r600_resource *ib = state->indirect_buffer;
 140
 141                 radeon_add_to_buffer_list(&sctx->b, &sctx->b.gfx, ib,
 142                                           RADEON_USAGE_READ,
 143                                           RADEON_PRIO_IB2);
 144
 145                 radeon_emit(cs, PKT3(PKT3_INDIRECT_BUFFER_CIK, 2, 0));
 146                 radeon_emit(cs, ib->gpu_address);
 147                 radeon_emit(cs, ib->gpu_address >> 32);
 148                 radeon_emit(cs, (ib->b.b.width0 >> 2) & 0xfffff);
 149         }
 150 }
 151
 152 void si_pm4_reset_emitted(struct si_context *sctx)
 153 {
 154         memset(&sctx->emitted, 0, sizeof(sctx->emitted));
 155         sctx->dirty_states |= u_bit_consecutive(0, SI_NUM_STATES);
 156 }
 157
 158 void si_pm4_upload_indirect_buffer(struct si_context *sctx,
 159                                    struct si_pm4_state *state)
 160 {
 161         struct pipe_screen *screen = sctx->b.b.screen;
 162         unsigned aligned_ndw = align(state->ndw, 8);
 163
 164         /* only supported on CIK and later */
 165         if (sctx->b.chip_class < CIK)
 166                 return;
 167
 168         assert(state->ndw);
 169         assert(aligned_ndw <= SI_PM4_MAX_DW);
 170
 171         r600_resource_reference(&state->indirect_buffer, NULL);
 172         state->indirect_buffer = (struct r600_resource*)
 173                 pipe_buffer_create(screen, 0,
 174                                    PIPE_USAGE_DEFAULT, aligned_ndw * 4);
 175         if (!state->indirect_buffer)
 176                 return;
 177
 178         /* Pad the IB to 8 DWs to meet CP fetch alignment requirements. */
 179         if (sctx->screen->b.info.gfx_ib_pad_with_type2) {
 180                 for (int i = state->ndw; i < aligned_ndw; i++)
 181                         state->pm4[i] = 0x80000000; /* type2 nop packet */
 182         } else {
 183                 for (int i = state->ndw; i < aligned_ndw; i++)
 184                         state->pm4[i] = 0xffff1000; /* type3 nop packet */
 185         }
 186
 187         pipe_buffer_write(&sctx->b.b, &state->indirect_buffer->b.b,
 188                           0, aligned_ndw *4, state->pm4);
 189 }