1 /**************************************************************************
3 * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **************************************************************************/
30 #include "i915_context.h"
31 #include "i915_batch.h"
32 #include "i915_debug.h"
33 #include "i915_resource.h"
35 #include "pipe/p_context.h"
36 #include "pipe/p_defines.h"
37 #include "pipe/p_format.h"
39 #include "util/u_format.h"
40 #include "util/u_math.h"
41 #include "util/u_memory.h"
43 struct i915_tracked_hw_state {
45 void (*validate)(struct i915_context *, unsigned *batch_space);
46 void (*emit)(struct i915_context *);
47 unsigned dirty, batch_space;
52 validate_flush(struct i915_context *i915, unsigned *batch_space)
54 *batch_space = i915->flush_dirty ? 1 : 0;
58 emit_flush(struct i915_context *i915)
60 /* Cache handling is very cheap atm. State handling can request to flushes:
61 * - I915_FLUSH_CACHE which is a flush everything request and
62 * - I915_PIPELINE_FLUSH which is specifically for the draw_offset flush.
63 * Because the cache handling is so dumb, no explicit "invalidate map cache".
64 * Also, the first is a strict superset of the latter, so the following logic
66 if (i915->flush_dirty & I915_FLUSH_CACHE)
67 OUT_BATCH(MI_FLUSH | FLUSH_MAP_CACHE);
68 else if (i915->flush_dirty & I915_PIPELINE_FLUSH)
69 OUT_BATCH(MI_FLUSH | INHIBIT_FLUSH_RENDER_CACHE);
72 uint32_t invariant_state[] = {
73 _3DSTATE_AA_CMD | AA_LINE_ECAAR_WIDTH_ENABLE | AA_LINE_ECAAR_WIDTH_1_0 |
74 AA_LINE_REGION_WIDTH_ENABLE | AA_LINE_REGION_WIDTH_1_0,
76 _3DSTATE_DFLT_DIFFUSE_CMD, 0,
78 _3DSTATE_DFLT_SPEC_CMD, 0,
80 _3DSTATE_DFLT_Z_CMD, 0,
82 _3DSTATE_COORD_SET_BINDINGS |
92 _3DSTATE_RASTER_RULES_CMD |
93 ENABLE_POINT_RASTER_RULE |
94 OGL_POINT_RASTER_RULE |
95 ENABLE_LINE_STRIP_PROVOKE_VRTX |
96 ENABLE_TRI_FAN_PROVOKE_VRTX |
97 LINE_STRIP_PROVOKE_VRTX(1) |
98 TRI_FAN_PROVOKE_VRTX(2) |
99 ENABLE_TEXKILL_3D_4D |
102 _3DSTATE_DEPTH_SUBRECT_DISABLE,
104 /* disable indirect state for now
106 _3DSTATE_LOAD_INDIRECT | 0, 0};
109 emit_invariant(struct i915_context *i915)
111 i915_winsys_batchbuffer_write(i915->batch, invariant_state,
112 Elements(invariant_state)*sizeof(uint32_t));
116 validate_immediate(struct i915_context *i915, unsigned *batch_space)
118 unsigned dirty = (1 << I915_IMMEDIATE_S0 | 1 << I915_IMMEDIATE_S1 |
119 1 << I915_IMMEDIATE_S2 | 1 << I915_IMMEDIATE_S3 |
120 1 << I915_IMMEDIATE_S3 | 1 << I915_IMMEDIATE_S4 |
121 1 << I915_IMMEDIATE_S5 | 1 << I915_IMMEDIATE_S6) &
122 i915->immediate_dirty;
124 if (i915->immediate_dirty & (1 << I915_IMMEDIATE_S0) && i915->vbo)
125 i915->validation_buffers[i915->num_validation_buffers++] = i915->vbo;
127 *batch_space = 1 + util_bitcount(dirty);
131 emit_immediate(struct i915_context *i915)
133 /* remove unwatned bits and S7 */
134 unsigned dirty = (1 << I915_IMMEDIATE_S0 | 1 << I915_IMMEDIATE_S1 |
135 1 << I915_IMMEDIATE_S2 | 1 << I915_IMMEDIATE_S3 |
136 1 << I915_IMMEDIATE_S3 | 1 << I915_IMMEDIATE_S4 |
137 1 << I915_IMMEDIATE_S5 | 1 << I915_IMMEDIATE_S6) &
138 i915->immediate_dirty;
139 int i, num = util_bitcount(dirty);
140 assert(num && num <= I915_MAX_IMMEDIATE);
142 OUT_BATCH(_3DSTATE_LOAD_STATE_IMMEDIATE_1 |
143 dirty << 4 | (num - 1));
145 if (i915->immediate_dirty & (1 << I915_IMMEDIATE_S0)) {
147 OUT_RELOC(i915->vbo, I915_USAGE_VERTEX,
148 i915->current.immediate[I915_IMMEDIATE_S0]);
153 for (i = 1; i < I915_MAX_IMMEDIATE; i++) {
154 if (dirty & (1 << i))
155 OUT_BATCH(i915->current.immediate[i]);
160 validate_dynamic(struct i915_context *i915, unsigned *batch_space)
162 *batch_space = util_bitcount(i915->dynamic_dirty & ((1 << I915_MAX_DYNAMIC) - 1));
166 emit_dynamic(struct i915_context *i915)
169 for (i = 0; i < I915_MAX_DYNAMIC; i++) {
170 if (i915->dynamic_dirty & (1 << i))
171 OUT_BATCH(i915->current.dynamic[i]);
176 validate_static(struct i915_context *i915, unsigned *batch_space)
180 if (i915->current.cbuf_bo && (i915->static_dirty & I915_DST_BUF_COLOR)) {
181 i915->validation_buffers[i915->num_validation_buffers++]
182 = i915->current.cbuf_bo;
186 if (i915->current.depth_bo && (i915->static_dirty & I915_DST_BUF_DEPTH)) {
187 i915->validation_buffers[i915->num_validation_buffers++]
188 = i915->current.depth_bo;
192 if (i915->static_dirty & I915_DST_VARS)
195 if (i915->static_dirty & I915_DST_RECT)
200 emit_static(struct i915_context *i915)
202 if (i915->current.cbuf_bo && (i915->static_dirty & I915_DST_BUF_COLOR)) {
203 OUT_BATCH(_3DSTATE_BUF_INFO_CMD);
204 OUT_BATCH(i915->current.cbuf_flags);
205 OUT_RELOC(i915->current.cbuf_bo,
210 /* What happens if no zbuf??
212 if (i915->current.depth_bo && (i915->static_dirty & I915_DST_BUF_DEPTH)) {
213 OUT_BATCH(_3DSTATE_BUF_INFO_CMD);
214 OUT_BATCH(i915->current.depth_flags);
215 OUT_RELOC(i915->current.depth_bo,
220 if (i915->static_dirty & I915_DST_VARS) {
221 OUT_BATCH(_3DSTATE_DST_BUF_VARS_CMD);
222 OUT_BATCH(i915->current.dst_buf_vars);
227 validate_map(struct i915_context *i915, unsigned *batch_space)
229 const uint enabled = i915->current.sampler_enable_flags;
231 struct i915_texture *tex;
233 *batch_space = i915->current.sampler_enable_nr ?
234 2 + 3*i915->current.sampler_enable_nr : 0;
236 for (unit = 0; unit < I915_TEX_UNITS; unit++) {
237 if (enabled & (1 << unit)) {
238 tex = i915_texture(i915->fragment_sampler_views[unit]->texture);
239 i915->validation_buffers[i915->num_validation_buffers++] = tex->buffer;
245 emit_map(struct i915_context *i915)
247 const uint nr = i915->current.sampler_enable_nr;
249 const uint enabled = i915->current.sampler_enable_flags;
252 OUT_BATCH(_3DSTATE_MAP_STATE | (3 * nr));
254 for (unit = 0; unit < I915_TEX_UNITS; unit++) {
255 if (enabled & (1 << unit)) {
256 struct i915_texture *texture = i915_texture(i915->fragment_sampler_views[unit]->texture);
257 struct i915_winsys_buffer *buf = texture->buffer;
262 OUT_RELOC(buf, I915_USAGE_SAMPLER, 0);
263 OUT_BATCH(i915->current.texbuffer[unit][0]); /* MS3 */
264 OUT_BATCH(i915->current.texbuffer[unit][1]); /* MS4 */
272 validate_sampler(struct i915_context *i915, unsigned *batch_space)
274 *batch_space = i915->current.sampler_enable_nr ?
275 2 + 3*i915->current.sampler_enable_nr : 0;
279 emit_sampler(struct i915_context *i915)
281 if (i915->current.sampler_enable_nr) {
284 OUT_BATCH( _3DSTATE_SAMPLER_STATE |
285 (3 * i915->current.sampler_enable_nr) );
287 OUT_BATCH( i915->current.sampler_enable_flags );
289 for (i = 0; i < I915_TEX_UNITS; i++) {
290 if (i915->current.sampler_enable_flags & (1<<i)) {
291 OUT_BATCH( i915->current.sampler[i][0] );
292 OUT_BATCH( i915->current.sampler[i][1] );
293 OUT_BATCH( i915->current.sampler[i][2] );
300 validate_constants(struct i915_context *i915, unsigned *batch_space)
302 *batch_space = i915->fs->num_constants ?
303 2 + 4*i915->fs->num_constants : 0;
307 emit_constants(struct i915_context *i915)
309 /* Collate the user-defined constants with the fragment shader's
310 * immediates according to the constant_flags[] array.
312 const uint nr = i915->fs->num_constants;
316 OUT_BATCH( _3DSTATE_PIXEL_SHADER_CONSTANTS | (nr * 4) );
317 OUT_BATCH((1 << nr) - 1);
319 for (i = 0; i < nr; i++) {
321 if (i915->fs->constant_flags[i] == I915_CONSTFLAG_USER) {
322 /* grab user-defined constant */
323 c = (uint *) i915_buffer(i915->constants[PIPE_SHADER_FRAGMENT])->data;
327 /* emit program constant */
328 c = (uint *) i915->fs->constants[i];
332 float *f = (float *) c;
333 printf("Const %2d: %f %f %f %f %s\n", i, f[0], f[1], f[2], f[3],
334 (i915->fs->constant_flags[i] == I915_CONSTFLAG_USER
335 ? "user" : "immediate"));
348 enum pipe_format format;
350 } fixup_formats[] = {
351 { PIPE_FORMAT_R8G8B8A8_UNORM, 0x21030000 /* BGRA */},
352 { PIPE_FORMAT_L8_UNORM, 0x00030000 /* RRRA */},
353 { PIPE_FORMAT_I8_UNORM, 0x00030000 /* RRRA */},
354 { PIPE_FORMAT_A8_UNORM, 0x33330000 /* AAAA */},
355 { PIPE_FORMAT_NONE, 0x00000000},
358 static uint need_target_fixup(struct pipe_surface* p)
361 /* if we don't have a surface bound yet, we don't need to fixup the shader */
366 for(int i=0; fixup_formats[i].format != PIPE_FORMAT_NONE; i++)
367 if (fixup_formats[i].format == f)
373 static uint fixup_swizzle(enum pipe_format f)
375 for(int i=0; fixup_formats[i].format != PIPE_FORMAT_NONE; i++)
376 if (fixup_formats[i].format == f)
377 return fixup_formats[i].hw_swizzle;
383 validate_program(struct i915_context *i915, unsigned *batch_space)
385 struct pipe_surface *cbuf_surface = i915->framebuffer.cbufs[0];
386 uint additional_size = need_target_fixup(cbuf_surface);
388 /* we need more batch space if we want to emulate rgba framebuffers */
389 *batch_space = i915->fs->program_len + 3 * additional_size;
393 emit_program(struct i915_context *i915)
395 struct pipe_surface *cbuf_surface = i915->framebuffer.cbufs[0];
396 uint target_fixup = need_target_fixup(cbuf_surface);
399 /* we should always have, at least, a pass-through program */
400 assert(i915->fs->program_len > 0);
403 /* first word has the size, we have to adjust that */
404 uint size = (i915->fs->program[0]);
405 size += target_fixup * 3;
409 /* output the declarations of the program */
410 for (i=1 ; i < i915->fs->program_len; i++)
411 OUT_BATCH(i915->fs->program[i]);
413 /* we emit an additional mov with swizzle to fake RGBA framebuffers */
415 /* mov out_color, out_color.zyxw */
417 (REG_TYPE_OC << A0_DEST_TYPE_SHIFT) |
418 A0_DEST_CHANNEL_ALL |
419 (REG_TYPE_OC << A0_SRC0_TYPE_SHIFT) |
420 (T_DIFFUSE << A0_SRC0_NR_SHIFT));
421 OUT_BATCH(fixup_swizzle(cbuf_surface->format));
427 emit_draw_rect(struct i915_context *i915)
429 if (i915->static_dirty & I915_DST_RECT) {
430 OUT_BATCH(_3DSTATE_DRAW_RECT_CMD);
431 OUT_BATCH(DRAW_RECT_DIS_DEPTH_OFS);
432 OUT_BATCH(i915->current.draw_offset);
433 OUT_BATCH(i915->current.draw_size);
434 OUT_BATCH(i915->current.draw_offset);
439 i915_validate_state(struct i915_context *i915, unsigned *batch_space)
443 i915->num_validation_buffers = 0;
444 if (i915->hardware_dirty & I915_HW_INVARIANT)
445 *batch_space = Elements(invariant_state);
449 #define VALIDATE_ATOM(atom, hw_dirty) \
450 if (i915->hardware_dirty & hw_dirty) { \
451 validate_##atom(i915, &tmp); \
452 *batch_space += tmp; }
453 VALIDATE_ATOM(flush, I915_HW_FLUSH);
454 VALIDATE_ATOM(immediate, I915_HW_IMMEDIATE);
455 VALIDATE_ATOM(dynamic, I915_HW_DYNAMIC);
456 VALIDATE_ATOM(static, I915_HW_STATIC);
457 VALIDATE_ATOM(map, I915_HW_MAP);
458 VALIDATE_ATOM(sampler, I915_HW_SAMPLER);
459 VALIDATE_ATOM(constants, I915_HW_CONSTANTS);
460 VALIDATE_ATOM(program, I915_HW_PROGRAM);
463 if (i915->num_validation_buffers == 0)
466 if (!i915_winsys_validate_buffers(i915->batch, i915->validation_buffers,
467 i915->num_validation_buffers))
473 /* Push the state into the sarea and/or texture memory.
476 i915_emit_hardware_state(struct i915_context *i915 )
478 unsigned batch_space;
481 assert(i915->dirty == 0);
483 if (I915_DBG_ON(DBG_ATOMS))
484 i915_dump_hardware_dirty(i915, __FUNCTION__);
486 if (!i915_validate_state(i915, &batch_space)) {
488 assert(i915_validate_state(i915, &batch_space));
491 if(!BEGIN_BATCH(batch_space)) {
493 assert(i915_validate_state(i915, &batch_space));
494 assert(BEGIN_BATCH(batch_space));
497 save_ptr = (uintptr_t)i915->batch->ptr;
499 #define EMIT_ATOM(atom, hw_dirty) \
500 if (i915->hardware_dirty & hw_dirty) \
502 EMIT_ATOM(flush, I915_HW_FLUSH);
503 EMIT_ATOM(invariant, I915_HW_INVARIANT);
504 EMIT_ATOM(immediate, I915_HW_IMMEDIATE);
505 EMIT_ATOM(dynamic, I915_HW_DYNAMIC);
506 EMIT_ATOM(static, I915_HW_STATIC);
507 EMIT_ATOM(map, I915_HW_MAP);
508 EMIT_ATOM(sampler, I915_HW_SAMPLER);
509 EMIT_ATOM(constants, I915_HW_CONSTANTS);
510 EMIT_ATOM(program, I915_HW_PROGRAM);
511 EMIT_ATOM(draw_rect, I915_HW_STATIC);
514 I915_DBG(DBG_EMIT, "%s: used %d dwords, %d dwords reserved\n", __FUNCTION__,
515 ((uintptr_t)i915->batch->ptr - save_ptr) / 4,
517 assert(((uintptr_t)i915->batch->ptr - save_ptr) / 4 == batch_space);
519 i915->hardware_dirty = 0;
520 i915->immediate_dirty = 0;
521 i915->dynamic_dirty = 0;
522 i915->static_dirty = 0;
523 i915->flush_dirty = 0;