src/gallium/drivers/freedreno/a2xx/fd2_program.c

   1 /*
   2  * Copyright (C) 2012 Rob Clark <robclark@freedesktop.org>
   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  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21  * SOFTWARE.
  22  *
  23  * Authors:
  24  *    Rob Clark <robclark@freedesktop.org>
  25  *    Jonathan Marek <jonathan@marek.ca>
  26  */
  27
  28 #include "pipe/p_state.h"
  29 #include "util/u_string.h"
  30 #include "util/u_memory.h"
  31 #include "util/u_inlines.h"
  32 #include "util/format/u_format.h"
  33 #include "tgsi/tgsi_dump.h"
  34 #include "tgsi/tgsi_parse.h"
  35 #include "nir/tgsi_to_nir.h"
  36
  37 #include "freedreno_program.h"
  38
  39 #include "ir2.h"
  40 #include "fd2_program.h"
  41 #include "fd2_texture.h"
  42 #include "fd2_util.h"
  43 #include "instr-a2xx.h"
  44
  45 static struct fd2_shader_stateobj *
  46 create_shader(struct pipe_context *pctx, gl_shader_stage type)
  47 {
  48         struct fd2_shader_stateobj *so = CALLOC_STRUCT(fd2_shader_stateobj);
  49         if (!so)
  50                 return NULL;
  51         so->type = type;
  52         so->is_a20x = is_a20x(fd_context(pctx)->screen);
  53         return so;
  54 }
  55
  56 static void
  57 delete_shader(struct fd2_shader_stateobj *so)
  58 {
  59         if (!so)
  60                 return;
  61         ralloc_free(so->nir);
  62         for (int i = 0; i < ARRAY_SIZE(so->variant); i++)
  63                 free(so->variant[i].info.dwords);
  64         free(so);
  65 }
  66
  67 static void
  68 emit(struct fd_ringbuffer *ring, gl_shader_stage type,
  69         struct ir2_shader_info *info, struct util_dynarray *patches)
  70 {
  71         unsigned i;
  72
  73         assert(info->sizedwords);
  74
  75         OUT_PKT3(ring, CP_IM_LOAD_IMMEDIATE, 2 + info->sizedwords);
  76         OUT_RING(ring, type == MESA_SHADER_FRAGMENT);
  77         OUT_RING(ring, info->sizedwords);
  78
  79         if (patches)
  80                 util_dynarray_append(patches, uint32_t*, &ring->cur[info->mem_export_ptr]);
  81
  82         for (i = 0; i < info->sizedwords; i++)
  83                 OUT_RING(ring, info->dwords[i]);
  84 }
  85
  86 static int
  87 ir2_glsl_type_size(const struct glsl_type *type, bool bindless)
  88 {
  89         return glsl_count_attribute_slots(type, false);
  90 }
  91
  92 static void *
  93 fd2_fp_state_create(struct pipe_context *pctx,
  94                 const struct pipe_shader_state *cso)
  95 {
  96         struct fd2_shader_stateobj *so = create_shader(pctx, MESA_SHADER_FRAGMENT);
  97         if (!so)
  98                 return NULL;
  99
 100         so->nir = (cso->type == PIPE_SHADER_IR_NIR) ? cso->ir.nir :
 101                 tgsi_to_nir(cso->tokens, pctx->screen);
 102
 103         NIR_PASS_V(so->nir, nir_lower_io, nir_var_all, ir2_glsl_type_size,
 104                            (nir_lower_io_options)0);
 105
 106         if (ir2_optimize_nir(so->nir, true))
 107                 goto fail;
 108
 109         so->first_immediate = so->nir->num_uniforms;
 110
 111         ir2_compile(so, 0, NULL);
 112
 113         ralloc_free(so->nir);
 114         so->nir = NULL;
 115         return so;
 116
 117 fail:
 118         delete_shader(so);
 119         return NULL;
 120 }
 121
 122 static void
 123 fd2_fp_state_delete(struct pipe_context *pctx, void *hwcso)
 124 {
 125         struct fd2_shader_stateobj *so = hwcso;
 126         delete_shader(so);
 127 }
 128
 129 static void *
 130 fd2_vp_state_create(struct pipe_context *pctx,
 131                 const struct pipe_shader_state *cso)
 132 {
 133         struct fd2_shader_stateobj *so = create_shader(pctx, MESA_SHADER_VERTEX);
 134         if (!so)
 135                 return NULL;
 136
 137         so->nir = (cso->type == PIPE_SHADER_IR_NIR) ? cso->ir.nir :
 138                 tgsi_to_nir(cso->tokens, pctx->screen);
 139
 140         NIR_PASS_V(so->nir, nir_lower_io, nir_var_all, ir2_glsl_type_size,
 141                            (nir_lower_io_options)0);
 142
 143         if (ir2_optimize_nir(so->nir, true))
 144                 goto fail;
 145
 146         so->first_immediate = so->nir->num_uniforms;
 147
 148         /* compile binning variant now */
 149         ir2_compile(so, 0, NULL);
 150
 151         return so;
 152
 153 fail:
 154         delete_shader(so);
 155         return NULL;
 156 }
 157
 158 static void
 159 fd2_vp_state_delete(struct pipe_context *pctx, void *hwcso)
 160 {
 161         struct fd2_shader_stateobj *so = hwcso;
 162         delete_shader(so);
 163 }
 164
 165 static void
 166 patch_vtx_fetch(struct fd_context *ctx, struct pipe_vertex_element *elem,
 167         instr_fetch_vtx_t *instr, uint16_t dst_swiz)
 168 {
 169         struct surface_format fmt = fd2_pipe2surface(elem->src_format);
 170
 171         instr->dst_swiz = fd2_vtx_swiz(elem->src_format, dst_swiz);
 172         instr->format_comp_all = fmt.sign == SQ_TEX_SIGN_SIGNED;
 173         instr->num_format_all = fmt.num_format;
 174         instr->format = fmt.format;
 175         instr->exp_adjust_all = fmt.exp_adjust;
 176         instr->stride = ctx->vtx.vertexbuf.vb[elem->vertex_buffer_index].stride;
 177         instr->offset = elem->src_offset;
 178 }
 179
 180 static void
 181 patch_fetches(struct fd_context *ctx, struct ir2_shader_info *info,
 182         struct fd_vertex_stateobj *vtx, struct fd_texture_stateobj *tex)
 183 {
 184         for (int i = 0; i < info->num_fetch_instrs; i++) {
 185                 struct ir2_fetch_info *fi = &info->fetch_info[i];
 186
 187                 instr_fetch_t *instr = (instr_fetch_t*) &info->dwords[fi->offset];
 188                 if (instr->opc == VTX_FETCH) {
 189                         unsigned idx = (instr->vtx.const_index - 20) * 3 +
 190                                 instr->vtx.const_index_sel;
 191                         patch_vtx_fetch(ctx, &vtx->pipe[idx], &instr->vtx, fi->vtx.dst_swiz);
 192                         continue;
 193                 }
 194
 195                 assert(instr->opc == TEX_FETCH);
 196                 instr->tex.const_idx = fd2_get_const_idx(ctx, tex, fi->tex.samp_id);
 197                 instr->tex.src_swiz = fi->tex.src_swiz;
 198         }
 199 }
 200
 201 void
 202 fd2_program_emit(struct fd_context *ctx, struct fd_ringbuffer *ring,
 203                 struct fd_program_stateobj *prog)
 204 {
 205         struct fd2_shader_stateobj *fp = NULL, *vp;
 206         struct ir2_shader_info *fpi, *vpi;
 207         struct ir2_frag_linkage *f;
 208         uint8_t vs_gprs, fs_gprs = 0, vs_export = 0;
 209         enum a2xx_sq_ps_vtx_mode mode = POSITION_1_VECTOR;
 210         bool binning = (ctx->batch && ring == ctx->batch->binning);
 211         unsigned variant = 0;
 212
 213         vp = prog->vs;
 214
 215         /* find variant matching the linked fragment shader */
 216         if (!binning) {
 217                 fp = prog->fs;
 218                 for (variant = 1; variant < ARRAY_SIZE(vp->variant); variant++) {
 219                         /* if checked all variants, compile a new variant */
 220                         if (!vp->variant[variant].info.sizedwords) {
 221                                 ir2_compile(vp, variant, fp);
 222                                 break;
 223                         }
 224
 225                         /* check if fragment shader linkage matches */
 226                         if (!memcmp(&vp->variant[variant].f, &fp->variant[0].f,
 227                                         sizeof(struct ir2_frag_linkage)))
 228                                 break;
 229                 }
 230                 assert(variant < ARRAY_SIZE(vp->variant));
 231         }
 232
 233         vpi = &vp->variant[variant].info;
 234         fpi = &fp->variant[0].info;
 235         f = &fp->variant[0].f;
 236
 237         /* clear/gmem2mem/mem2gmem need to be changed to remove this condition */
 238         if (prog != &ctx->solid_prog && prog != &ctx->blit_prog[0]) {
 239                 patch_fetches(ctx, vpi, ctx->vtx.vtx, &ctx->tex[PIPE_SHADER_VERTEX]);
 240                 if (fp)
 241                         patch_fetches(ctx, fpi, NULL, &ctx->tex[PIPE_SHADER_FRAGMENT]);
 242         }
 243
 244         emit(ring, MESA_SHADER_VERTEX, vpi,
 245                 binning ? &ctx->batch->shader_patches : NULL);
 246
 247         if (fp) {
 248                 emit(ring, MESA_SHADER_FRAGMENT, fpi, NULL);
 249                 fs_gprs = (fpi->max_reg < 0) ? 0x80 : fpi->max_reg;
 250                 vs_export = MAX2(1, f->inputs_count) - 1;
 251         }
 252
 253         vs_gprs = (vpi->max_reg < 0) ? 0x80 : vpi->max_reg;
 254
 255         if (vp->writes_psize && !binning)
 256                 mode = POSITION_2_VECTORS_SPRITE;
 257
 258         /* set register to use for param (fragcoord/pointcoord/frontfacing) */
 259         OUT_PKT3(ring, CP_SET_CONSTANT, 2);
 260         OUT_RING(ring, CP_REG(REG_A2XX_SQ_CONTEXT_MISC));
 261         OUT_RING(ring, A2XX_SQ_CONTEXT_MISC_SC_SAMPLE_CNTL(CENTERS_ONLY) |
 262                 COND(fp, A2XX_SQ_CONTEXT_MISC_PARAM_GEN_POS(f->inputs_count)) |
 263                 /* we need SCREEN_XY for both fragcoord and frontfacing */
 264                 A2XX_SQ_CONTEXT_MISC_SC_OUTPUT_SCREEN_XY);
 265
 266         OUT_PKT3(ring, CP_SET_CONSTANT, 2);
 267         OUT_RING(ring, CP_REG(REG_A2XX_SQ_PROGRAM_CNTL));
 268         OUT_RING(ring, A2XX_SQ_PROGRAM_CNTL_PS_EXPORT_MODE(2) |
 269                         A2XX_SQ_PROGRAM_CNTL_VS_EXPORT_MODE(mode) |
 270                         A2XX_SQ_PROGRAM_CNTL_VS_RESOURCE |
 271                         A2XX_SQ_PROGRAM_CNTL_PS_RESOURCE |
 272                         A2XX_SQ_PROGRAM_CNTL_VS_EXPORT_COUNT(vs_export) |
 273                         A2XX_SQ_PROGRAM_CNTL_PS_REGS(fs_gprs) |
 274                         A2XX_SQ_PROGRAM_CNTL_VS_REGS(vs_gprs) |
 275                         COND(fp && fp->need_param, A2XX_SQ_PROGRAM_CNTL_PARAM_GEN) |
 276                         COND(!fp, A2XX_SQ_PROGRAM_CNTL_GEN_INDEX_VTX));
 277 }
 278
 279 void
 280 fd2_prog_init(struct pipe_context *pctx)
 281 {
 282         struct fd_context *ctx = fd_context(pctx);
 283         struct fd_program_stateobj *prog;
 284         struct fd2_shader_stateobj *so;
 285         struct ir2_shader_info *info;
 286         instr_fetch_vtx_t *instr;
 287
 288         pctx->create_fs_state = fd2_fp_state_create;
 289         pctx->delete_fs_state = fd2_fp_state_delete;
 290
 291         pctx->create_vs_state = fd2_vp_state_create;
 292         pctx->delete_vs_state = fd2_vp_state_delete;
 293
 294         fd_prog_init(pctx);
 295
 296         /* XXX maybe its possible to reuse patch_vtx_fetch somehow? */
 297
 298         prog = &ctx->solid_prog;
 299         so = prog->vs;
 300         ir2_compile(prog->vs, 1, prog->fs);
 301
 302 #define IR2_FETCH_SWIZ_XY01 0xb08
 303 #define IR2_FETCH_SWIZ_XYZ1 0xa88
 304
 305         info = &so->variant[1].info;
 306
 307         instr = (instr_fetch_vtx_t*) &info->dwords[info->fetch_info[0].offset];
 308         instr->const_index = 26;
 309         instr->const_index_sel = 0;
 310         instr->format = FMT_32_32_32_FLOAT;
 311         instr->format_comp_all = false;
 312         instr->stride = 12;
 313         instr->num_format_all = true;
 314         instr->dst_swiz = IR2_FETCH_SWIZ_XYZ1;
 315
 316         prog = &ctx->blit_prog[0];
 317         so = prog->vs;
 318         ir2_compile(prog->vs, 1, prog->fs);
 319
 320         info = &so->variant[1].info;
 321
 322         instr = (instr_fetch_vtx_t*) &info->dwords[info->fetch_info[0].offset];
 323         instr->const_index = 26;
 324         instr->const_index_sel = 1;
 325         instr->format = FMT_32_32_FLOAT;
 326         instr->format_comp_all = false;
 327         instr->stride = 8;
 328         instr->num_format_all = false;
 329         instr->dst_swiz = IR2_FETCH_SWIZ_XY01;
 330
 331         instr = (instr_fetch_vtx_t*) &info->dwords[info->fetch_info[1].offset];
 332         instr->const_index = 26;
 333         instr->const_index_sel = 0;
 334         instr->format = FMT_32_32_32_FLOAT;
 335         instr->format_comp_all = false;
 336         instr->stride = 12;
 337         instr->num_format_all = false;
 338         instr->dst_swiz = IR2_FETCH_SWIZ_XYZ1;
 339 }