Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
5564 | serge | 1 | /* |
2 | * Copyright 2009 Nicolai Hähnle |
||
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 |
||
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 |