src/gallium/drivers/r300/compiler/radeon_code.h

   1 /*
   2  * Copyright 2009 Nicolai Hähnle <nhaehnle@gmail.com>
   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 #ifndef RADEON_CODE_H
  24 #define RADEON_CODE_H
  25
  26 #include <stdint.h>
  27
  28 #define R300_PFS_MAX_ALU_INST     64
  29 #define R300_PFS_MAX_TEX_INST     32
  30 #define R300_PFS_MAX_TEX_INDIRECT 4
  31 #define R300_PFS_NUM_TEMP_REGS    32
  32 #define R300_PFS_NUM_CONST_REGS   32
  33
  34 #define R400_PFS_MAX_ALU_INST     512
  35 #define R400_PFS_MAX_TEX_INST     512
  36
  37 #define R500_PFS_MAX_INST         512
  38 #define R500_PFS_NUM_TEMP_REGS    128
  39 #define R500_PFS_NUM_CONST_REGS   256
  40 #define R500_PFS_MAX_BRANCH_DEPTH_FULL 32
  41 #define R500_PFS_MAX_BRANCH_DEPTH_PARTIAL 4
  42
  43 /* The r500 maximum depth is not just for loops, but any combination of loops
  44  * and subroutine jumps. */
  45 #define R500_PVS_MAX_LOOP_DEPTH 8
  46
  47 #define STATE_R300_WINDOW_DIMENSION (STATE_INTERNAL_DRIVER+0)
  48
  49 enum {
  50         /**
  51          * External constants are constants whose meaning is unknown to this
  52          * compiler. For example, a Mesa gl_program's constants are turned
  53          * into external constants.
  54          */
  55         RC_CONSTANT_EXTERNAL = 0,
  56
  57         RC_CONSTANT_IMMEDIATE,
  58
  59         /**
  60          * Constant referring to state that is known by this compiler,
  61          * see RC_STATE_xxx, i.e. *not* arbitrary Mesa (or other) state.
  62          */
  63         RC_CONSTANT_STATE
  64 };
  65
  66 enum {
  67         RC_STATE_SHADOW_AMBIENT = 0,
  68
  69         RC_STATE_R300_WINDOW_DIMENSION,
  70         RC_STATE_R300_TEXRECT_FACTOR,
  71         RC_STATE_R300_TEXSCALE_FACTOR,
  72         RC_STATE_R300_VIEWPORT_SCALE,
  73         RC_STATE_R300_VIEWPORT_OFFSET
  74 };
  75
  76 struct rc_constant {
  77         unsigned Type:2; /**< RC_CONSTANT_xxx */
  78         unsigned Size:3;
  79
  80         union {
  81                 unsigned External;
  82                 float Immediate[4];
  83                 unsigned State[2];
  84         } u;
  85 };
  86
  87 struct rc_constant_list {
  88         struct rc_constant * Constants;
  89         unsigned Count;
  90
  91         unsigned _Reserved;
  92 };
  93
  94 void rc_constants_init(struct rc_constant_list * c);
  95 void rc_constants_copy(struct rc_constant_list * dst, struct rc_constant_list * src);
  96 void rc_constants_destroy(struct rc_constant_list * c);
  97 unsigned rc_constants_add(struct rc_constant_list * c, struct rc_constant * constant);
  98 unsigned rc_constants_add_state(struct rc_constant_list * c, unsigned state1, unsigned state2);
  99 unsigned rc_constants_add_immediate_vec4(struct rc_constant_list * c, const float * data);
 100 unsigned rc_constants_add_immediate_scalar(struct rc_constant_list * c, float data, unsigned * swizzle);
 101 void rc_constants_print(struct rc_constant_list * c);
 102
 103 /**
 104  * Compare functions.
 105  *
 106  * \note By design, RC_COMPARE_FUNC_xxx + GL_NEVER gives you
 107  * the correct GL compare function.
 108  */
 109 typedef enum {
 110         RC_COMPARE_FUNC_NEVER = 0,
 111         RC_COMPARE_FUNC_LESS,
 112         RC_COMPARE_FUNC_EQUAL,
 113         RC_COMPARE_FUNC_LEQUAL,
 114         RC_COMPARE_FUNC_GREATER,
 115         RC_COMPARE_FUNC_NOTEQUAL,
 116         RC_COMPARE_FUNC_GEQUAL,
 117         RC_COMPARE_FUNC_ALWAYS
 118 } rc_compare_func;
 119
 120 /**
 121  * Coordinate wrapping modes.
 122  *
 123  * These are not quite the same as their GL counterparts yet.
 124  */
 125 typedef enum {
 126         RC_WRAP_NONE = 0,
 127         RC_WRAP_REPEAT,
 128         RC_WRAP_MIRRORED_REPEAT,
 129         RC_WRAP_MIRRORED_CLAMP
 130 } rc_wrap_mode;
 131
 132 /**
 133  * Stores state that influences the compilation of a fragment program.
 134  */
 135 struct r300_fragment_program_external_state {
 136         struct {
 137                 /**
 138                  * This field contains swizzle for some lowering passes
 139                  * (shadow comparison, unorm->snorm conversion)
 140                  */
 141                 unsigned texture_swizzle:12;
 142
 143                 /**
 144                  * If the sampler is used as a shadow sampler,
 145                  * this field specifies the compare function.
 146                  *
 147                  * Otherwise, this field is \ref RC_COMPARE_FUNC_NEVER (aka 0).
 148                  * \sa rc_compare_func
 149                  */
 150                 unsigned texture_compare_func : 3;
 151
 152                 /**
 153                  * No matter what the sampler type is,
 154                  * this field turns it into a shadow sampler.
 155                  */
 156                 unsigned compare_mode_enabled : 1;
 157
 158                 /**
 159                  * If the sampler will receive non-normalized coords,
 160                  * this field is set. The scaling factor is given by
 161                  * RC_STATE_R300_TEXRECT_FACTOR.
 162                  */
 163                 unsigned non_normalized_coords : 1;
 164
 165                 /**
 166                  * This field specifies wrapping modes for the sampler.
 167                  *
 168                  * If this field is \ref RC_WRAP_NONE (aka 0), no wrapping maths
 169                  * will be performed on the coordinates.
 170                  */
 171                 unsigned wrap_mode : 3;
 172
 173                 /**
 174                  * The coords are scaled after applying the wrap mode emulation
 175                  * and right before texture fetch. The scaling factor is given by
 176                  * RC_STATE_R300_TEXSCALE_FACTOR. */
 177                 unsigned clamp_and_scale_before_fetch : 1;
 178         } unit[16];
 179
 180         unsigned alpha_to_one:1;
 181 };
 182
 183
 184
 185 struct r300_fragment_program_node {
 186         int tex_offset; /**< first tex instruction */
 187         int tex_end; /**< last tex instruction, relative to tex_offset */
 188         int alu_offset; /**< first ALU instruction */
 189         int alu_end; /**< last ALU instruction, relative to alu_offset */
 190         int flags;
 191 };
 192
 193 /**
 194  * Stores an R300 fragment program in its compiled-to-hardware form.
 195  */
 196 struct r300_fragment_program_code {
 197         struct {
 198                 unsigned int length; /**< total # of texture instructions used */
 199                 uint32_t inst[R400_PFS_MAX_TEX_INST];
 200         } tex;
 201
 202         struct {
 203                 unsigned int length; /**< total # of ALU instructions used */
 204                 struct {
 205                         uint32_t rgb_inst;
 206                         uint32_t rgb_addr;
 207                         uint32_t alpha_inst;
 208                         uint32_t alpha_addr;
 209                         uint32_t r400_ext_addr;
 210                 } inst[R400_PFS_MAX_ALU_INST];
 211         } alu;
 212
 213         uint32_t config; /* US_CONFIG */
 214         uint32_t pixsize; /* US_PIXSIZE */
 215         uint32_t code_offset; /* US_CODE_OFFSET */
 216         uint32_t r400_code_offset_ext; /* US_CODE_EXT */
 217         uint32_t code_addr[4]; /* US_CODE_ADDR */
 218         /*US_CODE_BANK.R390_MODE: Enables 512 instructions and 64 temporaries
 219          * for r400 cards */
 220         unsigned int r390_mode:1;
 221 };
 222
 223
 224 struct r500_fragment_program_code {
 225         struct {
 226                 uint32_t inst0;
 227                 uint32_t inst1;
 228                 uint32_t inst2;
 229                 uint32_t inst3;
 230                 uint32_t inst4;
 231                 uint32_t inst5;
 232         } inst[R500_PFS_MAX_INST];
 233
 234         int inst_end; /* Number of instructions - 1; also, last instruction to be executed */
 235
 236         int max_temp_idx;
 237
 238         uint32_t us_fc_ctrl;
 239
 240         uint32_t int_constants[32];
 241         uint32_t int_constant_count;
 242 };
 243
 244 struct rX00_fragment_program_code {
 245         union {
 246                 struct r300_fragment_program_code r300;
 247                 struct r500_fragment_program_code r500;
 248         } code;
 249
 250         unsigned writes_depth:1;
 251
 252         struct rc_constant_list constants;
 253         unsigned *constants_remap_table;
 254 };
 255
 256
 257 #define R300_VS_MAX_ALU         256
 258 #define R300_VS_MAX_ALU_DWORDS  (R300_VS_MAX_ALU * 4)
 259 #define R500_VS_MAX_ALU         1024
 260 #define R500_VS_MAX_ALU_DWORDS  (R500_VS_MAX_ALU * 4)
 261 #define R300_VS_MAX_TEMPS       32
 262 /* This is the max for all chipsets (r300-r500) */
 263 #define R300_VS_MAX_FC_OPS 16
 264 #define R300_VS_MAX_LOOP_DEPTH 1
 265
 266 #define VSF_MAX_INPUTS 32
 267 #define VSF_MAX_OUTPUTS 32
 268
 269 struct r300_vertex_program_code {
 270         int length;
 271         union {
 272                 uint32_t d[R500_VS_MAX_ALU_DWORDS];
 273                 float f[R500_VS_MAX_ALU_DWORDS];
 274         } body;
 275
 276         int pos_end;
 277         int num_temporaries;    /* Number of temp vars used by program */
 278         int inputs[VSF_MAX_INPUTS];
 279         int outputs[VSF_MAX_OUTPUTS];
 280
 281         struct rc_constant_list constants;
 282         unsigned *constants_remap_table;
 283
 284         uint32_t InputsRead;
 285         uint32_t OutputsWritten;
 286
 287         unsigned int num_fc_ops;
 288         uint32_t fc_ops;
 289         union {
 290                 uint32_t r300[R300_VS_MAX_FC_OPS];
 291                 struct {
 292                         uint32_t lw;
 293                         uint32_t uw;
 294                 } r500[R300_VS_MAX_FC_OPS];
 295         } fc_op_addrs;
 296         int32_t fc_loop_index[R300_VS_MAX_FC_OPS];
 297 };
 298
 299 #endif /* RADEON_CODE_H */
 300