i915_state_emit.c revision 305bcda4b583641bab5a7bfa6ce4e30a8559a868
1/************************************************************************** 2 * 3 * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas. 4 * All Rights Reserved. 5 * 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: 13 * 14 * The above copyright notice and this permission notice (including the 15 * next paragraph) shall be included in all copies or substantial portions 16 * of the Software. 17 * 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. 25 * 26 **************************************************************************/ 27 28 29#include "i915_reg.h" 30#include "i915_context.h" 31#include "i915_batch.h" 32#include "i915_debug.h" 33#include "i915_resource.h" 34 35#include "pipe/p_context.h" 36#include "pipe/p_defines.h" 37#include "pipe/p_format.h" 38 39#include "util/u_format.h" 40#include "util/u_math.h" 41#include "util/u_memory.h" 42 43struct i915_tracked_hw_state { 44 const char *name; 45 void (*validate)(struct i915_context *, unsigned *batch_space); 46 void (*emit)(struct i915_context *); 47 unsigned dirty, batch_space; 48}; 49 50 51static void 52validate_flush(struct i915_context *i915, unsigned *batch_space) 53{ 54 *batch_space = i915->flush_dirty ? 1 : 0; 55} 56 57static void 58emit_flush(struct i915_context *i915) 59{ 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 65 * works. */ 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); 70} 71 72uint32_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, 75 76 _3DSTATE_DFLT_DIFFUSE_CMD, 0, 77 78 _3DSTATE_DFLT_SPEC_CMD, 0, 79 80 _3DSTATE_DFLT_Z_CMD, 0, 81 82 _3DSTATE_COORD_SET_BINDINGS | 83 CSB_TCB(0, 0) | 84 CSB_TCB(1, 1) | 85 CSB_TCB(2, 2) | 86 CSB_TCB(3, 3) | 87 CSB_TCB(4, 4) | 88 CSB_TCB(5, 5) | 89 CSB_TCB(6, 6) | 90 CSB_TCB(7, 7), 91 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 | 100 TEXKILL_4D, 101 102 _3DSTATE_DEPTH_SUBRECT_DISABLE, 103 104 /* disable indirect state for now 105 */ 106 _3DSTATE_LOAD_INDIRECT | 0, 0}; 107 108static void 109emit_invariant(struct i915_context *i915) 110{ 111 i915_winsys_batchbuffer_write(i915->batch, invariant_state, 112 Elements(invariant_state)*sizeof(uint32_t)); 113} 114 115static void 116validate_immediate(struct i915_context *i915, unsigned *batch_space) 117{ 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; 123 124 if (i915->immediate_dirty & (1 << I915_IMMEDIATE_S0) && i915->vbo) 125 i915->validation_buffers[i915->num_validation_buffers++] = i915->vbo; 126 127 *batch_space = 1 + util_bitcount(dirty); 128} 129 130static void 131emit_immediate(struct i915_context *i915) 132{ 133 /* remove unwanted 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); 141 142 OUT_BATCH(_3DSTATE_LOAD_STATE_IMMEDIATE_1 | 143 dirty << 4 | (num - 1)); 144 145 if (i915->immediate_dirty & (1 << I915_IMMEDIATE_S0)) { 146 if (i915->vbo) 147 OUT_RELOC(i915->vbo, I915_USAGE_VERTEX, 148 i915->current.immediate[I915_IMMEDIATE_S0]); 149 else 150 OUT_BATCH(0); 151 } 152 153 for (i = 1; i < I915_MAX_IMMEDIATE; i++) { 154 if (dirty & (1 << i)) 155 OUT_BATCH(i915->current.immediate[i]); 156 } 157} 158 159static void 160validate_dynamic(struct i915_context *i915, unsigned *batch_space) 161{ 162 *batch_space = util_bitcount(i915->dynamic_dirty & ((1 << I915_MAX_DYNAMIC) - 1)); 163} 164 165static void 166emit_dynamic(struct i915_context *i915) 167{ 168 int i; 169 for (i = 0; i < I915_MAX_DYNAMIC; i++) { 170 if (i915->dynamic_dirty & (1 << i)) 171 OUT_BATCH(i915->current.dynamic[i]); 172 } 173} 174 175static void 176validate_static(struct i915_context *i915, unsigned *batch_space) 177{ 178 *batch_space = 0; 179 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; 183 *batch_space += 3; 184 } 185 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; 189 *batch_space += 3; 190 } 191 192 if (i915->static_dirty & I915_DST_VARS) 193 *batch_space += 2; 194 195 if (i915->static_dirty & I915_DST_RECT) 196 *batch_space += 5; 197} 198 199static void 200emit_static(struct i915_context *i915) 201{ 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, 206 I915_USAGE_RENDER, 207 0); 208 } 209 210 /* What happens if no zbuf?? 211 */ 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, 216 I915_USAGE_RENDER, 217 0); 218 } 219 220 if (i915->static_dirty & I915_DST_VARS) { 221 OUT_BATCH(_3DSTATE_DST_BUF_VARS_CMD); 222 OUT_BATCH(i915->current.dst_buf_vars); 223 } 224} 225 226static void 227validate_map(struct i915_context *i915, unsigned *batch_space) 228{ 229 const uint enabled = i915->current.sampler_enable_flags; 230 uint unit; 231 struct i915_texture *tex; 232 233 *batch_space = i915->current.sampler_enable_nr ? 234 2 + 3*i915->current.sampler_enable_nr : 0; 235 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; 240 } 241 } 242} 243 244static void 245emit_map(struct i915_context *i915) 246{ 247 const uint nr = i915->current.sampler_enable_nr; 248 if (nr) { 249 const uint enabled = i915->current.sampler_enable_flags; 250 uint unit; 251 uint count = 0; 252 OUT_BATCH(_3DSTATE_MAP_STATE | (3 * nr)); 253 OUT_BATCH(enabled); 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; 258 assert(buf); 259 260 count++; 261 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 */ 265 } 266 } 267 assert(count == nr); 268 } 269} 270 271static void 272validate_sampler(struct i915_context *i915, unsigned *batch_space) 273{ 274 *batch_space = i915->current.sampler_enable_nr ? 275 2 + 3*i915->current.sampler_enable_nr : 0; 276} 277 278static void 279emit_sampler(struct i915_context *i915) 280{ 281 if (i915->current.sampler_enable_nr) { 282 int i; 283 284 OUT_BATCH( _3DSTATE_SAMPLER_STATE | 285 (3 * i915->current.sampler_enable_nr) ); 286 287 OUT_BATCH( i915->current.sampler_enable_flags ); 288 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] ); 294 } 295 } 296 } 297} 298 299static void 300validate_constants(struct i915_context *i915, unsigned *batch_space) 301{ 302 *batch_space = i915->fs->num_constants ? 303 2 + 4*i915->fs->num_constants : 0; 304} 305 306static void 307emit_constants(struct i915_context *i915) 308{ 309 /* Collate the user-defined constants with the fragment shader's 310 * immediates according to the constant_flags[] array. 311 */ 312 const uint nr = i915->fs->num_constants; 313 if (nr) { 314 uint i; 315 316 OUT_BATCH( _3DSTATE_PIXEL_SHADER_CONSTANTS | (nr * 4) ); 317 OUT_BATCH((1 << nr) - 1); 318 319 for (i = 0; i < nr; i++) { 320 const uint *c; 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; 324 c += 4 * i; 325 } 326 else { 327 /* emit program constant */ 328 c = (uint *) i915->fs->constants[i]; 329 } 330#if 0 /* debug */ 331 { 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")); 336 } 337#endif 338 OUT_BATCH(*c++); 339 OUT_BATCH(*c++); 340 OUT_BATCH(*c++); 341 OUT_BATCH(*c++); 342 } 343 } 344} 345 346static void 347validate_program(struct i915_context *i915, unsigned *batch_space) 348{ 349 uint additional_size = i915->current.need_target_fixup; 350 351 /* we need more batch space if we want to emulate rgba framebuffers */ 352 *batch_space = i915->fs->program_len + 3 * additional_size; 353} 354 355static void 356emit_program(struct i915_context *i915) 357{ 358 uint target_fixup = i915->current.need_target_fixup; 359 uint i; 360 361 /* we should always have, at least, a pass-through program */ 362 assert(i915->fs->program_len > 0); 363 364 { 365 /* first word has the size, we have to adjust that */ 366 uint size = (i915->fs->program[0]); 367 size += target_fixup * 3; 368 OUT_BATCH(size); 369 } 370 371 /* output the declarations of the program */ 372 for (i=1 ; i < i915->fs->program_len; i++) 373 OUT_BATCH(i915->fs->program[i]); 374 375 /* we emit an additional mov with swizzle to fake RGBA framebuffers */ 376 if (target_fixup) { 377 /* mov out_color, out_color.zyxw */ 378 OUT_BATCH(A0_MOV | 379 (REG_TYPE_OC << A0_DEST_TYPE_SHIFT) | 380 A0_DEST_CHANNEL_ALL | 381 (REG_TYPE_OC << A0_SRC0_TYPE_SHIFT) | 382 (T_DIFFUSE << A0_SRC0_NR_SHIFT)); 383 OUT_BATCH(i915->current.fixup_swizzle); 384 OUT_BATCH(0); 385 } 386} 387 388static void 389emit_draw_rect(struct i915_context *i915) 390{ 391 if (i915->static_dirty & I915_DST_RECT) { 392 OUT_BATCH(_3DSTATE_DRAW_RECT_CMD); 393 OUT_BATCH(DRAW_RECT_DIS_DEPTH_OFS); 394 OUT_BATCH(i915->current.draw_offset); 395 OUT_BATCH(i915->current.draw_size); 396 OUT_BATCH(i915->current.draw_offset); 397 } 398} 399 400static boolean 401i915_validate_state(struct i915_context *i915, unsigned *batch_space) 402{ 403 unsigned tmp; 404 405 i915->num_validation_buffers = 0; 406 if (i915->hardware_dirty & I915_HW_INVARIANT) 407 *batch_space = Elements(invariant_state); 408 else 409 *batch_space = 0; 410 411#define VALIDATE_ATOM(atom, hw_dirty) \ 412 if (i915->hardware_dirty & hw_dirty) { \ 413 validate_##atom(i915, &tmp); \ 414 *batch_space += tmp; } 415 VALIDATE_ATOM(flush, I915_HW_FLUSH); 416 VALIDATE_ATOM(immediate, I915_HW_IMMEDIATE); 417 VALIDATE_ATOM(dynamic, I915_HW_DYNAMIC); 418 VALIDATE_ATOM(static, I915_HW_STATIC); 419 VALIDATE_ATOM(map, I915_HW_MAP); 420 VALIDATE_ATOM(sampler, I915_HW_SAMPLER); 421 VALIDATE_ATOM(constants, I915_HW_CONSTANTS); 422 VALIDATE_ATOM(program, I915_HW_PROGRAM); 423#undef VALIDATE_ATOM 424 425 if (i915->num_validation_buffers == 0) 426 return TRUE; 427 428 if (!i915_winsys_validate_buffers(i915->batch, i915->validation_buffers, 429 i915->num_validation_buffers)) 430 return FALSE; 431 432 return TRUE; 433} 434 435/* Push the state into the sarea and/or texture memory. 436 */ 437void 438i915_emit_hardware_state(struct i915_context *i915 ) 439{ 440 unsigned batch_space; 441 uintptr_t save_ptr; 442 443 assert(i915->dirty == 0); 444 445 if (I915_DBG_ON(DBG_ATOMS)) 446 i915_dump_hardware_dirty(i915, __FUNCTION__); 447 448 if (!i915_validate_state(i915, &batch_space)) { 449 FLUSH_BATCH(NULL); 450 assert(i915_validate_state(i915, &batch_space)); 451 } 452 453 if(!BEGIN_BATCH(batch_space)) { 454 FLUSH_BATCH(NULL); 455 assert(i915_validate_state(i915, &batch_space)); 456 assert(BEGIN_BATCH(batch_space)); 457 } 458 459 save_ptr = (uintptr_t)i915->batch->ptr; 460 461#define EMIT_ATOM(atom, hw_dirty) \ 462 if (i915->hardware_dirty & hw_dirty) \ 463 emit_##atom(i915); 464 EMIT_ATOM(flush, I915_HW_FLUSH); 465 EMIT_ATOM(invariant, I915_HW_INVARIANT); 466 EMIT_ATOM(immediate, I915_HW_IMMEDIATE); 467 EMIT_ATOM(dynamic, I915_HW_DYNAMIC); 468 EMIT_ATOM(static, I915_HW_STATIC); 469 EMIT_ATOM(map, I915_HW_MAP); 470 EMIT_ATOM(sampler, I915_HW_SAMPLER); 471 EMIT_ATOM(constants, I915_HW_CONSTANTS); 472 EMIT_ATOM(program, I915_HW_PROGRAM); 473 EMIT_ATOM(draw_rect, I915_HW_STATIC); 474#undef EMIT_ATOM 475 476 I915_DBG(DBG_EMIT, "%s: used %d dwords, %d dwords reserved\n", __FUNCTION__, 477 ((uintptr_t)i915->batch->ptr - save_ptr) / 4, 478 batch_space); 479 assert(((uintptr_t)i915->batch->ptr - save_ptr) / 4 == batch_space); 480 481 i915->hardware_dirty = 0; 482 i915->immediate_dirty = 0; 483 i915->dynamic_dirty = 0; 484 i915->static_dirty = 0; 485 i915->flush_dirty = 0; 486} 487