1 /* 2 * Mesa 3-D graphics library 3 * 4 * Copyright (C) 2014 LunarG, Inc. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the "Software"), 8 * to deal in the Software without restriction, including without limitation 9 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 10 * and/or sell copies of the Software, and to permit persons to whom the 11 * Software is furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included 14 * in all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 22 * DEALINGS IN THE SOFTWARE. 23 * 24 * Authors: 25 * Chia-I Wu <olv (at) lunarg.com> 26 */ 27 28 #ifndef ILO_BUILDER_3D_TOP_H 29 #define ILO_BUILDER_3D_TOP_H 30 31 #include "genhw/genhw.h" 32 #include "intel_winsys.h" 33 34 #include "ilo_core.h" 35 #include "ilo_dev.h" 36 #include "ilo_state_sampler.h" 37 #include "ilo_state_shader.h" 38 #include "ilo_state_sol.h" 39 #include "ilo_state_surface.h" 40 #include "ilo_state_urb.h" 41 #include "ilo_state_vf.h" 42 #include "ilo_vma.h" 43 #include "ilo_builder.h" 44 45 static inline void 46 gen6_3DSTATE_URB(struct ilo_builder *builder, 47 const struct ilo_state_urb *urb) 48 { 49 const uint8_t cmd_len = 3; 50 uint32_t *dw; 51 52 ilo_builder_batch_pointer(builder, cmd_len, &dw); 53 54 dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_URB) | (cmd_len - 2); 55 /* see urb_set_gen6_3DSTATE_URB() */ 56 dw[1] = urb->urb[0]; 57 dw[2] = urb->urb[1]; 58 } 59 60 static inline void 61 gen7_3DSTATE_PUSH_CONSTANT_ALLOC_VS(struct ilo_builder *builder, 62 const struct ilo_state_urb *urb) 63 { 64 const uint8_t cmd_len = 2; 65 uint32_t *dw; 66 67 ilo_builder_batch_pointer(builder, cmd_len, &dw); 68 69 dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_PUSH_CONSTANT_ALLOC_VS) | 70 (cmd_len - 2); 71 /* see urb_set_gen7_3dstate_push_constant_alloc() */ 72 dw[1] = urb->pcb[0]; 73 } 74 75 static inline void 76 gen7_3DSTATE_PUSH_CONSTANT_ALLOC_HS(struct ilo_builder *builder, 77 const struct ilo_state_urb *urb) 78 { 79 const uint8_t cmd_len = 2; 80 uint32_t *dw; 81 82 ilo_builder_batch_pointer(builder, cmd_len, &dw); 83 84 dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_PUSH_CONSTANT_ALLOC_HS) | 85 (cmd_len - 2); 86 /* see urb_set_gen7_3dstate_push_constant_alloc() */ 87 dw[1] = urb->pcb[1]; 88 } 89 90 static inline void 91 gen7_3DSTATE_PUSH_CONSTANT_ALLOC_DS(struct ilo_builder *builder, 92 const struct ilo_state_urb *urb) 93 { 94 const uint8_t cmd_len = 2; 95 uint32_t *dw; 96 97 ilo_builder_batch_pointer(builder, cmd_len, &dw); 98 99 dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_PUSH_CONSTANT_ALLOC_DS) | 100 (cmd_len - 2); 101 /* see urb_set_gen7_3dstate_push_constant_alloc() */ 102 dw[1] = urb->pcb[2]; 103 } 104 105 static inline void 106 gen7_3DSTATE_PUSH_CONSTANT_ALLOC_GS(struct ilo_builder *builder, 107 const struct ilo_state_urb *urb) 108 { 109 const uint8_t cmd_len = 2; 110 uint32_t *dw; 111 112 ilo_builder_batch_pointer(builder, cmd_len, &dw); 113 114 dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_PUSH_CONSTANT_ALLOC_GS) | 115 (cmd_len - 2); 116 /* see urb_set_gen7_3dstate_push_constant_alloc() */ 117 dw[1] = urb->pcb[3]; 118 } 119 120 static inline void 121 gen7_3DSTATE_PUSH_CONSTANT_ALLOC_PS(struct ilo_builder *builder, 122 const struct ilo_state_urb *urb) 123 { 124 const uint8_t cmd_len = 2; 125 uint32_t *dw; 126 127 ilo_builder_batch_pointer(builder, cmd_len, &dw); 128 129 dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_PUSH_CONSTANT_ALLOC_PS) | 130 (cmd_len - 2); 131 /* see urb_set_gen7_3dstate_push_constant_alloc() */ 132 dw[1] = urb->pcb[4]; 133 } 134 135 static inline void 136 gen7_3DSTATE_URB_VS(struct ilo_builder *builder, 137 const struct ilo_state_urb *urb) 138 { 139 const uint8_t cmd_len = 2; 140 uint32_t *dw; 141 142 ilo_builder_batch_pointer(builder, cmd_len, &dw); 143 144 dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_URB_VS) | (cmd_len - 2); 145 /* see urb_set_gen7_3dstate_push_constant_alloc() */ 146 dw[1] = urb->urb[0]; 147 } 148 149 static inline void 150 gen7_3DSTATE_URB_HS(struct ilo_builder *builder, 151 const struct ilo_state_urb *urb) 152 { 153 const uint8_t cmd_len = 2; 154 uint32_t *dw; 155 156 ilo_builder_batch_pointer(builder, cmd_len, &dw); 157 158 dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_URB_HS) | (cmd_len - 2); 159 /* see urb_set_gen7_3dstate_push_constant_alloc() */ 160 dw[1] = urb->urb[1]; 161 } 162 163 static inline void 164 gen7_3DSTATE_URB_DS(struct ilo_builder *builder, 165 const struct ilo_state_urb *urb) 166 { 167 const uint8_t cmd_len = 2; 168 uint32_t *dw; 169 170 ilo_builder_batch_pointer(builder, cmd_len, &dw); 171 172 dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_URB_DS) | (cmd_len - 2); 173 /* see urb_set_gen7_3dstate_push_constant_alloc() */ 174 dw[1] = urb->urb[2]; 175 } 176 177 static inline void 178 gen7_3DSTATE_URB_GS(struct ilo_builder *builder, 179 const struct ilo_state_urb *urb) 180 { 181 const uint8_t cmd_len = 2; 182 uint32_t *dw; 183 184 ilo_builder_batch_pointer(builder, cmd_len, &dw); 185 186 dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_URB_GS) | (cmd_len - 2); 187 /* see urb_set_gen7_3dstate_push_constant_alloc() */ 188 dw[1] = urb->urb[3]; 189 } 190 191 static inline void 192 gen75_3DSTATE_VF(struct ilo_builder *builder, 193 const struct ilo_state_vf *vf) 194 { 195 const uint8_t cmd_len = 2; 196 uint32_t *dw; 197 198 ILO_DEV_ASSERT(builder->dev, 7.5, 8); 199 200 ilo_builder_batch_pointer(builder, cmd_len, &dw); 201 202 /* see vf_params_set_gen75_3DSTATE_VF() */ 203 dw[0] = GEN75_RENDER_CMD(3D, 3DSTATE_VF) | (cmd_len - 2) | 204 vf->cut[0]; 205 dw[1] = vf->cut[1]; 206 } 207 208 static inline void 209 gen6_3DSTATE_VF_STATISTICS(struct ilo_builder *builder, 210 bool enable) 211 { 212 const uint8_t cmd_len = 1; 213 const uint32_t dw0 = GEN6_RENDER_CMD(SINGLE_DW, 3DSTATE_VF_STATISTICS) | 214 enable; 215 216 ILO_DEV_ASSERT(builder->dev, 6, 8); 217 218 ilo_builder_batch_write(builder, cmd_len, &dw0); 219 } 220 221 static inline void 222 gen8_3DSTATE_VF_TOPOLOGY(struct ilo_builder *builder, 223 enum gen_3dprim_type topology) 224 { 225 const uint8_t cmd_len = 2; 226 uint32_t *dw; 227 228 ILO_DEV_ASSERT(builder->dev, 8, 8); 229 230 ilo_builder_batch_pointer(builder, cmd_len, &dw); 231 232 dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_VF_TOPOLOGY) | (cmd_len - 2); 233 dw[1] = topology << GEN8_TOPOLOGY_DW1_TYPE__SHIFT; 234 } 235 236 static inline void 237 gen8_3DSTATE_VF_INSTANCING(struct ilo_builder *builder, 238 const struct ilo_state_vf *vf, 239 uint32_t attr) 240 { 241 const uint8_t cmd_len = 3; 242 uint32_t *dw; 243 244 ILO_DEV_ASSERT(builder->dev, 8, 8); 245 246 ilo_builder_batch_pointer(builder, cmd_len, &dw); 247 248 dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_VF_INSTANCING) | (cmd_len - 2); 249 dw[1] = attr << GEN8_INSTANCING_DW1_VE_INDEX__SHIFT; 250 dw[2] = 0; 251 /* see vf_set_gen8_3DSTATE_VF_INSTANCING() */ 252 if (attr >= vf->internal_ve_count) { 253 attr -= vf->internal_ve_count; 254 255 dw[1] |= vf->user_instancing[attr][0]; 256 dw[2] |= vf->user_instancing[attr][1]; 257 } 258 } 259 260 static inline void 261 gen8_3DSTATE_VF_SGVS(struct ilo_builder *builder, 262 const struct ilo_state_vf *vf) 263 { 264 const uint8_t cmd_len = 2; 265 uint32_t *dw; 266 267 ILO_DEV_ASSERT(builder->dev, 8, 8); 268 269 ilo_builder_batch_pointer(builder, cmd_len, &dw); 270 271 dw[0] = GEN8_RENDER_CMD(3D, 3DSTATE_VF_SGVS) | (cmd_len - 2); 272 /* see vf_params_set_gen8_3DSTATE_VF_SGVS() */ 273 dw[1] = vf->sgvs[0]; 274 } 275 276 static inline void 277 gen6_3DSTATE_VERTEX_BUFFERS(struct ilo_builder *builder, 278 const struct ilo_state_vf *vf, 279 const struct ilo_state_vertex_buffer *vb, 280 unsigned vb_count) 281 { 282 uint8_t cmd_len; 283 uint32_t *dw; 284 unsigned pos, i; 285 286 ILO_DEV_ASSERT(builder->dev, 6, 8); 287 288 /* 289 * From the Sandy Bridge PRM, volume 2 part 1, page 82: 290 * 291 * "From 1 to 33 VBs can be specified..." 292 */ 293 assert(vb_count <= 33); 294 295 if (!vb_count) 296 return; 297 298 cmd_len = 1 + 4 * vb_count; 299 pos = ilo_builder_batch_pointer(builder, cmd_len, &dw); 300 301 dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_VERTEX_BUFFERS) | (cmd_len - 2); 302 dw++; 303 pos++; 304 305 for (i = 0; i < vb_count; i++) { 306 const struct ilo_state_vertex_buffer *b = &vb[i]; 307 308 /* see vertex_buffer_set_gen8_vertex_buffer_state() */ 309 dw[0] = b->vb[0] | 310 i << GEN6_VB_DW0_INDEX__SHIFT; 311 312 if (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) 313 dw[0] |= builder->mocs << GEN8_VB_DW0_MOCS__SHIFT; 314 else 315 dw[0] |= builder->mocs << GEN6_VB_DW0_MOCS__SHIFT; 316 317 dw[1] = 0; 318 dw[2] = 0; 319 dw[3] = 0; 320 321 if (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) { 322 if (b->vma) { 323 ilo_builder_batch_reloc64(builder, pos + 1, b->vma->bo, 324 b->vma->bo_offset + b->vb[1], 0); 325 } 326 327 dw[3] |= b->vb[2]; 328 } else { 329 const int8_t elem = vf->vb_to_first_elem[i]; 330 331 /* see vf_set_gen6_vertex_buffer_state() */ 332 if (elem >= 0) { 333 dw[0] |= vf->user_instancing[elem][0]; 334 dw[3] |= vf->user_instancing[elem][1]; 335 } 336 337 if (b->vma) { 338 ilo_builder_batch_reloc(builder, pos + 1, b->vma->bo, 339 b->vma->bo_offset + b->vb[1], 0); 340 ilo_builder_batch_reloc(builder, pos + 2, b->vma->bo, 341 b->vma->bo_offset + b->vb[2], 0); 342 } 343 } 344 345 dw += 4; 346 pos += 4; 347 } 348 } 349 350 /* the user vertex buffer must be uploaded with gen6_user_vertex_buffer() */ 351 static inline void 352 gen6_user_3DSTATE_VERTEX_BUFFERS(struct ilo_builder *builder, 353 uint32_t vb_begin, uint32_t vb_end, 354 uint32_t stride) 355 { 356 const struct ilo_builder_writer *bat = 357 &builder->writers[ILO_BUILDER_WRITER_BATCH]; 358 const uint8_t cmd_len = 1 + 4; 359 uint32_t *dw; 360 unsigned pos; 361 362 ILO_DEV_ASSERT(builder->dev, 6, 7.5); 363 364 pos = ilo_builder_batch_pointer(builder, cmd_len, &dw); 365 366 dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_VERTEX_BUFFERS) | (cmd_len - 2); 367 dw++; 368 pos++; 369 370 /* VERTEX_BUFFER_STATE */ 371 dw[0] = 0 << GEN6_VB_DW0_INDEX__SHIFT | 372 GEN6_VB_DW0_ACCESS_VERTEXDATA | 373 stride << GEN6_VB_DW0_PITCH__SHIFT; 374 if (ilo_dev_gen(builder->dev) >= ILO_GEN(7)) 375 dw[0] |= GEN7_VB_DW0_ADDR_MODIFIED; 376 377 dw[3] = 0; 378 379 ilo_builder_batch_reloc(builder, pos + 1, bat->bo, vb_begin, 0); 380 ilo_builder_batch_reloc(builder, pos + 2, bat->bo, vb_end, 0); 381 } 382 383 static inline void 384 gen6_3DSTATE_VERTEX_ELEMENTS(struct ilo_builder *builder, 385 const struct ilo_state_vf *vf) 386 { 387 uint8_t cmd_len; 388 uint32_t *dw; 389 390 ILO_DEV_ASSERT(builder->dev, 6, 8); 391 392 cmd_len = 1 + 2 * (vf->internal_ve_count + vf->user_ve_count); 393 394 ilo_builder_batch_pointer(builder, cmd_len, &dw); 395 396 dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_VERTEX_ELEMENTS) | (cmd_len - 2); 397 dw++; 398 399 /* 400 * see vf_params_set_gen6_internal_ve() and 401 * vf_set_gen6_3DSTATE_VERTEX_ELEMENTS() 402 */ 403 if (vf->internal_ve_count) { 404 memcpy(dw, vf->internal_ve, 405 sizeof(vf->internal_ve[0]) * vf->internal_ve_count); 406 dw += 2 * vf->internal_ve_count; 407 } 408 409 memcpy(dw, vf->user_ve, sizeof(vf->user_ve[0]) * vf->user_ve_count); 410 } 411 412 static inline void 413 gen6_3DSTATE_INDEX_BUFFER(struct ilo_builder *builder, 414 const struct ilo_state_vf *vf, 415 const struct ilo_state_index_buffer *ib) 416 { 417 const uint8_t cmd_len = 3; 418 uint32_t dw0, *dw; 419 unsigned pos; 420 421 ILO_DEV_ASSERT(builder->dev, 6, 7.5); 422 423 dw0 = GEN6_RENDER_CMD(3D, 3DSTATE_INDEX_BUFFER) | (cmd_len - 2) | 424 builder->mocs << GEN6_IB_DW0_MOCS__SHIFT; 425 426 /* 427 * see index_buffer_set_gen8_3DSTATE_INDEX_BUFFER() and 428 * vf_params_set_gen6_3dstate_index_buffer() 429 */ 430 dw0 |= ib->ib[0]; 431 if (ilo_dev_gen(builder->dev) <= ILO_GEN(7)) 432 dw0 |= vf->cut[0]; 433 434 pos = ilo_builder_batch_pointer(builder, cmd_len, &dw); 435 436 dw[0] = dw0; 437 if (ib->vma) { 438 ilo_builder_batch_reloc(builder, pos + 1, ib->vma->bo, 439 ib->vma->bo_offset + ib->ib[1], 0); 440 ilo_builder_batch_reloc(builder, pos + 2, ib->vma->bo, 441 ib->vma->bo_offset + ib->ib[2], 0); 442 } else { 443 dw[1] = 0; 444 dw[2] = 0; 445 } 446 } 447 448 static inline void 449 gen8_3DSTATE_INDEX_BUFFER(struct ilo_builder *builder, 450 const struct ilo_state_vf *vf, 451 const struct ilo_state_index_buffer *ib) 452 { 453 const uint8_t cmd_len = 5; 454 uint32_t *dw; 455 unsigned pos; 456 457 ILO_DEV_ASSERT(builder->dev, 8, 8); 458 459 pos = ilo_builder_batch_pointer(builder, cmd_len, &dw); 460 461 dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_INDEX_BUFFER) | (cmd_len - 2); 462 /* see index_buffer_set_gen8_3DSTATE_INDEX_BUFFER() */ 463 dw[1] = ib->ib[0] | 464 builder->mocs << GEN8_IB_DW1_MOCS__SHIFT; 465 466 if (ib->vma) { 467 ilo_builder_batch_reloc64(builder, pos + 2, ib->vma->bo, 468 ib->vma->bo_offset + ib->ib[1], 0); 469 } else { 470 dw[2] = 0; 471 dw[3] = 0; 472 } 473 474 dw[4] = ib->ib[2]; 475 } 476 477 static inline void 478 gen6_3DSTATE_VS(struct ilo_builder *builder, 479 const struct ilo_state_vs *vs, 480 uint32_t kernel_offset, 481 struct intel_bo *scratch_bo) 482 { 483 const uint8_t cmd_len = 6; 484 uint32_t *dw; 485 unsigned pos; 486 487 ILO_DEV_ASSERT(builder->dev, 6, 7.5); 488 489 pos = ilo_builder_batch_pointer(builder, cmd_len, &dw); 490 491 dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_VS) | (cmd_len - 2); 492 dw[1] = kernel_offset; 493 /* see vs_set_gen6_3DSTATE_VS() */ 494 dw[2] = vs->vs[0]; 495 dw[3] = vs->vs[1]; 496 dw[4] = vs->vs[2]; 497 dw[5] = vs->vs[3]; 498 499 if (ilo_state_vs_get_scratch_size(vs)) { 500 ilo_builder_batch_reloc(builder, pos + 3, scratch_bo, 501 vs->vs[1], 0); 502 } 503 } 504 505 static inline void 506 gen8_3DSTATE_VS(struct ilo_builder *builder, 507 const struct ilo_state_vs *vs, 508 uint32_t kernel_offset, 509 struct intel_bo *scratch_bo) 510 { 511 const uint8_t cmd_len = 9; 512 uint32_t *dw; 513 unsigned pos; 514 515 ILO_DEV_ASSERT(builder->dev, 8, 8); 516 517 pos = ilo_builder_batch_pointer(builder, cmd_len, &dw); 518 519 dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_VS) | (cmd_len - 2); 520 dw[1] = kernel_offset; 521 dw[2] = 0; 522 /* see vs_set_gen6_3DSTATE_VS() */ 523 dw[3] = vs->vs[0]; 524 dw[4] = vs->vs[1]; 525 dw[5] = 0; 526 dw[6] = vs->vs[2]; 527 dw[7] = vs->vs[3]; 528 dw[8] = vs->vs[4]; 529 530 if (ilo_state_vs_get_scratch_size(vs)) { 531 ilo_builder_batch_reloc64(builder, pos + 4, scratch_bo, 532 vs->vs[1], 0); 533 } 534 } 535 536 static inline void 537 gen7_3DSTATE_HS(struct ilo_builder *builder, 538 const struct ilo_state_hs *hs, 539 uint32_t kernel_offset, 540 struct intel_bo *scratch_bo) 541 { 542 const uint8_t cmd_len = 7; 543 uint32_t *dw; 544 unsigned pos; 545 546 ILO_DEV_ASSERT(builder->dev, 7, 7.5); 547 548 pos = ilo_builder_batch_pointer(builder, cmd_len, &dw); 549 550 dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_HS) | (cmd_len - 2); 551 /* see hs_set_gen7_3DSTATE_HS() */ 552 dw[1] = hs->hs[0]; 553 dw[2] = hs->hs[1]; 554 dw[3] = kernel_offset; 555 dw[4] = hs->hs[2]; 556 dw[5] = hs->hs[3]; 557 dw[6] = 0; 558 559 if (ilo_state_hs_get_scratch_size(hs)) { 560 ilo_builder_batch_reloc(builder, pos + 4, scratch_bo, 561 hs->hs[2], 0); 562 } 563 } 564 565 static inline void 566 gen8_3DSTATE_HS(struct ilo_builder *builder, 567 const struct ilo_state_hs *hs, 568 uint32_t kernel_offset, 569 struct intel_bo *scratch_bo) 570 { 571 const uint8_t cmd_len = 9; 572 uint32_t *dw; 573 unsigned pos; 574 575 ILO_DEV_ASSERT(builder->dev, 8, 8); 576 577 pos = ilo_builder_batch_pointer(builder, cmd_len, &dw); 578 579 dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_HS) | (cmd_len - 2); 580 /* see hs_set_gen7_3DSTATE_HS() */ 581 dw[1] = hs->hs[0]; 582 dw[2] = hs->hs[1]; 583 dw[3] = kernel_offset; 584 dw[4] = 0; 585 dw[5] = hs->hs[2]; 586 dw[6] = 0; 587 dw[7] = hs->hs[3]; 588 dw[8] = 0; 589 590 if (ilo_state_hs_get_scratch_size(hs)) { 591 ilo_builder_batch_reloc64(builder, pos + 5, scratch_bo, 592 hs->hs[2], 0); 593 } 594 } 595 596 static inline void 597 gen7_3DSTATE_TE(struct ilo_builder *builder, 598 const struct ilo_state_ds *ds) 599 { 600 const uint8_t cmd_len = 4; 601 uint32_t *dw; 602 603 ILO_DEV_ASSERT(builder->dev, 7, 8); 604 605 ilo_builder_batch_pointer(builder, cmd_len, &dw); 606 607 dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_TE) | (cmd_len - 2); 608 /* see ds_set_gen7_3DSTATE_TE() */ 609 dw[1] = ds->te[0]; 610 dw[2] = ds->te[1]; 611 dw[3] = ds->te[2]; 612 } 613 614 static inline void 615 gen7_3DSTATE_DS(struct ilo_builder *builder, 616 const struct ilo_state_ds *ds, 617 uint32_t kernel_offset, 618 struct intel_bo *scratch_bo) 619 { 620 const uint8_t cmd_len = 6; 621 uint32_t *dw; 622 unsigned pos; 623 624 ILO_DEV_ASSERT(builder->dev, 7, 7.5); 625 626 pos = ilo_builder_batch_pointer(builder, cmd_len, &dw); 627 628 dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_DS) | (cmd_len - 2); 629 /* see ds_set_gen7_3DSTATE_DS() */ 630 dw[1] = kernel_offset; 631 dw[2] = ds->ds[0]; 632 dw[3] = ds->ds[1]; 633 dw[4] = ds->ds[2]; 634 dw[5] = ds->ds[3]; 635 636 if (ilo_state_ds_get_scratch_size(ds)) { 637 ilo_builder_batch_reloc(builder, pos + 3, scratch_bo, 638 ds->ds[1], 0); 639 } 640 } 641 642 static inline void 643 gen8_3DSTATE_DS(struct ilo_builder *builder, 644 const struct ilo_state_ds *ds, 645 uint32_t kernel_offset, 646 struct intel_bo *scratch_bo) 647 { 648 const uint8_t cmd_len = 9; 649 uint32_t *dw; 650 unsigned pos; 651 652 ILO_DEV_ASSERT(builder->dev, 8, 8); 653 654 pos = ilo_builder_batch_pointer(builder, cmd_len, &dw); 655 656 dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_DS) | (cmd_len - 2); 657 /* see ds_set_gen7_3DSTATE_DS() */ 658 dw[1] = kernel_offset; 659 dw[2] = 0; 660 dw[3] = ds->ds[0]; 661 dw[4] = ds->ds[1]; 662 dw[5] = 0; 663 dw[6] = ds->ds[2]; 664 dw[7] = ds->ds[3]; 665 dw[8] = ds->ds[4]; 666 667 if (ilo_state_ds_get_scratch_size(ds)) { 668 ilo_builder_batch_reloc64(builder, pos + 4, scratch_bo, 669 ds->ds[1], 0); 670 } 671 } 672 673 static inline void 674 gen6_3DSTATE_GS(struct ilo_builder *builder, 675 const struct ilo_state_gs *gs, 676 uint32_t kernel_offset, 677 struct intel_bo *scratch_bo) 678 { 679 const uint8_t cmd_len = 7; 680 uint32_t *dw; 681 unsigned pos; 682 683 ILO_DEV_ASSERT(builder->dev, 6, 6); 684 685 pos = ilo_builder_batch_pointer(builder, cmd_len, &dw); 686 687 dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_GS) | (cmd_len - 2); 688 dw[1] = kernel_offset; 689 /* see gs_set_gen6_3DSTATE_GS() */ 690 dw[2] = gs->gs[0]; 691 dw[3] = gs->gs[1]; 692 dw[4] = gs->gs[2]; 693 dw[5] = gs->gs[3]; 694 dw[6] = gs->gs[4]; 695 696 if (ilo_state_gs_get_scratch_size(gs)) { 697 ilo_builder_batch_reloc(builder, pos + 3, scratch_bo, 698 gs->gs[1], 0); 699 } 700 } 701 702 static inline void 703 gen6_3DSTATE_GS_SVB_INDEX(struct ilo_builder *builder, 704 int index, unsigned svbi, 705 unsigned max_svbi, 706 bool load_vertex_count) 707 { 708 const uint8_t cmd_len = 4; 709 uint32_t *dw; 710 711 ILO_DEV_ASSERT(builder->dev, 6, 6); 712 assert(index >= 0 && index < 4); 713 714 ilo_builder_batch_pointer(builder, cmd_len, &dw); 715 716 dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_GS_SVB_INDEX) | (cmd_len - 2); 717 718 dw[1] = index << GEN6_SVBI_DW1_INDEX__SHIFT; 719 if (load_vertex_count) 720 dw[1] |= GEN6_SVBI_DW1_LOAD_INTERNAL_VERTEX_COUNT; 721 722 dw[2] = svbi; 723 dw[3] = max_svbi; 724 } 725 726 static inline void 727 gen7_3DSTATE_GS(struct ilo_builder *builder, 728 const struct ilo_state_gs *gs, 729 uint32_t kernel_offset, 730 struct intel_bo *scratch_bo) 731 { 732 const uint8_t cmd_len = 7; 733 uint32_t *dw; 734 unsigned pos; 735 736 ILO_DEV_ASSERT(builder->dev, 7, 7.5); 737 738 pos = ilo_builder_batch_pointer(builder, cmd_len, &dw); 739 740 dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_GS) | (cmd_len - 2); 741 dw[1] = kernel_offset; 742 /* see gs_set_gen7_3DSTATE_GS() */ 743 dw[2] = gs->gs[0]; 744 dw[3] = gs->gs[1]; 745 dw[4] = gs->gs[2]; 746 dw[5] = gs->gs[3]; 747 dw[6] = 0; 748 749 if (ilo_state_gs_get_scratch_size(gs)) { 750 ilo_builder_batch_reloc(builder, pos + 3, scratch_bo, 751 gs->gs[1], 0); 752 } 753 } 754 755 static inline void 756 gen8_3DSTATE_GS(struct ilo_builder *builder, 757 const struct ilo_state_gs *gs, 758 uint32_t kernel_offset, 759 struct intel_bo *scratch_bo) 760 { 761 const uint8_t cmd_len = 10; 762 uint32_t *dw; 763 unsigned pos; 764 765 ILO_DEV_ASSERT(builder->dev, 8, 8); 766 767 pos = ilo_builder_batch_pointer(builder, cmd_len, &dw); 768 769 dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_GS) | (cmd_len - 2); 770 dw[1] = kernel_offset; 771 dw[2] = 0; 772 /* see gs_set_gen7_3DSTATE_GS() */ 773 dw[3] = gs->gs[0]; 774 dw[4] = gs->gs[1]; 775 dw[5] = 0; 776 dw[6] = gs->gs[2]; 777 dw[7] = gs->gs[3]; 778 dw[8] = 0; 779 dw[9] = gs->gs[4]; 780 781 if (ilo_state_gs_get_scratch_size(gs)) { 782 ilo_builder_batch_reloc64(builder, pos + 4, scratch_bo, 783 gs->gs[1], 0); 784 } 785 } 786 787 static inline void 788 gen7_3DSTATE_STREAMOUT(struct ilo_builder *builder, 789 const struct ilo_state_sol *sol) 790 { 791 const uint8_t cmd_len = (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) ? 5 : 3; 792 uint32_t *dw; 793 794 ILO_DEV_ASSERT(builder->dev, 7, 8); 795 796 ilo_builder_batch_pointer(builder, cmd_len, &dw); 797 798 dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_STREAMOUT) | (cmd_len - 2); 799 /* see sol_set_gen7_3DSTATE_STREAMOUT() */ 800 dw[1] = sol->streamout[0]; 801 dw[2] = sol->streamout[1]; 802 if (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) { 803 dw[3] = sol->strides[1] << GEN8_SO_DW3_BUFFER1_PITCH__SHIFT | 804 sol->strides[0] << GEN8_SO_DW3_BUFFER0_PITCH__SHIFT; 805 dw[4] = sol->strides[3] << GEN8_SO_DW4_BUFFER3_PITCH__SHIFT | 806 sol->strides[2] << GEN8_SO_DW4_BUFFER2_PITCH__SHIFT; 807 } 808 } 809 810 static inline void 811 gen7_3DSTATE_SO_DECL_LIST(struct ilo_builder *builder, 812 const struct ilo_state_sol *sol) 813 { 814 /* 815 * Note that "DWord Length" has 9 bits for this command and the type of 816 * cmd_len cannot be uint8_t. 817 */ 818 uint16_t cmd_len; 819 int cmd_decl_count; 820 uint32_t *dw; 821 822 ILO_DEV_ASSERT(builder->dev, 7, 8); 823 824 if (ilo_dev_gen(builder->dev) >= ILO_GEN(7.5)) { 825 cmd_decl_count = sol->decl_count; 826 } else { 827 /* 828 * From the Ivy Bridge PRM, volume 2 part 1, page 201: 829 * 830 * "Errata: All 128 decls for all four streams must be included 831 * whenever this command is issued. The "Num Entries [n]" fields 832 * still contain the actual numbers of valid decls." 833 */ 834 cmd_decl_count = 128; 835 } 836 837 cmd_len = 3 + 2 * cmd_decl_count; 838 839 ilo_builder_batch_pointer(builder, cmd_len, &dw); 840 841 dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_SO_DECL_LIST) | (cmd_len - 2); 842 /* see sol_set_gen7_3DSTATE_SO_DECL_LIST() */ 843 dw[1] = sol->so_decl[0]; 844 dw[2] = sol->so_decl[1]; 845 memcpy(&dw[3], sol->decl, sizeof(sol->decl[0]) * sol->decl_count); 846 847 if (sol->decl_count < cmd_decl_count) { 848 memset(&dw[3 + 2 * sol->decl_count], 0, sizeof(sol->decl[0]) * 849 cmd_decl_count - sol->decl_count); 850 } 851 } 852 853 static inline void 854 gen7_3DSTATE_SO_BUFFER(struct ilo_builder *builder, 855 const struct ilo_state_sol *sol, 856 const struct ilo_state_sol_buffer *sb, 857 uint8_t buffer) 858 { 859 const uint8_t cmd_len = 4; 860 uint32_t *dw; 861 unsigned pos; 862 863 ILO_DEV_ASSERT(builder->dev, 7, 7.5); 864 865 assert(buffer < ILO_STATE_SOL_MAX_BUFFER_COUNT); 866 867 pos = ilo_builder_batch_pointer(builder, cmd_len, &dw); 868 869 dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_SO_BUFFER) | (cmd_len - 2); 870 /* see sol_buffer_set_gen7_3dstate_so_buffer() */ 871 dw[1] = buffer << GEN7_SO_BUF_DW1_INDEX__SHIFT | 872 builder->mocs << GEN7_SO_BUF_DW1_MOCS__SHIFT | 873 sol->strides[buffer] << GEN7_SO_BUF_DW1_PITCH__SHIFT; 874 875 if (sb->vma) { 876 ilo_builder_batch_reloc(builder, pos + 2, sb->vma->bo, 877 sb->vma->bo_offset + sb->so_buf[0], INTEL_RELOC_WRITE); 878 ilo_builder_batch_reloc(builder, pos + 3, sb->vma->bo, 879 sb->vma->bo_offset + sb->so_buf[1], INTEL_RELOC_WRITE); 880 } else { 881 dw[2] = 0; 882 dw[3] = 0; 883 } 884 } 885 886 static inline void 887 gen8_3DSTATE_SO_BUFFER(struct ilo_builder *builder, 888 const struct ilo_state_sol *sol, 889 const struct ilo_state_sol_buffer *sb, 890 uint8_t buffer) 891 { 892 const uint8_t cmd_len = 8; 893 uint32_t *dw; 894 unsigned pos; 895 896 ILO_DEV_ASSERT(builder->dev, 8, 8); 897 898 pos = ilo_builder_batch_pointer(builder, cmd_len, &dw); 899 900 dw[0] = GEN7_RENDER_CMD(3D, 3DSTATE_SO_BUFFER) | (cmd_len - 2); 901 /* see sol_buffer_set_gen8_3dstate_so_buffer() */ 902 dw[1] = sb->so_buf[0] | 903 buffer << GEN7_SO_BUF_DW1_INDEX__SHIFT | 904 builder->mocs << GEN8_SO_BUF_DW1_MOCS__SHIFT; 905 906 if (sb->vma) { 907 ilo_builder_batch_reloc64(builder, pos + 2, sb->vma->bo, 908 sb->vma->bo_offset + sb->so_buf[1], INTEL_RELOC_WRITE); 909 } else { 910 dw[2] = 0; 911 dw[3] = 0; 912 } 913 914 dw[4] = sb->so_buf[2]; 915 916 if (sb->write_offset_vma) { 917 ilo_builder_batch_reloc64(builder, pos + 5, sb->write_offset_vma->bo, 918 sb->write_offset_vma->bo_offset + sizeof(uint32_t) * buffer, 919 INTEL_RELOC_WRITE); 920 } else { 921 dw[5] = 0; 922 dw[6] = 0; 923 } 924 925 dw[7] = sb->so_buf[3]; 926 } 927 928 static inline void 929 gen6_3DSTATE_BINDING_TABLE_POINTERS(struct ilo_builder *builder, 930 uint32_t vs_binding_table, 931 uint32_t gs_binding_table, 932 uint32_t ps_binding_table) 933 { 934 const uint8_t cmd_len = 4; 935 uint32_t *dw; 936 937 ILO_DEV_ASSERT(builder->dev, 6, 6); 938 939 ilo_builder_batch_pointer(builder, cmd_len, &dw); 940 941 dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_BINDING_TABLE_POINTERS) | 942 GEN6_BINDING_TABLE_PTR_DW0_VS_CHANGED | 943 GEN6_BINDING_TABLE_PTR_DW0_GS_CHANGED | 944 GEN6_BINDING_TABLE_PTR_DW0_PS_CHANGED | 945 (cmd_len - 2); 946 dw[1] = vs_binding_table; 947 dw[2] = gs_binding_table; 948 dw[3] = ps_binding_table; 949 } 950 951 static inline void 952 gen6_3DSTATE_SAMPLER_STATE_POINTERS(struct ilo_builder *builder, 953 uint32_t vs_sampler_state, 954 uint32_t gs_sampler_state, 955 uint32_t ps_sampler_state) 956 { 957 const uint8_t cmd_len = 4; 958 uint32_t *dw; 959 960 ILO_DEV_ASSERT(builder->dev, 6, 6); 961 962 ilo_builder_batch_pointer(builder, cmd_len, &dw); 963 964 dw[0] = GEN6_RENDER_CMD(3D, 3DSTATE_SAMPLER_STATE_POINTERS) | 965 GEN6_SAMPLER_PTR_DW0_VS_CHANGED | 966 GEN6_SAMPLER_PTR_DW0_GS_CHANGED | 967 GEN6_SAMPLER_PTR_DW0_PS_CHANGED | 968 (cmd_len - 2); 969 dw[1] = vs_sampler_state; 970 dw[2] = gs_sampler_state; 971 dw[3] = ps_sampler_state; 972 } 973 974 static inline void 975 gen7_3dstate_pointer(struct ilo_builder *builder, 976 int subop, uint32_t pointer) 977 { 978 const uint32_t cmd = GEN6_RENDER_TYPE_RENDER | 979 GEN6_RENDER_SUBTYPE_3D | 980 subop; 981 const uint8_t cmd_len = 2; 982 uint32_t *dw; 983 984 ILO_DEV_ASSERT(builder->dev, 7, 8); 985 986 ilo_builder_batch_pointer(builder, cmd_len, &dw); 987 988 dw[0] = cmd | (cmd_len - 2); 989 dw[1] = pointer; 990 } 991 992 static inline void 993 gen7_3DSTATE_BINDING_TABLE_POINTERS_VS(struct ilo_builder *builder, 994 uint32_t binding_table) 995 { 996 gen7_3dstate_pointer(builder, 997 GEN7_RENDER_OPCODE_3DSTATE_BINDING_TABLE_POINTERS_VS, 998 binding_table); 999 } 1000 1001 static inline void 1002 gen7_3DSTATE_BINDING_TABLE_POINTERS_HS(struct ilo_builder *builder, 1003 uint32_t binding_table) 1004 { 1005 gen7_3dstate_pointer(builder, 1006 GEN7_RENDER_OPCODE_3DSTATE_BINDING_TABLE_POINTERS_HS, 1007 binding_table); 1008 } 1009 1010 static inline void 1011 gen7_3DSTATE_BINDING_TABLE_POINTERS_DS(struct ilo_builder *builder, 1012 uint32_t binding_table) 1013 { 1014 gen7_3dstate_pointer(builder, 1015 GEN7_RENDER_OPCODE_3DSTATE_BINDING_TABLE_POINTERS_DS, 1016 binding_table); 1017 } 1018 1019 static inline void 1020 gen7_3DSTATE_BINDING_TABLE_POINTERS_GS(struct ilo_builder *builder, 1021 uint32_t binding_table) 1022 { 1023 gen7_3dstate_pointer(builder, 1024 GEN7_RENDER_OPCODE_3DSTATE_BINDING_TABLE_POINTERS_GS, 1025 binding_table); 1026 } 1027 1028 static inline void 1029 gen7_3DSTATE_SAMPLER_STATE_POINTERS_VS(struct ilo_builder *builder, 1030 uint32_t sampler_state) 1031 { 1032 gen7_3dstate_pointer(builder, 1033 GEN7_RENDER_OPCODE_3DSTATE_SAMPLER_STATE_POINTERS_VS, 1034 sampler_state); 1035 } 1036 1037 static inline void 1038 gen7_3DSTATE_SAMPLER_STATE_POINTERS_HS(struct ilo_builder *builder, 1039 uint32_t sampler_state) 1040 { 1041 gen7_3dstate_pointer(builder, 1042 GEN7_RENDER_OPCODE_3DSTATE_SAMPLER_STATE_POINTERS_HS, 1043 sampler_state); 1044 } 1045 1046 static inline void 1047 gen7_3DSTATE_SAMPLER_STATE_POINTERS_DS(struct ilo_builder *builder, 1048 uint32_t sampler_state) 1049 { 1050 gen7_3dstate_pointer(builder, 1051 GEN7_RENDER_OPCODE_3DSTATE_SAMPLER_STATE_POINTERS_DS, 1052 sampler_state); 1053 } 1054 1055 static inline void 1056 gen7_3DSTATE_SAMPLER_STATE_POINTERS_GS(struct ilo_builder *builder, 1057 uint32_t sampler_state) 1058 { 1059 gen7_3dstate_pointer(builder, 1060 GEN7_RENDER_OPCODE_3DSTATE_SAMPLER_STATE_POINTERS_GS, 1061 sampler_state); 1062 } 1063 1064 static inline void 1065 gen6_3dstate_constant(struct ilo_builder *builder, int subop, 1066 const uint32_t *bufs, const int *sizes, 1067 int num_bufs) 1068 { 1069 const uint32_t cmd = GEN6_RENDER_TYPE_RENDER | 1070 GEN6_RENDER_SUBTYPE_3D | 1071 subop; 1072 const uint8_t cmd_len = 5; 1073 unsigned buf_enabled = 0x0; 1074 uint32_t buf_dw[4], *dw; 1075 int max_read_length, total_read_length; 1076 int i; 1077 1078 ILO_DEV_ASSERT(builder->dev, 6, 6); 1079 1080 assert(num_bufs <= 4); 1081 1082 /* 1083 * From the Sandy Bridge PRM, volume 2 part 1, page 138: 1084 * 1085 * "(3DSTATE_CONSTANT_VS) The sum of all four read length fields (each 1086 * incremented to represent the actual read length) must be less than 1087 * or equal to 32" 1088 * 1089 * From the Sandy Bridge PRM, volume 2 part 1, page 161: 1090 * 1091 * "(3DSTATE_CONSTANT_GS) The sum of all four read length fields (each 1092 * incremented to represent the actual read length) must be less than 1093 * or equal to 64" 1094 * 1095 * From the Sandy Bridge PRM, volume 2 part 1, page 287: 1096 * 1097 * "(3DSTATE_CONSTANT_PS) The sum of all four read length fields (each 1098 * incremented to represent the actual read length) must be less than 1099 * or equal to 64" 1100 */ 1101 switch (subop) { 1102 case GEN6_RENDER_OPCODE_3DSTATE_CONSTANT_VS: 1103 max_read_length = 32; 1104 break; 1105 case GEN6_RENDER_OPCODE_3DSTATE_CONSTANT_GS: 1106 case GEN6_RENDER_OPCODE_3DSTATE_CONSTANT_PS: 1107 max_read_length = 64; 1108 break; 1109 default: 1110 assert(!"unknown pcb subop"); 1111 max_read_length = 0; 1112 break; 1113 } 1114 1115 total_read_length = 0; 1116 for (i = 0; i < 4; i++) { 1117 if (i < num_bufs && sizes[i]) { 1118 /* in 256-bit units */ 1119 const int read_len = (sizes[i] + 31) / 32; 1120 1121 assert(bufs[i] % 32 == 0); 1122 assert(read_len <= 32); 1123 1124 buf_enabled |= 1 << i; 1125 buf_dw[i] = bufs[i] | (read_len - 1); 1126 1127 total_read_length += read_len; 1128 } else { 1129 buf_dw[i] = 0; 1130 } 1131 } 1132 1133 assert(total_read_length <= max_read_length); 1134 1135 ilo_builder_batch_pointer(builder, cmd_len, &dw); 1136 1137 dw[0] = cmd | (cmd_len - 2) | 1138 buf_enabled << GEN6_CONSTANT_DW0_BUFFER_ENABLES__SHIFT | 1139 builder->mocs << GEN6_CONSTANT_DW0_MOCS__SHIFT; 1140 1141 memcpy(&dw[1], buf_dw, sizeof(buf_dw)); 1142 } 1143 1144 static inline void 1145 gen6_3DSTATE_CONSTANT_VS(struct ilo_builder *builder, 1146 const uint32_t *bufs, const int *sizes, 1147 int num_bufs) 1148 { 1149 gen6_3dstate_constant(builder, GEN6_RENDER_OPCODE_3DSTATE_CONSTANT_VS, 1150 bufs, sizes, num_bufs); 1151 } 1152 1153 static inline void 1154 gen6_3DSTATE_CONSTANT_GS(struct ilo_builder *builder, 1155 const uint32_t *bufs, const int *sizes, 1156 int num_bufs) 1157 { 1158 gen6_3dstate_constant(builder, GEN6_RENDER_OPCODE_3DSTATE_CONSTANT_GS, 1159 bufs, sizes, num_bufs); 1160 } 1161 1162 static inline void 1163 gen7_3dstate_constant(struct ilo_builder *builder, 1164 int subop, 1165 const uint32_t *bufs, const int *sizes, 1166 int num_bufs) 1167 { 1168 const uint32_t cmd = GEN6_RENDER_TYPE_RENDER | 1169 GEN6_RENDER_SUBTYPE_3D | 1170 subop; 1171 const uint8_t cmd_len = (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) ? 11 : 7; 1172 uint32_t payload[6], *dw; 1173 int total_read_length, i; 1174 1175 ILO_DEV_ASSERT(builder->dev, 7, 8); 1176 1177 /* VS, HS, DS, GS, and PS variants */ 1178 assert(subop >= GEN6_RENDER_OPCODE_3DSTATE_CONSTANT_VS && 1179 subop <= GEN7_RENDER_OPCODE_3DSTATE_CONSTANT_DS && 1180 subop != GEN6_RENDER_OPCODE_3DSTATE_SAMPLE_MASK); 1181 1182 assert(num_bufs <= 4); 1183 1184 payload[0] = 0; 1185 payload[1] = 0; 1186 1187 total_read_length = 0; 1188 for (i = 0; i < 4; i++) { 1189 int read_len; 1190 1191 /* 1192 * From the Ivy Bridge PRM, volume 2 part 1, page 112: 1193 * 1194 * "Constant buffers must be enabled in order from Constant Buffer 0 1195 * to Constant Buffer 3 within this command. For example, it is 1196 * not allowed to enable Constant Buffer 1 by programming a 1197 * non-zero value in the VS Constant Buffer 1 Read Length without a 1198 * non-zero value in VS Constant Buffer 0 Read Length." 1199 */ 1200 if (i >= num_bufs || !sizes[i]) { 1201 for (; i < 4; i++) { 1202 assert(i >= num_bufs || !sizes[i]); 1203 payload[2 + i] = 0; 1204 } 1205 break; 1206 } 1207 1208 /* read lengths are in 256-bit units */ 1209 read_len = (sizes[i] + 31) / 32; 1210 /* the lower 5 bits are used for memory object control state */ 1211 assert(bufs[i] % 32 == 0); 1212 1213 payload[i / 2] |= read_len << ((i % 2) ? 16 : 0); 1214 payload[2 + i] = bufs[i]; 1215 1216 total_read_length += read_len; 1217 } 1218 1219 /* 1220 * From the Ivy Bridge PRM, volume 2 part 1, page 113: 1221 * 1222 * "The sum of all four read length fields must be less than or equal 1223 * to the size of 64" 1224 */ 1225 assert(total_read_length <= 64); 1226 1227 ilo_builder_batch_pointer(builder, cmd_len, &dw); 1228 1229 dw[0] = cmd | (cmd_len - 2); 1230 if (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) { 1231 dw[1] = payload[0]; 1232 dw[2] = payload[1]; 1233 dw[3] = payload[2]; 1234 dw[4] = 0; 1235 dw[5] = payload[3]; 1236 dw[6] = 0; 1237 dw[7] = payload[4]; 1238 dw[8] = 0; 1239 dw[9] = payload[5]; 1240 dw[10] = 0; 1241 } else { 1242 payload[2] |= builder->mocs << GEN7_CONSTANT_DW_ADDR_MOCS__SHIFT; 1243 1244 memcpy(&dw[1], payload, sizeof(payload)); 1245 } 1246 } 1247 1248 static inline void 1249 gen7_3DSTATE_CONSTANT_VS(struct ilo_builder *builder, 1250 const uint32_t *bufs, const int *sizes, 1251 int num_bufs) 1252 { 1253 gen7_3dstate_constant(builder, GEN6_RENDER_OPCODE_3DSTATE_CONSTANT_VS, 1254 bufs, sizes, num_bufs); 1255 } 1256 1257 static inline void 1258 gen7_3DSTATE_CONSTANT_HS(struct ilo_builder *builder, 1259 const uint32_t *bufs, const int *sizes, 1260 int num_bufs) 1261 { 1262 gen7_3dstate_constant(builder, GEN7_RENDER_OPCODE_3DSTATE_CONSTANT_HS, 1263 bufs, sizes, num_bufs); 1264 } 1265 1266 static inline void 1267 gen7_3DSTATE_CONSTANT_DS(struct ilo_builder *builder, 1268 const uint32_t *bufs, const int *sizes, 1269 int num_bufs) 1270 { 1271 gen7_3dstate_constant(builder, GEN7_RENDER_OPCODE_3DSTATE_CONSTANT_DS, 1272 bufs, sizes, num_bufs); 1273 } 1274 1275 static inline void 1276 gen7_3DSTATE_CONSTANT_GS(struct ilo_builder *builder, 1277 const uint32_t *bufs, const int *sizes, 1278 int num_bufs) 1279 { 1280 gen7_3dstate_constant(builder, GEN6_RENDER_OPCODE_3DSTATE_CONSTANT_GS, 1281 bufs, sizes, num_bufs); 1282 } 1283 1284 static inline uint32_t 1285 gen6_BINDING_TABLE_STATE(struct ilo_builder *builder, 1286 const uint32_t *surface_states, 1287 int num_surface_states) 1288 { 1289 const int state_align = 32; 1290 const int state_len = num_surface_states; 1291 uint32_t state_offset, *dw; 1292 1293 ILO_DEV_ASSERT(builder->dev, 6, 8); 1294 1295 /* 1296 * From the Sandy Bridge PRM, volume 4 part 1, page 69: 1297 * 1298 * "It is stored as an array of up to 256 elements..." 1299 */ 1300 assert(num_surface_states <= 256); 1301 1302 if (!num_surface_states) 1303 return 0; 1304 1305 state_offset = ilo_builder_surface_pointer(builder, 1306 ILO_BUILDER_ITEM_BINDING_TABLE, state_align, state_len, &dw); 1307 memcpy(dw, surface_states, state_len << 2); 1308 1309 return state_offset; 1310 } 1311 1312 static inline uint32_t 1313 gen6_SURFACE_STATE(struct ilo_builder *builder, 1314 const struct ilo_state_surface *surf) 1315 { 1316 int state_align, state_len; 1317 uint32_t state_offset, *dw; 1318 1319 ILO_DEV_ASSERT(builder->dev, 6, 8); 1320 1321 if (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) { 1322 state_align = 64; 1323 state_len = 13; 1324 1325 state_offset = ilo_builder_surface_pointer(builder, 1326 ILO_BUILDER_ITEM_SURFACE, state_align, state_len, &dw); 1327 memcpy(dw, surf->surface, state_len << 2); 1328 1329 if (surf->vma) { 1330 const uint32_t mocs = (surf->scanout) ? 1331 (GEN8_MOCS_MT_PTE | GEN8_MOCS_CT_L3) : builder->mocs; 1332 1333 dw[1] |= mocs << GEN8_SURFACE_DW1_MOCS__SHIFT; 1334 1335 ilo_builder_surface_reloc64(builder, state_offset, 8, surf->vma->bo, 1336 surf->vma->bo_offset + surf->surface[8], 1337 (surf->readonly) ? 0 : INTEL_RELOC_WRITE); 1338 } 1339 } else { 1340 state_align = 32; 1341 state_len = (ilo_dev_gen(builder->dev) >= ILO_GEN(7)) ? 8 : 6; 1342 1343 state_offset = ilo_builder_surface_pointer(builder, 1344 ILO_BUILDER_ITEM_SURFACE, state_align, state_len, &dw); 1345 memcpy(dw, surf->surface, state_len << 2); 1346 1347 if (surf->vma) { 1348 /* 1349 * For scanouts, we should not enable caching in LLC. Since we only 1350 * enable that on Gen8+, we are fine here. 1351 */ 1352 dw[5] |= builder->mocs << GEN6_SURFACE_DW5_MOCS__SHIFT; 1353 1354 ilo_builder_surface_reloc(builder, state_offset, 1, surf->vma->bo, 1355 surf->vma->bo_offset + surf->surface[1], 1356 (surf->readonly) ? 0 : INTEL_RELOC_WRITE); 1357 } 1358 } 1359 1360 return state_offset; 1361 } 1362 1363 static inline uint32_t 1364 gen6_SAMPLER_STATE(struct ilo_builder *builder, 1365 const struct ilo_state_sampler *samplers, 1366 const uint32_t *sampler_border_colors, 1367 int sampler_count) 1368 { 1369 const int state_align = 32; 1370 const int state_len = 4 * sampler_count; 1371 uint32_t state_offset, *dw; 1372 int i; 1373 1374 ILO_DEV_ASSERT(builder->dev, 6, 8); 1375 1376 /* 1377 * From the Sandy Bridge PRM, volume 4 part 1, page 101: 1378 * 1379 * "The sampler state is stored as an array of up to 16 elements..." 1380 */ 1381 assert(sampler_count <= 16); 1382 1383 if (!sampler_count) 1384 return 0; 1385 1386 /* 1387 * From the Sandy Bridge PRM, volume 2 part 1, page 132: 1388 * 1389 * "(Sampler Count of 3DSTATE_VS) Specifies how many samplers (in 1390 * multiples of 4) the vertex shader 0 kernel uses. Used only for 1391 * prefetching the associated sampler state entries. 1392 * 1393 * It also applies to other shader stages. 1394 */ 1395 ilo_builder_dynamic_pad_top(builder, 4 * (4 - (sampler_count % 4))); 1396 1397 state_offset = ilo_builder_dynamic_pointer(builder, 1398 ILO_BUILDER_ITEM_SAMPLER, state_align, state_len, &dw); 1399 1400 for (i = 0; i < sampler_count; i++) { 1401 /* see sampler_set_gen6_SAMPLER_STATE() */ 1402 dw[0] = samplers[i].sampler[0]; 1403 dw[1] = samplers[i].sampler[1]; 1404 dw[3] = samplers[i].sampler[2]; 1405 1406 assert(!(sampler_border_colors[i] & 0x1f)); 1407 dw[2] = sampler_border_colors[i]; 1408 1409 dw += 4; 1410 } 1411 1412 return state_offset; 1413 } 1414 1415 static inline uint32_t 1416 gen6_SAMPLER_BORDER_COLOR_STATE(struct ilo_builder *builder, 1417 const struct ilo_state_sampler_border *border) 1418 { 1419 const int state_align = 1420 (ilo_dev_gen(builder->dev) >= ILO_GEN(8)) ? 64 : 32; 1421 const int state_len = (ilo_dev_gen(builder->dev) >= ILO_GEN(7)) ? 4 : 12; 1422 1423 ILO_DEV_ASSERT(builder->dev, 6, 8); 1424 1425 /* 1426 * see border_set_gen6_SAMPLER_BORDER_COLOR_STATE() and 1427 * border_set_gen7_SAMPLER_BORDER_COLOR_STATE() 1428 */ 1429 return ilo_builder_dynamic_write(builder, ILO_BUILDER_ITEM_BLOB, 1430 state_align, state_len, border->color); 1431 } 1432 1433 static inline uint32_t 1434 gen6_push_constant_buffer(struct ilo_builder *builder, 1435 int size, void **pcb) 1436 { 1437 /* 1438 * For all VS, GS, FS, and CS push constant buffers, they must be aligned 1439 * to 32 bytes, and their sizes are specified in 256-bit units. 1440 */ 1441 const int state_align = 32; 1442 const int state_len = align(size, 32) / 4; 1443 uint32_t state_offset; 1444 char *buf; 1445 1446 ILO_DEV_ASSERT(builder->dev, 6, 8); 1447 1448 state_offset = ilo_builder_dynamic_pointer(builder, 1449 ILO_BUILDER_ITEM_BLOB, state_align, state_len, (uint32_t **) &buf); 1450 1451 /* zero out the unused range */ 1452 if (size < state_len * 4) 1453 memset(&buf[size], 0, state_len * 4 - size); 1454 1455 if (pcb) 1456 *pcb = buf; 1457 1458 return state_offset; 1459 } 1460 1461 static inline uint32_t 1462 gen6_user_vertex_buffer(struct ilo_builder *builder, 1463 int size, const void *vertices) 1464 { 1465 const int state_align = 8; 1466 const int state_len = size / 4; 1467 1468 ILO_DEV_ASSERT(builder->dev, 6, 7.5); 1469 1470 assert(size % 4 == 0); 1471 1472 return ilo_builder_dynamic_write(builder, ILO_BUILDER_ITEM_BLOB, 1473 state_align, state_len, vertices); 1474 } 1475 1476 #endif /* ILO_BUILDER_3D_TOP_H */ 1477
