genX_cmd_buffer.c revision eadbc95d642cac6feb7f5e5abe136dfd36ff76ac
16f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand/* 26f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * Copyright © 2015 Intel Corporation 36f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * 46f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * Permission is hereby granted, free of charge, to any person obtaining a 56f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * copy of this software and associated documentation files (the "Software"), 66f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * to deal in the Software without restriction, including without limitation 76f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * the rights to use, copy, modify, merge, publish, distribute, sublicense, 86f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * and/or sell copies of the Software, and to permit persons to whom the 96f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * Software is furnished to do so, subject to the following conditions: 106f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * 116f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * The above copyright notice and this permission notice (including the next 126f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * paragraph) shall be included in all copies or substantial portions of the 136f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * Software. 146f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * 156f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 166f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 176f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 186f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 196f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 206f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 216f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * IN THE SOFTWARE. 226f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand */ 236f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 246f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand#include <assert.h> 256f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand#include <stdbool.h> 266f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 276f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand#include "anv_private.h" 28d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand#include "vk_format_info.h" 296f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 307e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#include "common/gen_l3_config.h" 31371b4a5b33a13f35fa7783510d2d90685a9a2e8aJason Ekstrand#include "genxml/gen_macros.h" 32371b4a5b33a13f35fa7783510d2d90685a9a2e8aJason Ekstrand#include "genxml/genX_pack.h" 336f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 3417968e2dfd8bd362404e9bdd34188d473edd471fJason Ekstrandstatic void 3517968e2dfd8bd362404e9bdd34188d473edd471fJason Ekstrandemit_lrm(struct anv_batch *batch, 3617968e2dfd8bd362404e9bdd34188d473edd471fJason Ekstrand uint32_t reg, struct anv_bo *bo, uint32_t offset) 3717968e2dfd8bd362404e9bdd34188d473edd471fJason Ekstrand{ 3817968e2dfd8bd362404e9bdd34188d473edd471fJason Ekstrand anv_batch_emit(batch, GENX(MI_LOAD_REGISTER_MEM), lrm) { 3917968e2dfd8bd362404e9bdd34188d473edd471fJason Ekstrand lrm.RegisterAddress = reg; 4017968e2dfd8bd362404e9bdd34188d473edd471fJason Ekstrand lrm.MemoryAddress = (struct anv_address) { bo, offset }; 4117968e2dfd8bd362404e9bdd34188d473edd471fJason Ekstrand } 4217968e2dfd8bd362404e9bdd34188d473edd471fJason Ekstrand} 4317968e2dfd8bd362404e9bdd34188d473edd471fJason Ekstrand 4417968e2dfd8bd362404e9bdd34188d473edd471fJason Ekstrandstatic void 4517968e2dfd8bd362404e9bdd34188d473edd471fJason Ekstrandemit_lri(struct anv_batch *batch, uint32_t reg, uint32_t imm) 4617968e2dfd8bd362404e9bdd34188d473edd471fJason Ekstrand{ 4717968e2dfd8bd362404e9bdd34188d473edd471fJason Ekstrand anv_batch_emit(batch, GENX(MI_LOAD_REGISTER_IMM), lri) { 4817968e2dfd8bd362404e9bdd34188d473edd471fJason Ekstrand lri.RegisterOffset = reg; 4917968e2dfd8bd362404e9bdd34188d473edd471fJason Ekstrand lri.DataDWord = imm; 5017968e2dfd8bd362404e9bdd34188d473edd471fJason Ekstrand } 5117968e2dfd8bd362404e9bdd34188d473edd471fJason Ekstrand} 5217968e2dfd8bd362404e9bdd34188d473edd471fJason Ekstrand 536f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrandvoid 546f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason EkstrandgenX(cmd_buffer_emit_state_base_address)(struct anv_cmd_buffer *cmd_buffer) 556f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand{ 566f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand struct anv_device *device = cmd_buffer->device; 576f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 586f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand /* Emit a render target cache flush. 596f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * 606f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * This isn't documented anywhere in the PRM. However, it seems to be 616f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * necessary prior to changing the surface state base adress. Without 626f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * this, we get GPU hangs when using multi-level command buffers which 636f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * clear depth, reset state base address, and then go render stuff. 646f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand */ 6550018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 66eadbc95d642cac6feb7f5e5abe136dfd36ff76acJason Ekstrand pc.DCFlushEnable = true; 6756453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.RenderTargetCacheFlushEnable = true; 68eadbc95d642cac6feb7f5e5abe136dfd36ff76acJason Ekstrand pc.CommandStreamerStallEnable = true; 6956453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 706f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 7150018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(STATE_BASE_ADDRESS), sba) { 72c2f2c8e407207c31c29aab5570d23cd6e98d287aJason Ekstrand sba.GeneralStateBaseAddress = (struct anv_address) { NULL, 0 }; 7356453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.GeneralStateMemoryObjectControlState = GENX(MOCS); 7456453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.GeneralStateBaseAddressModifyEnable = true; 756f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 7656453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.SurfaceStateBaseAddress = 7756453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand anv_cmd_buffer_surface_base_address(cmd_buffer); 7856453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.SurfaceStateMemoryObjectControlState = GENX(MOCS); 7956453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.SurfaceStateBaseAddressModifyEnable = true; 806f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 8156453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.DynamicStateBaseAddress = 8256453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand (struct anv_address) { &device->dynamic_state_block_pool.bo, 0 }; 83696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin sba.DynamicStateMemoryObjectControlState = GENX(MOCS); 84696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin sba.DynamicStateBaseAddressModifyEnable = true; 856f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 8656453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.IndirectObjectBaseAddress = (struct anv_address) { NULL, 0 }; 8756453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.IndirectObjectMemoryObjectControlState = GENX(MOCS); 8856453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.IndirectObjectBaseAddressModifyEnable = true; 896f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 9056453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.InstructionBaseAddress = 9156453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand (struct anv_address) { &device->instruction_block_pool.bo, 0 }; 9256453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.InstructionMemoryObjectControlState = GENX(MOCS); 9356453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.InstructionBaseAddressModifyEnable = true; 946f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 95371b4a5b33a13f35fa7783510d2d90685a9a2e8aJason Ekstrand# if (GEN_GEN >= 8) 966f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand /* Broadwell requires that we specify a buffer size for a bunch of 976f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * these fields. However, since we will be growing the BO's live, we 986f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * just set them all to the maximum. 996f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand */ 10056453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.GeneralStateBufferSize = 0xfffff; 10156453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.GeneralStateBufferSizeModifyEnable = true; 10256453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.DynamicStateBufferSize = 0xfffff; 10356453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.DynamicStateBufferSizeModifyEnable = true; 10456453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.IndirectObjectBufferSize = 0xfffff; 10556453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.IndirectObjectBufferSizeModifyEnable = true; 10656453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.InstructionBufferSize = 0xfffff; 10756453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.InstructionBuffersizeModifyEnable = true; 1086f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand# endif 10956453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 1106f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 1116f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand /* After re-setting the surface state base address, we have to do some 1126f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * cache flusing so that the sampler engine will pick up the new 1136f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * SURFACE_STATE objects and binding tables. From the Broadwell PRM, 1146f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * Shared Function > 3D Sampler > State > State Caching (page 96): 1156f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * 1166f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * Coherency with system memory in the state cache, like the texture 1176f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * cache is handled partially by software. It is expected that the 1186f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * command stream or shader will issue Cache Flush operation or 1196f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * Cache_Flush sampler message to ensure that the L1 cache remains 1206f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * coherent with system memory. 1216f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * 1226f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * [...] 1236f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * 1246f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * Whenever the value of the Dynamic_State_Base_Addr, 1256f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * Surface_State_Base_Addr are altered, the L1 state cache must be 1266f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * invalidated to ensure the new surface or sampler state is fetched 1276f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * from system memory. 1286f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * 1296f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * The PIPE_CONTROL command has a "State Cache Invalidation Enable" bit 1306f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * which, according the PIPE_CONTROL instruction documentation in the 1316f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * Broadwell PRM: 1326f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * 1336f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * Setting this bit is independent of any other bit in this packet. 1346f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * This bit controls the invalidation of the L1 and L2 state caches 1356f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * at the top of the pipe i.e. at the parsing time. 1366f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * 1376f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * Unfortunately, experimentation seems to indicate that state cache 1386f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * invalidation through a PIPE_CONTROL does nothing whatsoever in 1396f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * regards to surface state and binding tables. In stead, it seems that 1406f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * invalidating the texture cache is what is actually needed. 1416f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * 1426f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * XXX: As far as we have been able to determine through 1436f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * experimentation, shows that flush the texture cache appears to be 1446f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * sufficient. The theory here is that all of the sampling/rendering 1456f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * units cache the binding table in the texture cache. However, we have 1466f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * yet to be able to actually confirm this. 1476f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand */ 14850018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 14956453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.TextureCacheInvalidationEnable = true; 150eadbc95d642cac6feb7f5e5abe136dfd36ff76acJason Ekstrand pc.ConstantCacheInvalidationEnable = true; 151eadbc95d642cac6feb7f5e5abe136dfd36ff76acJason Ekstrand pc.StateCacheInvalidationEnable = true; 15256453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 1536f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand} 1546f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 1559be9f5f1c71a5c8942b1f41d0512479a9899df42Jason Ekstrandstatic void 1569be9f5f1c71a5c8942b1f41d0512479a9899df42Jason Ekstrandadd_surface_state_reloc(struct anv_cmd_buffer *cmd_buffer, 1579be9f5f1c71a5c8942b1f41d0512479a9899df42Jason Ekstrand struct anv_state state, 1589be9f5f1c71a5c8942b1f41d0512479a9899df42Jason Ekstrand struct anv_bo *bo, uint32_t offset) 1599be9f5f1c71a5c8942b1f41d0512479a9899df42Jason Ekstrand{ 1609be9f5f1c71a5c8942b1f41d0512479a9899df42Jason Ekstrand const struct isl_device *isl_dev = &cmd_buffer->device->isl_dev; 1619be9f5f1c71a5c8942b1f41d0512479a9899df42Jason Ekstrand 1629be9f5f1c71a5c8942b1f41d0512479a9899df42Jason Ekstrand anv_reloc_list_add(&cmd_buffer->surface_relocs, &cmd_buffer->pool->alloc, 1639be9f5f1c71a5c8942b1f41d0512479a9899df42Jason Ekstrand state.offset + isl_dev->ss.addr_offset, bo, offset); 1649be9f5f1c71a5c8942b1f41d0512479a9899df42Jason Ekstrand} 1659be9f5f1c71a5c8942b1f41d0512479a9899df42Jason Ekstrand 166818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrandstatic void 167818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrandadd_image_view_relocs(struct anv_cmd_buffer *cmd_buffer, 168818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand const struct anv_image_view *iview, 169338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand enum isl_aux_usage aux_usage, 170818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand struct anv_state state) 171818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand{ 172818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand const struct isl_device *isl_dev = &cmd_buffer->device->isl_dev; 173818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand 174818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand anv_reloc_list_add(&cmd_buffer->surface_relocs, &cmd_buffer->pool->alloc, 175818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand state.offset + isl_dev->ss.addr_offset, 176818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand iview->bo, iview->offset); 177338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand 178338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand if (aux_usage != ISL_AUX_USAGE_NONE) { 179338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand uint32_t aux_offset = iview->offset + iview->image->aux_surface.offset; 180338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand 181338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand /* On gen7 and prior, the bottom 12 bits of the MCS base address are 182338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand * used to store other information. This should be ok, however, because 183338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand * surface buffer addresses are always 4K page alinged. 184338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand */ 185338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand assert((aux_offset & 0xfff) == 0); 186338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand uint32_t *aux_addr_dw = state.map + isl_dev->ss.aux_addr_offset; 187338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand aux_offset += *aux_addr_dw & 0xfff; 188338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand 189338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand anv_reloc_list_add(&cmd_buffer->surface_relocs, &cmd_buffer->pool->alloc, 190338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand state.offset + isl_dev->ss.aux_addr_offset, 191338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand iview->bo, aux_offset); 192338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand } 193338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand} 194338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand 1955e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrandstatic bool 1965e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrandcolor_is_zero_one(VkClearColorValue value, enum isl_format format) 197338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand{ 1985e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand if (isl_format_has_int_channel(format)) { 1995e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand for (unsigned i = 0; i < 4; i++) { 2005e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand if (value.int32[i] != 0 && value.int32[i] != 1) 2015e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand return false; 2025e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand } 2035e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand } else { 2045e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand for (unsigned i = 0; i < 4; i++) { 2055e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand if (value.float32[i] != 0.0f && value.float32[i] != 1.0f) 2065e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand return false; 2075e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand } 2085e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand } 209338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand 2105e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand return true; 2115e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand} 2125e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand 2135e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrandstatic void 2145e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrandcolor_attachment_compute_aux_usage(struct anv_device *device, 2155e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand struct anv_attachment_state *att_state, 2165e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand struct anv_image_view *iview, 2175e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand VkRect2D render_area, 2185e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand union isl_color_value *fast_clear_color) 2195e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand{ 2205e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand if (iview->image->aux_surface.isl.size == 0) { 2215e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand att_state->aux_usage = ISL_AUX_USAGE_NONE; 2225e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand att_state->input_aux_usage = ISL_AUX_USAGE_NONE; 2235e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand att_state->fast_clear = false; 2245e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand return; 2255e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand } 226338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand 227338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand assert(iview->image->aux_surface.isl.usage & ISL_SURF_USAGE_CCS_BIT); 228338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand 2295e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand att_state->clear_color_is_zero_one = 2305e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand color_is_zero_one(att_state->clear_value.color, iview->isl.format); 231338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand 2325e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand if (att_state->pending_clear_aspects == VK_IMAGE_ASPECT_COLOR_BIT) { 2335e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand /* Start off assuming fast clears are possible */ 2345e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand att_state->fast_clear = true; 2355e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand 2365e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand /* Potentially, we could do partial fast-clears but doing so has crazy 2375e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand * alignment restrictions. It's easier to just restrict to full size 2385e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand * fast clears for now. 2395e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand */ 2405e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand if (render_area.offset.x != 0 || 2415e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand render_area.offset.y != 0 || 2425e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand render_area.extent.width != iview->extent.width || 2435e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand render_area.extent.height != iview->extent.height) 2445e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand att_state->fast_clear = false; 2455e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand 2463fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand if (GEN_GEN <= 7) { 2473fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand /* On gen7, we can't do multi-LOD or multi-layer fast-clears. We 2483fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand * technically can, but it comes with crazy restrictions that we 2493fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand * don't want to deal with now. 2503fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand */ 2513fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand if (iview->isl.base_level > 0 || 2523fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand iview->isl.base_array_layer > 0 || 2533fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand iview->isl.array_len > 1) 2543fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand att_state->fast_clear = false; 2553fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand } 2563fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand 2573fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand /* On Broadwell and earlier, we can only handle 0/1 clear colors */ 2583fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand if (GEN_GEN <= 8 && !att_state->clear_color_is_zero_one) 2593fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand att_state->fast_clear = false; 2603fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand 2615e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand if (att_state->fast_clear) { 2625e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand memcpy(fast_clear_color->u32, att_state->clear_value.color.uint32, 2635e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand sizeof(fast_clear_color->u32)); 2645e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand } 2655e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand } else { 2665e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand att_state->fast_clear = false; 2675e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand } 2685e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand 2695e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand if (isl_format_supports_lossless_compression(&device->info, 2705e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand iview->isl.format)) { 2715e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand att_state->aux_usage = ISL_AUX_USAGE_CCS_E; 2725e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand att_state->input_aux_usage = ISL_AUX_USAGE_CCS_E; 2735e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand } else if (att_state->fast_clear) { 2745e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand att_state->aux_usage = ISL_AUX_USAGE_CCS_D; 2753fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand if (GEN_GEN >= 9) { 2763fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand /* From the Sky Lake PRM, RENDER_SURFACE_STATE::AuxiliarySurfaceMode: 2773fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand * 2783fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand * "If Number of Multisamples is MULTISAMPLECOUNT_1, AUX_CCS_D 2793fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand * setting is only allowed if Surface Format supported for Fast 2803fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand * Clear. In addition, if the surface is bound to the sampling 2813fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand * engine, Surface Format must be supported for Render Target 2823fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand * Compression for surfaces bound to the sampling engine." 2833fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand * 2843fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand * In other words, we can't sample from a fast-cleared image if it 2853fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand * doesn't also support color compression. 2863fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand */ 2873fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand att_state->input_aux_usage = ISL_AUX_USAGE_NONE; 2883fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand } else if (GEN_GEN == 8) { 2893fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand /* Broadwell can sample from fast-cleared images */ 2903fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand att_state->input_aux_usage = ISL_AUX_USAGE_CCS_D; 2913fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand } else { 2923fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand /* Ivy Bridge and Haswell cannot */ 2933fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand att_state->input_aux_usage = ISL_AUX_USAGE_NONE; 2943fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand } 2955e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand } else { 2965e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand att_state->aux_usage = ISL_AUX_USAGE_NONE; 2975e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand att_state->input_aux_usage = ISL_AUX_USAGE_NONE; 2985e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand } 299818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand} 300818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand 3011d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrandstatic bool 3021d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrandneed_input_attachment_state(const struct anv_render_pass_attachment *att) 3031d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand{ 3041d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand if (!(att->usage & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT)) 3051d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand return false; 3061d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand 3072852efcda40274acf3272611c6a3b7731523a72dNanley Chery /* We only allocate input attachment states for color surfaces. Compression 3082852efcda40274acf3272611c6a3b7731523a72dNanley Chery * is not yet enabled for depth textures and stencil doesn't allow 3092852efcda40274acf3272611c6a3b7731523a72dNanley Chery * compression so we can just use the texture surface state from the view. 3101d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand */ 3112852efcda40274acf3272611c6a3b7731523a72dNanley Chery return vk_format_is_color(att->format); 3121d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand} 3131d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand 3142e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Cherystatic enum isl_aux_usage 31564272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Cherylayout_to_hiz_usage(VkImageLayout layout, uint8_t samples) 3162e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery{ 3172e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery switch (layout) { 3182e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL: 3192e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery return ISL_AUX_USAGE_HIZ; 32064272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL: 32164272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: 32264272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery if (anv_can_sample_with_hiz(GEN_GEN, samples)) 32364272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery return ISL_AUX_USAGE_HIZ; 32464272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery /* Fall-through */ 32564272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery case VK_IMAGE_LAYOUT_GENERAL: 32664272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery /* This buffer could be used as a source or destination in a transfer 32764272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery * operation. Transfer operations current don't perform HiZ-enabled reads 32864272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery * and writes. 32964272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery */ 3302e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery default: 3312e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery return ISL_AUX_USAGE_NONE; 3322e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery } 3332e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery} 3342e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery 3352e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery/* Transitions a HiZ-enabled depth buffer from one layout to another. Unless 3362e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery * the initial layout is undefined, the HiZ buffer and depth buffer will 3372e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery * represent the same data at the end of this operation. 3382e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery */ 3392e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Cherystatic void 3402e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Cherytransition_depth_buffer(struct anv_cmd_buffer *cmd_buffer, 3412e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery const struct anv_image *image, 3422e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery VkImageLayout initial_layout, 3432e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery VkImageLayout final_layout) 3442e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery{ 3452e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery assert(image); 3462e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery 34764272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery if (image->aux_usage != ISL_AUX_USAGE_HIZ || final_layout == initial_layout) 3482e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery return; 3492e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery 35064272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery const bool hiz_enabled = layout_to_hiz_usage(initial_layout, image->samples) == 3512e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery ISL_AUX_USAGE_HIZ; 35264272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery const bool enable_hiz = layout_to_hiz_usage(final_layout, image->samples) == 3532e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery ISL_AUX_USAGE_HIZ; 3542e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery 35564272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery enum blorp_hiz_op hiz_op; 35664272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery if (initial_layout == VK_IMAGE_LAYOUT_UNDEFINED) { 35764272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery /* We've already initialized the aux HiZ buffer at BindImageMemory time, 35864272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery * so there's no need to perform a HIZ resolve or clear to avoid GPU hangs. 35964272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery * This initial layout indicates that the user doesn't care about the data 36064272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery * that's currently in the buffer, so resolves are not necessary except 36164272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery * for the special case noted below. 36264272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery */ 36364272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery hiz_op = BLORP_HIZ_OP_NONE; 3642e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery } else if (hiz_enabled && !enable_hiz) { 36564272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery hiz_op = BLORP_HIZ_OP_DEPTH_RESOLVE; 36664272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery } else if (!hiz_enabled && enable_hiz) { 36764272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery hiz_op = BLORP_HIZ_OP_HIZ_RESOLVE; 3682e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery } else { 36964272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery assert(hiz_enabled == enable_hiz); 37064272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery /* If the same buffer will be used, no resolves are necessary except for 37164272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery * the special case noted below. 37264272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery */ 37364272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery hiz_op = BLORP_HIZ_OP_NONE; 37464272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery } 37564272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery 37664272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery if (hiz_op != BLORP_HIZ_OP_NONE) 37764272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery anv_gen8_hiz_op_resolve(cmd_buffer, image, hiz_op); 37864272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery 37964272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery /* Images that have sampling with HiZ enabled cause all shader sampling to 38064272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery * load data with the HiZ buffer. Therefore, in the case of transitioning to 38164272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery * the general layout - which currently routes all writes to the depth 38264272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery * buffer - we must ensure that the HiZ buffer remains consistent with the 38364272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery * depth buffer by performing an additional HIZ resolve if the operation 38464272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery * required by this transition was not already a HiZ resolve. 38564272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery */ 38664272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery if (final_layout == VK_IMAGE_LAYOUT_GENERAL && 38764272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery anv_can_sample_with_hiz(GEN_GEN, image->samples) && 38864272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery hiz_op != BLORP_HIZ_OP_HIZ_RESOLVE) { 3892e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery anv_gen8_hiz_op_resolve(cmd_buffer, image, BLORP_HIZ_OP_HIZ_RESOLVE); 3902e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery } 3912e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery} 3922e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery 3932e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery 394d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand/** 395d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand * Setup anv_cmd_state::attachments for vkCmdBeginRenderPass. 396d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand */ 397d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrandstatic void 398d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason EkstrandgenX(cmd_buffer_setup_attachments)(struct anv_cmd_buffer *cmd_buffer, 399d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_render_pass *pass, 400d1d6b788989e73edd2426999d891230500dc1a73Jason Ekstrand const VkRenderPassBeginInfo *begin) 401d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand{ 402d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand const struct isl_device *isl_dev = &cmd_buffer->device->isl_dev; 403d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_cmd_state *state = &cmd_buffer->state; 404d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 405d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand vk_free(&cmd_buffer->pool->alloc, state->attachments); 406d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 407d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (pass->attachment_count == 0) { 408d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand state->attachments = NULL; 409d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand return; 410d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 411d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 412d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand state->attachments = vk_alloc(&cmd_buffer->pool->alloc, 413d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand pass->attachment_count * 414d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand sizeof(state->attachments[0]), 415d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); 416d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (state->attachments == NULL) { 417d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand /* FIXME: Propagate VK_ERROR_OUT_OF_HOST_MEMORY to vkEndCommandBuffer */ 418d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand abort(); 419d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 420d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 421d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand bool need_null_state = false; 422633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand unsigned num_states = 0; 423d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand for (uint32_t i = 0; i < pass->attachment_count; ++i) { 424633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand if (vk_format_is_color(pass->attachments[i].format)) { 425d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand num_states++; 426633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand } else { 427633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand /* We need a null state for any depth-stencil-only subpasses. 428633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand * Importantly, this includes depth/stencil clears so we create one 429633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand * whenever we have depth or stencil 430633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand */ 431633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand need_null_state = true; 432633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand } 4331d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand 4341d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand if (need_input_attachment_state(&pass->attachments[i])) 4351d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand num_states++; 436d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 437633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand num_states += need_null_state; 438d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 439d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand const uint32_t ss_stride = align_u32(isl_dev->ss.size, isl_dev->ss.align); 440d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand state->render_pass_states = 441d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand anv_state_stream_alloc(&cmd_buffer->surface_state_stream, 442d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand num_states * ss_stride, isl_dev->ss.align); 443d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 444d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_state next_state = state->render_pass_states; 445d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand next_state.alloc_size = isl_dev->ss.size; 446d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 447d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (need_null_state) { 448d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand state->null_surface_state = next_state; 449d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand next_state.offset += ss_stride; 450d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand next_state.map += ss_stride; 451d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 452d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 453d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand for (uint32_t i = 0; i < pass->attachment_count; ++i) { 454d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (vk_format_is_color(pass->attachments[i].format)) { 455d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand state->attachments[i].color_rt_state = next_state; 456d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand next_state.offset += ss_stride; 457d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand next_state.map += ss_stride; 458d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 4591d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand 4601d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand if (need_input_attachment_state(&pass->attachments[i])) { 4611d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand state->attachments[i].input_att_state = next_state; 4621d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand next_state.offset += ss_stride; 4631d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand next_state.map += ss_stride; 4641d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand } 465d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 466d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand assert(next_state.offset == state->render_pass_states.offset + 467d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand state->render_pass_states.alloc_size); 468d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 469d1d6b788989e73edd2426999d891230500dc1a73Jason Ekstrand if (begin) { 470d1d6b788989e73edd2426999d891230500dc1a73Jason Ekstrand ANV_FROM_HANDLE(anv_framebuffer, framebuffer, begin->framebuffer); 471d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand assert(pass->attachment_count == framebuffer->attachment_count); 472d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 473d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (need_null_state) { 474d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct GENX(RENDER_SURFACE_STATE) null_ss = { 475d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .SurfaceType = SURFTYPE_NULL, 476d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .SurfaceArray = framebuffer->layers > 0, 477d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .SurfaceFormat = ISL_FORMAT_R8G8B8A8_UNORM, 478d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand#if GEN_GEN >= 8 479d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .TileMode = YMAJOR, 480d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand#else 481d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .TiledSurface = true, 482d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand#endif 483d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .Width = framebuffer->width - 1, 484d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .Height = framebuffer->height - 1, 485d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .Depth = framebuffer->layers - 1, 486d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .RenderTargetViewExtent = framebuffer->layers - 1, 487d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand }; 488d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand GENX(RENDER_SURFACE_STATE_pack)(NULL, state->null_surface_state.map, 489d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand &null_ss); 490d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 491d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 492d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand for (uint32_t i = 0; i < pass->attachment_count; ++i) { 493d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_render_pass_attachment *att = &pass->attachments[i]; 494d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand VkImageAspectFlags att_aspects = vk_format_aspects(att->format); 495d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand VkImageAspectFlags clear_aspects = 0; 496d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 497d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (att_aspects == VK_IMAGE_ASPECT_COLOR_BIT) { 498d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand /* color attachment */ 499d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (att->load_op == VK_ATTACHMENT_LOAD_OP_CLEAR) { 500d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand clear_aspects |= VK_IMAGE_ASPECT_COLOR_BIT; 501d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 502d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } else { 503d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand /* depthstencil attachment */ 504d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if ((att_aspects & VK_IMAGE_ASPECT_DEPTH_BIT) && 505d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand att->load_op == VK_ATTACHMENT_LOAD_OP_CLEAR) { 506d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand clear_aspects |= VK_IMAGE_ASPECT_DEPTH_BIT; 507d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 508d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if ((att_aspects & VK_IMAGE_ASPECT_STENCIL_BIT) && 509d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand att->stencil_load_op == VK_ATTACHMENT_LOAD_OP_CLEAR) { 510d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand clear_aspects |= VK_IMAGE_ASPECT_STENCIL_BIT; 511d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 512d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 513d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 514104ce1dbab44f8d11d5dcc90d3f1cc8c466893d8Nanley Chery state->attachments[i].current_layout = att->initial_layout; 515d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand state->attachments[i].pending_clear_aspects = clear_aspects; 516d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (clear_aspects) 517d1d6b788989e73edd2426999d891230500dc1a73Jason Ekstrand state->attachments[i].clear_value = begin->pClearValues[i]; 518d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 519d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_image_view *iview = framebuffer->attachments[i]; 520d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand assert(iview->vk_format == att->format); 521d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 5225e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand union isl_color_value clear_color = { .u32 = { 0, } }; 523d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (att_aspects == VK_IMAGE_ASPECT_COLOR_BIT) { 5245e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand color_attachment_compute_aux_usage(cmd_buffer->device, 5255e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand &state->attachments[i], 5265e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand iview, begin->renderArea, 5275e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand &clear_color); 528338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand 529d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct isl_view view = iview->isl; 530d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand view.usage |= ISL_SURF_USAGE_RENDER_TARGET_BIT; 531d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand isl_surf_fill_state(isl_dev, 532d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand state->attachments[i].color_rt_state.map, 533d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .surf = &iview->image->color_surface.isl, 534d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .view = &view, 535338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand .aux_surf = &iview->image->aux_surface.isl, 536338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand .aux_usage = state->attachments[i].aux_usage, 5375e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand .clear_color = clear_color, 538d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .mocs = cmd_buffer->device->default_mocs); 539d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 540818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand add_image_view_relocs(cmd_buffer, iview, 541338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand state->attachments[i].aux_usage, 542818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand state->attachments[i].color_rt_state); 543338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand } else { 54458af6156360a309578241acba949e540acf72cb1Nanley Chery if (iview->image->aux_usage == ISL_AUX_USAGE_HIZ) { 54558af6156360a309578241acba949e540acf72cb1Nanley Chery state->attachments[i].aux_usage = 54664272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery layout_to_hiz_usage(att->initial_layout, iview->image->samples); 54758af6156360a309578241acba949e540acf72cb1Nanley Chery } else { 54858af6156360a309578241acba949e540acf72cb1Nanley Chery state->attachments[i].aux_usage = ISL_AUX_USAGE_NONE; 54958af6156360a309578241acba949e540acf72cb1Nanley Chery } 5505e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand state->attachments[i].input_aux_usage = ISL_AUX_USAGE_NONE; 551d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 5521d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand 5531d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand if (need_input_attachment_state(&pass->attachments[i])) { 5541d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand struct isl_view view = iview->isl; 5551d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand view.usage |= ISL_SURF_USAGE_TEXTURE_BIT; 5561d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand isl_surf_fill_state(isl_dev, 5571d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand state->attachments[i].input_att_state.map, 5582852efcda40274acf3272611c6a3b7731523a72dNanley Chery .surf = &iview->image->color_surface.isl, 5591d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand .view = &view, 5601d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand .aux_surf = &iview->image->aux_surface.isl, 5615e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand .aux_usage = state->attachments[i].input_aux_usage, 5625e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand .clear_color = clear_color, 5631d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand .mocs = cmd_buffer->device->default_mocs); 5641d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand 5651d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand add_image_view_relocs(cmd_buffer, iview, 5665e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand state->attachments[i].input_aux_usage, 5671d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand state->attachments[i].input_att_state); 5681d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand } 569d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 570d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 571d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (!cmd_buffer->device->info.has_llc) 572d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand anv_state_clflush(state->render_pass_states); 573d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 574d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand} 575d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 5762314c9ed2e39bcf4ac6b206344acb05fec876a41Jason EkstrandVkResult 5772314c9ed2e39bcf4ac6b206344acb05fec876a41Jason EkstrandgenX(BeginCommandBuffer)( 5782314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand VkCommandBuffer commandBuffer, 5792314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand const VkCommandBufferBeginInfo* pBeginInfo) 5802314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand{ 5812314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 5822314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 5832314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand /* If this is the first vkBeginCommandBuffer, we must *initialize* the 5842314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * command buffer's state. Otherwise, we must *reset* its state. In both 5852314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * cases we reset it. 5862314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * 5872314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * From the Vulkan 1.0 spec: 5882314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * 5892314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * If a command buffer is in the executable state and the command buffer 5902314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * was allocated from a command pool with the 5912314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT flag set, then 5922314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * vkBeginCommandBuffer implicitly resets the command buffer, behaving 5932314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * as if vkResetCommandBuffer had been called with 5942314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT not set. It then puts 5952314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * the command buffer in the recording state. 5962314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand */ 5972314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand anv_cmd_buffer_reset(cmd_buffer); 5982314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 5992314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand cmd_buffer->usage_flags = pBeginInfo->flags; 6002314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 6012314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand assert(cmd_buffer->level == VK_COMMAND_BUFFER_LEVEL_SECONDARY || 6022314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand !(cmd_buffer->usage_flags & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT)); 6032314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 6042314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand genX(cmd_buffer_emit_state_base_address)(cmd_buffer); 6052314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 6062314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand if (cmd_buffer->usage_flags & 6072314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT) { 6082314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand cmd_buffer->state.pass = 6092314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand anv_render_pass_from_handle(pBeginInfo->pInheritanceInfo->renderPass); 6102314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand cmd_buffer->state.subpass = 6112314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand &cmd_buffer->state.pass->subpasses[pBeginInfo->pInheritanceInfo->subpass]; 612a380f954610319782811bb2aa44180c4e1231823Jason Ekstrand cmd_buffer->state.framebuffer = NULL; 6132314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 614d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand genX(cmd_buffer_setup_attachments)(cmd_buffer, cmd_buffer->state.pass, 615d1d6b788989e73edd2426999d891230500dc1a73Jason Ekstrand NULL); 616d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 6172314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand cmd_buffer->state.dirty |= ANV_CMD_DIRTY_RENDER_TARGETS; 6182314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand } 6192314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 6202314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand return VK_SUCCESS; 6212314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand} 6222314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 6232314c9ed2e39bcf4ac6b206344acb05fec876a41Jason EkstrandVkResult 6242314c9ed2e39bcf4ac6b206344acb05fec876a41Jason EkstrandgenX(EndCommandBuffer)( 6252314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand VkCommandBuffer commandBuffer) 6262314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand{ 6272314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 6282314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 6298d1ccd67290c1fd0213aed6a7e9a6bf85858f227Jason Ekstrand genX(cmd_buffer_apply_pipe_flushes)(cmd_buffer); 6308d1ccd67290c1fd0213aed6a7e9a6bf85858f227Jason Ekstrand 6312314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand anv_cmd_buffer_end_batch_buffer(cmd_buffer); 6322314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 6332314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand return VK_SUCCESS; 6342314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand} 6352314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 6362314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrandvoid 6372314c9ed2e39bcf4ac6b206344acb05fec876a41Jason EkstrandgenX(CmdExecuteCommands)( 6382314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand VkCommandBuffer commandBuffer, 6392314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand uint32_t commandBufferCount, 6402314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand const VkCommandBuffer* pCmdBuffers) 6412314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand{ 6422314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand ANV_FROM_HANDLE(anv_cmd_buffer, primary, commandBuffer); 6432314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 6442314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand assert(primary->level == VK_COMMAND_BUFFER_LEVEL_PRIMARY); 6452314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 6462314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand for (uint32_t i = 0; i < commandBufferCount; i++) { 6472314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand ANV_FROM_HANDLE(anv_cmd_buffer, secondary, pCmdBuffers[i]); 6482314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 6492314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand assert(secondary->level == VK_COMMAND_BUFFER_LEVEL_SECONDARY); 6502314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 651d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (secondary->usage_flags & 652d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT) { 653d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand /* If we're continuing a render pass from the primary, we need to 654d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand * copy the surface states for the current subpass into the storage 655d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand * we allocated for them in BeginCommandBuffer. 656d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand */ 657d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_bo *ss_bo = &primary->device->surface_state_block_pool.bo; 658d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_state src_state = primary->state.render_pass_states; 659d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_state dst_state = secondary->state.render_pass_states; 660d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand assert(src_state.alloc_size == dst_state.alloc_size); 661d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 662d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand genX(cmd_buffer_gpu_memcpy)(primary, ss_bo, dst_state.offset, 663d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand ss_bo, src_state.offset, 664d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand src_state.alloc_size); 665d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 666d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 6672314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand anv_cmd_buffer_add_secondary(primary, secondary); 6682314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand } 6692314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 6702314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand /* Each of the secondary command buffers will use its own state base 6712314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * address. We need to re-emit state base address for the primary after 6722314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * all of the secondaries are done. 6732314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * 6742314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * TODO: Maybe we want to make this a dirty bit to avoid extra state base 6752314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * address calls? 6762314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand */ 6772314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand genX(cmd_buffer_emit_state_base_address)(primary); 6782314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand} 6792314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 6807e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#define IVB_L3SQCREG1_SQGHPCI_DEFAULT 0x00730000 6817e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#define VLV_L3SQCREG1_SQGHPCI_DEFAULT 0x00d30000 6827e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#define HSW_L3SQCREG1_SQGHPCI_DEFAULT 0x00610000 6837e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 6847e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand/** 6857e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * Program the hardware to use the specified L3 configuration. 6867e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand */ 6877e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrandvoid 6887e891f90c701aa1c851f1846857daa75bbb65876Jason EkstrandgenX(cmd_buffer_config_l3)(struct anv_cmd_buffer *cmd_buffer, 6897e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const struct gen_l3_config *cfg) 6907e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand{ 6917e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand assert(cfg); 6927e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand if (cfg == cmd_buffer->state.current_l3_config) 6937e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand return; 6947e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 6957e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand if (unlikely(INTEL_DEBUG & DEBUG_L3)) { 6967e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand fprintf(stderr, "L3 config transition: "); 6977e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand gen_dump_l3_config(cfg, stderr); 6987e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand } 6997e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7007e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const bool has_slm = cfg->n[GEN_L3P_SLM]; 7017e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7027e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* According to the hardware docs, the L3 partitioning can only be changed 7037e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * while the pipeline is completely drained and the caches are flushed, 7047e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * which involves a first PIPE_CONTROL flush which stalls the pipeline... 7057e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand */ 7067e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 7077e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.DCFlushEnable = true; 7087e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.PostSyncOperation = NoWrite; 7097e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.CommandStreamerStallEnable = true; 7107e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand } 7117e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7127e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* ...followed by a second pipelined PIPE_CONTROL that initiates 7137e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * invalidation of the relevant caches. Note that because RO invalidation 7147e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * happens at the top of the pipeline (i.e. right away as the PIPE_CONTROL 7157e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * command is processed by the CS) we cannot combine it with the previous 7167e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * stalling flush as the hardware documentation suggests, because that 7177e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * would cause the CS to stall on previous rendering *after* RO 7187e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * invalidation and wouldn't prevent the RO caches from being polluted by 7197e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * concurrent rendering before the stall completes. This intentionally 7207e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * doesn't implement the SKL+ hardware workaround suggesting to enable CS 7217e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * stall on PIPE_CONTROLs with the texture cache invalidation bit set for 7227e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * GPGPU workloads because the previous and subsequent PIPE_CONTROLs 7237e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * already guarantee that there is no concurrent GPGPU kernel execution 7247e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * (see SKL HSD 2132585). 7257e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand */ 7267e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 7277e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.TextureCacheInvalidationEnable = true; 7287e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.ConstantCacheInvalidationEnable = true; 7297e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.InstructionCacheInvalidateEnable = true; 7307e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.StateCacheInvalidationEnable = true; 7317e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.PostSyncOperation = NoWrite; 7327e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand } 7337e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7347e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* Now send a third stalling flush to make sure that invalidation is 7357e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * complete when the L3 configuration registers are modified. 7367e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand */ 7377e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 7387e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.DCFlushEnable = true; 7397e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.PostSyncOperation = NoWrite; 7407e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.CommandStreamerStallEnable = true; 7417e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand } 7427e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7437e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#if GEN_GEN >= 8 7447e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7457e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand assert(!cfg->n[GEN_L3P_IS] && !cfg->n[GEN_L3P_C] && !cfg->n[GEN_L3P_T]); 7467e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7477e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand uint32_t l3cr; 7487e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_pack_struct(&l3cr, GENX(L3CNTLREG), 7497e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .SLMEnable = has_slm, 7507e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .URBAllocation = cfg->n[GEN_L3P_URB], 7517e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ROAllocation = cfg->n[GEN_L3P_RO], 7527e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .DCAllocation = cfg->n[GEN_L3P_DC], 7537e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .AllAllocation = cfg->n[GEN_L3P_ALL]); 7547e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7557e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* Set up the L3 partitioning. */ 7567e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand emit_lri(&cmd_buffer->batch, GENX(L3CNTLREG_num), l3cr); 7577e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7587e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#else 7597e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7607e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const bool has_dc = cfg->n[GEN_L3P_DC] || cfg->n[GEN_L3P_ALL]; 7617e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const bool has_is = cfg->n[GEN_L3P_IS] || cfg->n[GEN_L3P_RO] || 7627e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand cfg->n[GEN_L3P_ALL]; 7637e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const bool has_c = cfg->n[GEN_L3P_C] || cfg->n[GEN_L3P_RO] || 7647e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand cfg->n[GEN_L3P_ALL]; 7657e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const bool has_t = cfg->n[GEN_L3P_T] || cfg->n[GEN_L3P_RO] || 7667e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand cfg->n[GEN_L3P_ALL]; 7677e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7687e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand assert(!cfg->n[GEN_L3P_ALL]); 7697e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7707e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* When enabled SLM only uses a portion of the L3 on half of the banks, 7717e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * the matching space on the remaining banks has to be allocated to a 7727e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * client (URB for all validated configurations) set to the 7737e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * lower-bandwidth 2-bank address hashing mode. 7747e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand */ 7757e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const struct gen_device_info *devinfo = &cmd_buffer->device->info; 7767e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const bool urb_low_bw = has_slm && !devinfo->is_baytrail; 7777e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand assert(!urb_low_bw || cfg->n[GEN_L3P_URB] == cfg->n[GEN_L3P_SLM]); 7787e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7797e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* Minimum number of ways that can be allocated to the URB. */ 7803a1b15c3921d25ea2e6e81f500c3f45c84b95817Grazvydas Ignotas MAYBE_UNUSED const unsigned n0_urb = devinfo->is_baytrail ? 32 : 0; 7817e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand assert(cfg->n[GEN_L3P_URB] >= n0_urb); 7827e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7837e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand uint32_t l3sqcr1, l3cr2, l3cr3; 7847e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_pack_struct(&l3sqcr1, GENX(L3SQCREG1), 7857e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ConvertDC_UC = !has_dc, 7867e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ConvertIS_UC = !has_is, 7877e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ConvertC_UC = !has_c, 7887e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ConvertT_UC = !has_t); 7897e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand l3sqcr1 |= 7907e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand GEN_IS_HASWELL ? HSW_L3SQCREG1_SQGHPCI_DEFAULT : 7917e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand devinfo->is_baytrail ? VLV_L3SQCREG1_SQGHPCI_DEFAULT : 7927e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand IVB_L3SQCREG1_SQGHPCI_DEFAULT; 7937e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7947e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_pack_struct(&l3cr2, GENX(L3CNTLREG2), 7957e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .SLMEnable = has_slm, 7967e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .URBLowBandwidth = urb_low_bw, 7977e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .URBAllocation = cfg->n[GEN_L3P_URB], 7987e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#if !GEN_IS_HASWELL 7997e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ALLAllocation = cfg->n[GEN_L3P_ALL], 8007e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#endif 8017e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ROAllocation = cfg->n[GEN_L3P_RO], 8027e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .DCAllocation = cfg->n[GEN_L3P_DC]); 8037e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 8047e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_pack_struct(&l3cr3, GENX(L3CNTLREG3), 8057e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ISAllocation = cfg->n[GEN_L3P_IS], 8067e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ISLowBandwidth = 0, 8077e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .CAllocation = cfg->n[GEN_L3P_C], 8087e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .CLowBandwidth = 0, 8097e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .TAllocation = cfg->n[GEN_L3P_T], 8107e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .TLowBandwidth = 0); 8117e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 8127e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* Set up the L3 partitioning. */ 8137e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand emit_lri(&cmd_buffer->batch, GENX(L3SQCREG1_num), l3sqcr1); 8147e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand emit_lri(&cmd_buffer->batch, GENX(L3CNTLREG2_num), l3cr2); 8157e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand emit_lri(&cmd_buffer->batch, GENX(L3CNTLREG3_num), l3cr3); 8167e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 8177e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#if GEN_IS_HASWELL 8187e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand if (cmd_buffer->device->instance->physicalDevice.cmd_parser_version >= 4) { 8197e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* Enable L3 atomics on HSW if we have a DC partition, otherwise keep 8207e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * them disabled to avoid crashing the system hard. 8217e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand */ 8227e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand uint32_t scratch1, chicken3; 8237e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_pack_struct(&scratch1, GENX(SCRATCH1), 8247e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .L3AtomicDisable = !has_dc); 8257e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_pack_struct(&chicken3, GENX(CHICKEN3), 82689a96c8f43370cc84adf92ab32e3de302a1fa1d0Jason Ekstrand .L3AtomicDisableMask = true, 8277e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .L3AtomicDisable = !has_dc); 8287e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand emit_lri(&cmd_buffer->batch, GENX(SCRATCH1_num), scratch1); 8297e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand emit_lri(&cmd_buffer->batch, GENX(CHICKEN3_num), chicken3); 8307e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand } 8317e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#endif 8327e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 8337e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#endif 8347e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 8357e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand cmd_buffer->state.current_l3_config = cfg; 8367e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand} 8377e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 8383a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrandvoid 8393a83c176eab8c513eb723554a240af1a7308d701Jason EkstrandgenX(cmd_buffer_apply_pipe_flushes)(struct anv_cmd_buffer *cmd_buffer) 8403a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand{ 8413a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand enum anv_pipe_bits bits = cmd_buffer->state.pending_pipe_bits; 8423a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8433a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand /* Flushes are pipelined while invalidations are handled immediately. 8443a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * Therefore, if we're flushing anything then we need to schedule a stall 8453a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * before any invalidations can happen. 8463a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand */ 8473a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand if (bits & ANV_PIPE_FLUSH_BITS) 8483a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits |= ANV_PIPE_NEEDS_CS_STALL_BIT; 8493a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8503a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand /* If we're going to do an invalidate and we have a pending CS stall that 8513a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * has yet to be resolved, we do the CS stall now. 8523a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand */ 8533a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand if ((bits & ANV_PIPE_INVALIDATE_BITS) && 8543a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand (bits & ANV_PIPE_NEEDS_CS_STALL_BIT)) { 8553a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits |= ANV_PIPE_CS_STALL_BIT; 8563a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits &= ~ANV_PIPE_NEEDS_CS_STALL_BIT; 8573a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand } 8583a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8593a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand if (bits & (ANV_PIPE_FLUSH_BITS | ANV_PIPE_CS_STALL_BIT)) { 8603a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pipe) { 8613a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.DepthCacheFlushEnable = bits & ANV_PIPE_DEPTH_CACHE_FLUSH_BIT; 8623a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.DCFlushEnable = bits & ANV_PIPE_DATA_CACHE_FLUSH_BIT; 8633a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.RenderTargetCacheFlushEnable = 8643a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits & ANV_PIPE_RENDER_TARGET_CACHE_FLUSH_BIT; 8653a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8663a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.DepthStallEnable = bits & ANV_PIPE_DEPTH_STALL_BIT; 8673a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.CommandStreamerStallEnable = bits & ANV_PIPE_CS_STALL_BIT; 8683a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.StallAtPixelScoreboard = bits & ANV_PIPE_STALL_AT_SCOREBOARD_BIT; 8693a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8703a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand /* 8713a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * According to the Broadwell documentation, any PIPE_CONTROL with the 8723a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * "Command Streamer Stall" bit set must also have another bit set, 8733a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * with five different options: 8743a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * 8753a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * - Render Target Cache Flush 8763a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * - Depth Cache Flush 8773a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * - Stall at Pixel Scoreboard 8783a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * - Post-Sync Operation 8793a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * - Depth Stall 8803a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * - DC Flush Enable 8813a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * 8823a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * I chose "Stall at Pixel Scoreboard" since that's what we use in 8833a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * mesa and it seems to work fine. The choice is fairly arbitrary. 8843a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand */ 8853a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand if ((bits & ANV_PIPE_CS_STALL_BIT) && 8863a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand !(bits & (ANV_PIPE_FLUSH_BITS | ANV_PIPE_DEPTH_STALL_BIT | 8873a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand ANV_PIPE_STALL_AT_SCOREBOARD_BIT))) 8883a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.StallAtPixelScoreboard = true; 8893a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand } 8903a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8913a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits &= ~(ANV_PIPE_FLUSH_BITS | ANV_PIPE_CS_STALL_BIT); 8923a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand } 8933a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8943a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand if (bits & ANV_PIPE_INVALIDATE_BITS) { 8953a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pipe) { 8963a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.StateCacheInvalidationEnable = 8973a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits & ANV_PIPE_STATE_CACHE_INVALIDATE_BIT; 8983a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.ConstantCacheInvalidationEnable = 8993a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits & ANV_PIPE_CONSTANT_CACHE_INVALIDATE_BIT; 9003a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.VFCacheInvalidationEnable = 9013a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits & ANV_PIPE_VF_CACHE_INVALIDATE_BIT; 9023a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.TextureCacheInvalidationEnable = 9033a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits & ANV_PIPE_TEXTURE_CACHE_INVALIDATE_BIT; 9043a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.InstructionCacheInvalidateEnable = 9053a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits & ANV_PIPE_INSTRUCTION_CACHE_INVALIDATE_BIT; 9063a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand } 9073a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 9083a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits &= ~ANV_PIPE_INVALIDATE_BITS; 9093a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand } 9103a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 9113a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand cmd_buffer->state.pending_pipe_bits = bits; 9123a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand} 9133a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 9146f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrandvoid genX(CmdPipelineBarrier)( 915a89a485e79ad40793a85979d86d45760362be21aJason Ekstrand VkCommandBuffer commandBuffer, 9166f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand VkPipelineStageFlags srcStageMask, 9176f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand VkPipelineStageFlags destStageMask, 9186f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand VkBool32 byRegion, 919c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand uint32_t memoryBarrierCount, 920c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand const VkMemoryBarrier* pMemoryBarriers, 921c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand uint32_t bufferMemoryBarrierCount, 922c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand const VkBufferMemoryBarrier* pBufferMemoryBarriers, 923c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand uint32_t imageMemoryBarrierCount, 924c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand const VkImageMemoryBarrier* pImageMemoryBarriers) 9256f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand{ 926a89a485e79ad40793a85979d86d45760362be21aJason Ekstrand ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 9273a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand uint32_t b; 9286f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 9296f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand /* XXX: Right now, we're really dumb and just flush whatever categories 9306f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * the app asks for. One of these days we may make this a bit better 9316f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * but right now that's all the hardware allows for in most areas. 9326f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand */ 933b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand VkAccessFlags src_flags = 0; 934b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand VkAccessFlags dst_flags = 0; 9356f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 936c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand for (uint32_t i = 0; i < memoryBarrierCount; i++) { 937c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand src_flags |= pMemoryBarriers[i].srcAccessMask; 938c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand dst_flags |= pMemoryBarriers[i].dstAccessMask; 939c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand } 940c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand 941c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand for (uint32_t i = 0; i < bufferMemoryBarrierCount; i++) { 942c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand src_flags |= pBufferMemoryBarriers[i].srcAccessMask; 943c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand dst_flags |= pBufferMemoryBarriers[i].dstAccessMask; 944c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand } 945c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand 946c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand for (uint32_t i = 0; i < imageMemoryBarrierCount; i++) { 947c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand src_flags |= pImageMemoryBarriers[i].srcAccessMask; 948c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand dst_flags |= pImageMemoryBarriers[i].dstAccessMask; 94958af6156360a309578241acba949e540acf72cb1Nanley Chery ANV_FROM_HANDLE(anv_image, image, pImageMemoryBarriers[i].image); 95058af6156360a309578241acba949e540acf72cb1Nanley Chery if (pImageMemoryBarriers[i].subresourceRange.aspectMask & 95158af6156360a309578241acba949e540acf72cb1Nanley Chery VK_IMAGE_ASPECT_DEPTH_BIT) { 95258af6156360a309578241acba949e540acf72cb1Nanley Chery transition_depth_buffer(cmd_buffer, image, 95358af6156360a309578241acba949e540acf72cb1Nanley Chery pImageMemoryBarriers[i].oldLayout, 95458af6156360a309578241acba949e540acf72cb1Nanley Chery pImageMemoryBarriers[i].newLayout); 95558af6156360a309578241acba949e540acf72cb1Nanley Chery } 9566f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand } 9576f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 9583a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand enum anv_pipe_bits pipe_bits = 0; 9595e92e91c6177bfe31214b8a0ebd0d4c47969b61dKristian Høgsberg 960924fbfc9a1fc46a3698fa23649e6dccc3e3e6782Jason Ekstrand for_each_bit(b, src_flags) { 961b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand switch ((VkAccessFlagBits)(1 << b)) { 962b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_SHADER_WRITE_BIT: 9633a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_DATA_CACHE_FLUSH_BIT; 9646f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand break; 965b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT: 9663a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_RENDER_TARGET_CACHE_FLUSH_BIT; 9676f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand break; 968b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: 9693a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_DEPTH_CACHE_FLUSH_BIT; 9706f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand break; 971b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_TRANSFER_WRITE_BIT: 9723a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_RENDER_TARGET_CACHE_FLUSH_BIT; 9733a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_DEPTH_CACHE_FLUSH_BIT; 9746f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand break; 9756f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand default: 9763a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand break; /* Nothing to do */ 9776f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand } 9786f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand } 9796f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 980924fbfc9a1fc46a3698fa23649e6dccc3e3e6782Jason Ekstrand for_each_bit(b, dst_flags) { 981b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand switch ((VkAccessFlagBits)(1 << b)) { 982b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_INDIRECT_COMMAND_READ_BIT: 983b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_INDEX_READ_BIT: 984b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT: 9853a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_VF_CACHE_INVALIDATE_BIT; 9866f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand break; 987b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_UNIFORM_READ_BIT: 9883a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_CONSTANT_CACHE_INVALIDATE_BIT; 9893a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_TEXTURE_CACHE_INVALIDATE_BIT; 9906f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand break; 9913a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand case VK_ACCESS_SHADER_READ_BIT: 99257174d60421e9e63569335a269cd806703f5da5dJason Ekstrand case VK_ACCESS_INPUT_ATTACHMENT_READ_BIT: 993b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_TRANSFER_READ_BIT: 9943a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_TEXTURE_CACHE_INVALIDATE_BIT; 995b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand break; 996b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand default: 9973a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand break; /* Nothing to do */ 9986f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand } 9996f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand } 10006f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 10013a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand cmd_buffer->state.pending_pipe_bits |= pipe_bits; 10026f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand} 1003bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 100454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrandstatic void 100554324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrandcmd_buffer_alloc_push_constants(struct anv_cmd_buffer *cmd_buffer) 100654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand{ 100754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand VkShaderStageFlags stages = cmd_buffer->state.pipeline->active_stages; 100854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 100954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand /* In order to avoid thrash, we assume that vertex and fragment stages 101054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * always exist. In the rare case where one is missing *and* the other 101154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * uses push concstants, this may be suboptimal. However, avoiding stalls 101254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * seems more important. 101354324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand */ 101454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand stages |= VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_VERTEX_BIT; 101554324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 101654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand if (stages == cmd_buffer->state.push_constant_stages) 101754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand return; 101854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 101954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand#if GEN_GEN >= 8 102054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand const unsigned push_constant_kb = 32; 102154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand#elif GEN_IS_HASWELL 102254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand const unsigned push_constant_kb = cmd_buffer->device->info.gt == 3 ? 32 : 16; 102354324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand#else 102454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand const unsigned push_constant_kb = 16; 102554324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand#endif 102654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 102754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand const unsigned num_stages = 102854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand _mesa_bitcount(stages & VK_SHADER_STAGE_ALL_GRAPHICS); 102954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand unsigned size_per_stage = push_constant_kb / num_stages; 103054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 103154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand /* Broadwell+ and Haswell gt3 require that the push constant sizes be in 103254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * units of 2KB. Incidentally, these are the same platforms that have 103354324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * 32KB worth of push constant space. 103454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand */ 103554324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand if (push_constant_kb == 32) 103654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand size_per_stage &= ~1u; 103754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 103854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand uint32_t kb_used = 0; 103954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand for (int i = MESA_SHADER_VERTEX; i < MESA_SHADER_FRAGMENT; i++) { 104054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand unsigned push_size = (stages & (1 << i)) ? size_per_stage : 0; 104154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, 104254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand GENX(3DSTATE_PUSH_CONSTANT_ALLOC_VS), alloc) { 104354324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand alloc._3DCommandSubOpcode = 18 + i; 104454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand alloc.ConstantBufferOffset = (push_size > 0) ? kb_used : 0; 104554324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand alloc.ConstantBufferSize = push_size; 104654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand } 104754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand kb_used += push_size; 104854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand } 104954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 105054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, 105154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand GENX(3DSTATE_PUSH_CONSTANT_ALLOC_PS), alloc) { 105254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand alloc.ConstantBufferOffset = kb_used; 105354324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand alloc.ConstantBufferSize = push_constant_kb - kb_used; 105454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand } 105554324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 105654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand cmd_buffer->state.push_constant_stages = stages; 105754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 105854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand /* From the BDW PRM for 3DSTATE_PUSH_CONSTANT_ALLOC_VS: 105954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * 106054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * "The 3DSTATE_CONSTANT_VS must be reprogrammed prior to 106154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * the next 3DPRIMITIVE command after programming the 106254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * 3DSTATE_PUSH_CONSTANT_ALLOC_VS" 106354324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * 106454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * Since 3DSTATE_PUSH_CONSTANT_ALLOC_VS is programmed as part of 106554324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * pipeline setup, we need to dirty push constants. 106654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand */ 106754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand cmd_buffer->state.push_constants_dirty |= VK_SHADER_STAGE_ALL_GRAPHICS; 106854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand} 106954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 10707998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandstatic VkResult 10717998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandemit_binding_table(struct anv_cmd_buffer *cmd_buffer, 10727998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand gl_shader_stage stage, 10737998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_state *bt_state) 10747998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand{ 10757998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_subpass *subpass = cmd_buffer->state.subpass; 10767998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_pipeline *pipeline; 10777998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t bias, state_offset; 10787998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10797998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand switch (stage) { 10807998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case MESA_SHADER_COMPUTE: 10817998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand pipeline = cmd_buffer->state.compute_pipeline; 10827998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand bias = 1; 10837998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 10847998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand default: 10857998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand pipeline = cmd_buffer->state.pipeline; 10867998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand bias = 0; 10877998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 10887998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 10897998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10907998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (!anv_pipeline_has_stage(pipeline, stage)) { 10917998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *bt_state = (struct anv_state) { 0, }; 10927998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_SUCCESS; 10937998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 10947998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10957998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_pipeline_bind_map *map = &pipeline->shaders[stage]->bind_map; 10967998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (bias + map->surface_count == 0) { 10977998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *bt_state = (struct anv_state) { 0, }; 10987998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_SUCCESS; 10997998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 11007998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11017998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *bt_state = anv_cmd_buffer_alloc_binding_table(cmd_buffer, 11027998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand bias + map->surface_count, 11037998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand &state_offset); 11047998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t *bt_map = bt_state->map; 11057998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11067998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (bt_state->map == NULL) 11077998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_ERROR_OUT_OF_DEVICE_MEMORY; 11087998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11097998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (stage == MESA_SHADER_COMPUTE && 11107998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand get_cs_prog_data(cmd_buffer->state.compute_pipeline)->uses_num_work_groups) { 11117998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_bo *bo = cmd_buffer->state.num_workgroups_bo; 11127998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t bo_offset = cmd_buffer->state.num_workgroups_offset; 11137998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11147998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_state surface_state; 11157998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand surface_state = 11167998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_cmd_buffer_alloc_surface_state(cmd_buffer); 11177998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11187998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand const enum isl_format format = 11197998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_isl_format_for_descriptor_type(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER); 11207998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_fill_buffer_surface_state(cmd_buffer->device, surface_state, 11217998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand format, bo_offset, 12, 1); 11227998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11237998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand bt_map[0] = surface_state.offset + state_offset; 11249be9f5f1c71a5c8942b1f41d0512479a9899df42Jason Ekstrand add_surface_state_reloc(cmd_buffer, surface_state, bo, bo_offset); 11257998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 11267998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11277998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (map->surface_count == 0) 11287998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand goto out; 11297998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11307998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (map->image_count > 0) { 11317998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand VkResult result = 11327998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_cmd_buffer_ensure_push_constant_field(cmd_buffer, stage, images); 11337998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (result != VK_SUCCESS) 11347998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return result; 11357998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11367998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand cmd_buffer->state.push_constants_dirty |= 1 << stage; 11377998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 11387998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11397998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t image = 0; 11407998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand for (uint32_t s = 0; s < map->surface_count; s++) { 11417998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_pipeline_binding *binding = &map->surface_to_descriptor[s]; 11427998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11437998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_state surface_state; 11447998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11457998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (binding->set == ANV_DESCRIPTOR_SET_COLOR_ATTACHMENTS) { 11467998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand /* Color attachment binding */ 11477998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(stage == MESA_SHADER_FRAGMENT); 11487998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(binding->binding == 0); 11497998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (binding->index < subpass->color_count) { 1150d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand const unsigned att = subpass->color_attachments[binding->index]; 1151d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand surface_state = cmd_buffer->state.attachments[att].color_rt_state; 11527998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } else { 1153d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand surface_state = cmd_buffer->state.null_surface_state; 11547998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 11557998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11567998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand bt_map[bias + s] = surface_state.offset + state_offset; 11577998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand continue; 11587998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 11597998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11607998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_descriptor_set *set = 11617998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand cmd_buffer->state.descriptors[binding->set]; 11627998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t offset = set->layout->binding[binding->binding].descriptor_index; 11637998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_descriptor *desc = &set->descriptors[offset + binding->index]; 11647998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11657998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand switch (desc->type) { 11667998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_SAMPLER: 11677998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand /* Nothing for us to do here */ 11687998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand continue; 11697998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11707998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: 11717998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: 11727998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand surface_state = desc->image_view->sampler_surface_state; 11737998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(surface_state.alloc_size); 1174338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand add_image_view_relocs(cmd_buffer, desc->image_view, 1175edb7f67bd9c320cd47af20dc0a854e65fced7d9bJason Ekstrand desc->image_view->image->aux_usage, 1176edb7f67bd9c320cd47af20dc0a854e65fced7d9bJason Ekstrand surface_state); 11777998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 11787998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11791d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: 11801d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand assert(stage == MESA_SHADER_FRAGMENT); 118105d1c8aa020cb61b9a53cdec92fdbf4dc56f966aNanley Chery if (desc->image_view->aspect_mask != VK_IMAGE_ASPECT_COLOR_BIT) { 118205d1c8aa020cb61b9a53cdec92fdbf4dc56f966aNanley Chery /* For depth and stencil input attachments, we treat it like any 118305d1c8aa020cb61b9a53cdec92fdbf4dc56f966aNanley Chery * old texture that a user may have bound. 11841d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand */ 11851d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand surface_state = desc->image_view->sampler_surface_state; 11861d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand assert(surface_state.alloc_size); 11871d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand add_image_view_relocs(cmd_buffer, desc->image_view, 11881d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand desc->image_view->image->aux_usage, 11891d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand surface_state); 11901d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand } else { 119105d1c8aa020cb61b9a53cdec92fdbf4dc56f966aNanley Chery /* For color input attachments, we create the surface state at 119205d1c8aa020cb61b9a53cdec92fdbf4dc56f966aNanley Chery * vkBeginRenderPass time so that we can include aux and clear 119305d1c8aa020cb61b9a53cdec92fdbf4dc56f966aNanley Chery * color information. 11941d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand */ 11951d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand assert(binding->input_attachment_index < subpass->input_count); 11961d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand const unsigned subpass_att = binding->input_attachment_index; 11971d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand const unsigned att = subpass->input_attachments[subpass_att]; 11981d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand surface_state = cmd_buffer->state.attachments[att].input_att_state; 11991d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand } 12001d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand break; 12011d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand 12027998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: { 12037998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand surface_state = desc->image_view->storage_surface_state; 12047998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(surface_state.alloc_size); 1205338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand add_image_view_relocs(cmd_buffer, desc->image_view, 1206edb7f67bd9c320cd47af20dc0a854e65fced7d9bJason Ekstrand desc->image_view->image->aux_usage, 1207edb7f67bd9c320cd47af20dc0a854e65fced7d9bJason Ekstrand surface_state); 12087998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12097998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct brw_image_param *image_param = 12107998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand &cmd_buffer->state.push_constants[stage]->images[image++]; 12117998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12127998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *image_param = desc->image_view->storage_image_param; 12137998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand image_param->surface_idx = bias + s; 12147998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 12157998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 12167998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12177998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: 12187998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: 12197998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: 12207998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: 12217998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: 12227998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand surface_state = desc->buffer_view->surface_state; 12237998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(surface_state.alloc_size); 1224818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand add_surface_state_reloc(cmd_buffer, surface_state, 1225818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand desc->buffer_view->bo, 1226818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand desc->buffer_view->offset); 12277998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 12287998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12297998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: 12307998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand surface_state = desc->buffer_view->storage_surface_state; 12317998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(surface_state.alloc_size); 1232818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand add_surface_state_reloc(cmd_buffer, surface_state, 1233818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand desc->buffer_view->bo, 1234818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand desc->buffer_view->offset); 12357998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12367998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct brw_image_param *image_param = 12377998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand &cmd_buffer->state.push_constants[stage]->images[image++]; 12387998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12397998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *image_param = desc->buffer_view->storage_image_param; 12407998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand image_param->surface_idx = bias + s; 12417998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 12427998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12437998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand default: 12447998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(!"Invalid descriptor type"); 12457998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand continue; 12467998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 12477998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12487998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand bt_map[bias + s] = surface_state.offset + state_offset; 12497998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 12507998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(image == map->image_count); 12517998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12527998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand out: 12537998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (!cmd_buffer->device->info.has_llc) 12547998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_state_clflush(*bt_state); 12557998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12567998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_SUCCESS; 12577998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand} 12587998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12597998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandstatic VkResult 12607998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandemit_samplers(struct anv_cmd_buffer *cmd_buffer, 12617998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand gl_shader_stage stage, 12627998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_state *state) 12637998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand{ 12647998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_pipeline *pipeline; 12657998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12667998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (stage == MESA_SHADER_COMPUTE) 12677998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand pipeline = cmd_buffer->state.compute_pipeline; 12687998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand else 12697998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand pipeline = cmd_buffer->state.pipeline; 12707998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12717998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (!anv_pipeline_has_stage(pipeline, stage)) { 12727998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *state = (struct anv_state) { 0, }; 12737998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_SUCCESS; 12747998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 12757998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12767998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_pipeline_bind_map *map = &pipeline->shaders[stage]->bind_map; 12777998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (map->sampler_count == 0) { 12787998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *state = (struct anv_state) { 0, }; 12797998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_SUCCESS; 12807998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 12817998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12827998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t size = map->sampler_count * 16; 12837998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *state = anv_cmd_buffer_alloc_dynamic_state(cmd_buffer, size, 32); 12847998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12857998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (state->map == NULL) 12867998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_ERROR_OUT_OF_DEVICE_MEMORY; 12877998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12887998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand for (uint32_t s = 0; s < map->sampler_count; s++) { 12897998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_pipeline_binding *binding = &map->sampler_to_descriptor[s]; 12907998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_descriptor_set *set = 12917998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand cmd_buffer->state.descriptors[binding->set]; 12927998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t offset = set->layout->binding[binding->binding].descriptor_index; 12937998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_descriptor *desc = &set->descriptors[offset + binding->index]; 12947998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12957998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (desc->type != VK_DESCRIPTOR_TYPE_SAMPLER && 12967998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand desc->type != VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) 12977998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand continue; 12987998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12997998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_sampler *sampler = desc->sampler; 13007998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13017998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand /* This can happen if we have an unfilled slot since TYPE_SAMPLER 13027998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand * happens to be zero. 13037998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand */ 13047998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (sampler == NULL) 13057998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand continue; 13067998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13077998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand memcpy(state->map + (s * 16), 13087998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand sampler->state, sizeof(sampler->state)); 13097998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 13107998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13117998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (!cmd_buffer->device->info.has_llc) 13127998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_state_clflush(*state); 13137998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13147998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_SUCCESS; 13157998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand} 13167998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13177998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandstatic uint32_t 13187998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandflush_descriptor_sets(struct anv_cmd_buffer *cmd_buffer) 13197998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand{ 13207998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand VkShaderStageFlags dirty = cmd_buffer->state.descriptors_dirty & 13217998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand cmd_buffer->state.pipeline->active_stages; 13227998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13237998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand VkResult result = VK_SUCCESS; 13247998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_foreach_stage(s, dirty) { 13257998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand result = emit_samplers(cmd_buffer, s, &cmd_buffer->state.samplers[s]); 13267998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (result != VK_SUCCESS) 13277998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 13287998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand result = emit_binding_table(cmd_buffer, s, 13297998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand &cmd_buffer->state.binding_tables[s]); 13307998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (result != VK_SUCCESS) 13317998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 13327998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 13337998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13347998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (result != VK_SUCCESS) { 13357998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(result == VK_ERROR_OUT_OF_DEVICE_MEMORY); 13367998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13377998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand result = anv_cmd_buffer_new_binding_table_block(cmd_buffer); 13387998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(result == VK_SUCCESS); 13397998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13407998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand /* Re-emit state base addresses so we get the new surface state base 13417998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand * address before we start emitting binding tables etc. 13427998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand */ 13437998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand genX(cmd_buffer_emit_state_base_address)(cmd_buffer); 13447998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13457998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand /* Re-emit all active binding tables */ 13467998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand dirty |= cmd_buffer->state.pipeline->active_stages; 13477998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_foreach_stage(s, dirty) { 13487998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand result = emit_samplers(cmd_buffer, s, &cmd_buffer->state.samplers[s]); 13497998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (result != VK_SUCCESS) 13507998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return result; 13517998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand result = emit_binding_table(cmd_buffer, s, 13527998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand &cmd_buffer->state.binding_tables[s]); 13537998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (result != VK_SUCCESS) 13547998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return result; 13557998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 13567998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 13577998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13587998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand cmd_buffer->state.descriptors_dirty &= ~dirty; 13597998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13607998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return dirty; 13617998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand} 13627998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13637998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandstatic void 13642bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrandcmd_buffer_emit_descriptor_pointers(struct anv_cmd_buffer *cmd_buffer, 13652bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand uint32_t stages) 13662bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand{ 13672bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand static const uint32_t sampler_state_opcodes[] = { 13682bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_VERTEX] = 43, 13692bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_TESS_CTRL] = 44, /* HS */ 13702bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_TESS_EVAL] = 45, /* DS */ 13712bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_GEOMETRY] = 46, 13722bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_FRAGMENT] = 47, 13732bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_COMPUTE] = 0, 13742bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand }; 13752bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand 13762bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand static const uint32_t binding_table_opcodes[] = { 13772bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_VERTEX] = 38, 13782bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_TESS_CTRL] = 39, 13792bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_TESS_EVAL] = 40, 13802bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_GEOMETRY] = 41, 13812bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_FRAGMENT] = 42, 13822bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_COMPUTE] = 0, 13832bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand }; 13842bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand 13852bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand anv_foreach_stage(s, stages) { 13862bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand if (cmd_buffer->state.samplers[s].alloc_size > 0) { 13872bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand anv_batch_emit(&cmd_buffer->batch, 13882bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand GENX(3DSTATE_SAMPLER_STATE_POINTERS_VS), ssp) { 13892bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand ssp._3DCommandSubOpcode = sampler_state_opcodes[s]; 13902bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand ssp.PointertoVSSamplerState = cmd_buffer->state.samplers[s].offset; 13912bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand } 13922bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand } 13932bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand 13942bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand /* Always emit binding table pointers if we're asked to, since on SKL 13952bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand * this is what flushes push constants. */ 13962bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand anv_batch_emit(&cmd_buffer->batch, 13972bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand GENX(3DSTATE_BINDING_TABLE_POINTERS_VS), btp) { 13982bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand btp._3DCommandSubOpcode = binding_table_opcodes[s]; 13992bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand btp.PointertoVSBindingTable = cmd_buffer->state.binding_tables[s].offset; 14002bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand } 14012bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand } 14022bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand} 14032bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand 1404248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrandstatic uint32_t 1405248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrandcmd_buffer_flush_push_constants(struct anv_cmd_buffer *cmd_buffer) 1406248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand{ 1407248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand static const uint32_t push_constant_opcodes[] = { 1408248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand [MESA_SHADER_VERTEX] = 21, 1409248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand [MESA_SHADER_TESS_CTRL] = 25, /* HS */ 1410248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand [MESA_SHADER_TESS_EVAL] = 26, /* DS */ 1411248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand [MESA_SHADER_GEOMETRY] = 22, 1412248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand [MESA_SHADER_FRAGMENT] = 23, 1413248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand [MESA_SHADER_COMPUTE] = 0, 1414248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand }; 1415248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1416248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand VkShaderStageFlags flushed = 0; 1417248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1418248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand anv_foreach_stage(stage, cmd_buffer->state.push_constants_dirty) { 1419248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (stage == MESA_SHADER_COMPUTE) 1420248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand continue; 1421248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1422248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand struct anv_state state = anv_cmd_buffer_push_constants(cmd_buffer, stage); 1423248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1424248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (state.offset == 0) { 142550018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_CONSTANT_VS), c) 142606fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand c._3DCommandSubOpcode = push_constant_opcodes[stage]; 1427248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } else { 142850018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_CONSTANT_VS), c) { 142906fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand c._3DCommandSubOpcode = push_constant_opcodes[stage], 143006fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand c.ConstantBody = (struct GENX(3DSTATE_CONSTANT_BODY)) { 1431248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#if GEN_GEN >= 9 143206fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand .PointerToConstantBuffer2 = { &cmd_buffer->device->dynamic_state_block_pool.bo, state.offset }, 143306fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand .ConstantBuffer2ReadLength = DIV_ROUND_UP(state.alloc_size, 32), 1434248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#else 143506fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand .PointerToConstantBuffer0 = { .offset = state.offset }, 143606fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand .ConstantBuffer0ReadLength = DIV_ROUND_UP(state.alloc_size, 32), 1437248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#endif 143806fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand }; 143906fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand } 1440248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1441248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1442248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand flushed |= mesa_to_vk_shader_stage(stage); 1443248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1444248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1445248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand cmd_buffer->state.push_constants_dirty &= ~VK_SHADER_STAGE_ALL_GRAPHICS; 1446248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1447248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand return flushed; 1448248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand} 1449248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1450248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrandvoid 1451248ab61740c4082517424f5aa94b2f4e7b210d76Jason EkstrandgenX(cmd_buffer_flush_state)(struct anv_cmd_buffer *cmd_buffer) 1452248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand{ 1453248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand struct anv_pipeline *pipeline = cmd_buffer->state.pipeline; 1454248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand uint32_t *p; 1455248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1456248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand uint32_t vb_emit = cmd_buffer->state.vb_dirty & pipeline->vb_used; 1457248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1458248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand assert((pipeline->active_stages & VK_SHADER_STAGE_COMPUTE_BIT) == 0); 1459248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 14607e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand genX(cmd_buffer_config_l3)(cmd_buffer, pipeline->urb.l3_config); 1461248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1462248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand genX(flush_pipeline_select_3d)(cmd_buffer); 1463248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1464248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (vb_emit) { 1465248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand const uint32_t num_buffers = __builtin_popcount(vb_emit); 1466248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand const uint32_t num_dwords = 1 + num_buffers * 4; 1467248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1468248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand p = anv_batch_emitn(&cmd_buffer->batch, num_dwords, 1469248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand GENX(3DSTATE_VERTEX_BUFFERS)); 1470248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand uint32_t vb, i = 0; 1471248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand for_each_bit(vb, vb_emit) { 1472248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand struct anv_buffer *buffer = cmd_buffer->state.vertex_bindings[vb].buffer; 1473248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand uint32_t offset = cmd_buffer->state.vertex_bindings[vb].offset; 1474248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1475248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand struct GENX(VERTEX_BUFFER_STATE) state = { 1476248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .VertexBufferIndex = vb, 1477248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1478248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#if GEN_GEN >= 8 1479248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .MemoryObjectControlState = GENX(MOCS), 1480248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#else 1481248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .BufferAccessType = pipeline->instancing_enable[vb] ? INSTANCEDATA : VERTEXDATA, 1482248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .InstanceDataStepRate = 1, 1483248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .VertexBufferMemoryObjectControlState = GENX(MOCS), 1484248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#endif 1485248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1486248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .AddressModifyEnable = true, 1487248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .BufferPitch = pipeline->binding_stride[vb], 1488248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .BufferStartingAddress = { buffer->bo, buffer->offset + offset }, 1489248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1490248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#if GEN_GEN >= 8 1491248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .BufferSize = buffer->size - offset 1492248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#else 1493248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .EndAddress = { buffer->bo, buffer->offset + buffer->size - 1}, 1494248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#endif 1495248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand }; 1496248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1497248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand GENX(VERTEX_BUFFER_STATE_pack)(&cmd_buffer->batch, &p[1 + i * 4], &state); 1498248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand i++; 1499248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1500248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1501248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1502248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand cmd_buffer->state.vb_dirty &= ~vb_emit; 1503248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1504248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (cmd_buffer->state.dirty & ANV_CMD_DIRTY_PIPELINE) { 1505248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand anv_batch_emit_batch(&cmd_buffer->batch, &pipeline->batch); 1506248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 150735b53c8d47d3a0b53ee2549d73296d5db8e3cca0Jason Ekstrand /* The exact descriptor layout is pulled from the pipeline, so we need 150835b53c8d47d3a0b53ee2549d73296d5db8e3cca0Jason Ekstrand * to re-emit binding tables on every pipeline change. 150935b53c8d47d3a0b53ee2549d73296d5db8e3cca0Jason Ekstrand */ 151035b53c8d47d3a0b53ee2549d73296d5db8e3cca0Jason Ekstrand cmd_buffer->state.descriptors_dirty |= 151135b53c8d47d3a0b53ee2549d73296d5db8e3cca0Jason Ekstrand cmd_buffer->state.pipeline->active_stages; 151235b53c8d47d3a0b53ee2549d73296d5db8e3cca0Jason Ekstrand 151354324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand /* If the pipeline changed, we may need to re-allocate push constant 151454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * space in the URB. 1515248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand */ 151654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand cmd_buffer_alloc_push_constants(cmd_buffer); 1517248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1518248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1519248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#if GEN_GEN <= 7 1520248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (cmd_buffer->state.descriptors_dirty & VK_SHADER_STAGE_VERTEX_BIT || 1521248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand cmd_buffer->state.push_constants_dirty & VK_SHADER_STAGE_VERTEX_BIT) { 1522248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand /* From the IVB PRM Vol. 2, Part 1, Section 3.2.1: 1523248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * 1524248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * "A PIPE_CONTROL with Post-Sync Operation set to 1h and a depth 1525248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * stall needs to be sent just prior to any 3DSTATE_VS, 1526248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * 3DSTATE_URB_VS, 3DSTATE_CONSTANT_VS, 1527248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * 3DSTATE_BINDING_TABLE_POINTER_VS, 1528248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * 3DSTATE_SAMPLER_STATE_POINTER_VS command. Only one 1529248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * PIPE_CONTROL needs to be sent before any combination of VS 1530248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * associated 3DSTATE." 1531248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand */ 153250018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 153356453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DepthStallEnable = true; 153456453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.PostSyncOperation = WriteImmediateData; 153556453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.Address = 153656453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand (struct anv_address) { &cmd_buffer->device->workaround_bo, 0 }; 153756453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 1538248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1539248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#endif 1540248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1541fe4e276b02615b5db8acbf4c65fcfa68982e2e0fJason Ekstrand /* Render targets live in the same binding table as fragment descriptors */ 1542fe4e276b02615b5db8acbf4c65fcfa68982e2e0fJason Ekstrand if (cmd_buffer->state.dirty & ANV_CMD_DIRTY_RENDER_TARGETS) 1543fe4e276b02615b5db8acbf4c65fcfa68982e2e0fJason Ekstrand cmd_buffer->state.descriptors_dirty |= VK_SHADER_STAGE_FRAGMENT_BIT; 1544fe4e276b02615b5db8acbf4c65fcfa68982e2e0fJason Ekstrand 1545248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand /* We emit the binding tables and sampler tables first, then emit push 1546248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * constants and then finally emit binding table and sampler table 1547248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * pointers. It has to happen in this order, since emitting the binding 1548248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * tables may change the push constants (in case of storage images). After 1549248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * emitting push constants, on SKL+ we have to emit the corresponding 1550248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * 3DSTATE_BINDING_TABLE_POINTER_* for the push constants to take effect. 1551248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand */ 1552248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand uint32_t dirty = 0; 1553248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (cmd_buffer->state.descriptors_dirty) 15547998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand dirty = flush_descriptor_sets(cmd_buffer); 1555248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1556248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (cmd_buffer->state.push_constants_dirty) { 1557248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#if GEN_GEN >= 9 1558248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand /* On Sky Lake and later, the binding table pointers commands are 1559248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * what actually flush the changes to push constant state so we need 1560248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * to dirty them so they get re-emitted below. 1561248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand */ 1562248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand dirty |= cmd_buffer_flush_push_constants(cmd_buffer); 1563248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#else 1564248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand cmd_buffer_flush_push_constants(cmd_buffer); 1565248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#endif 1566248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1567248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1568248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (dirty) 15692bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand cmd_buffer_emit_descriptor_pointers(cmd_buffer, dirty); 1570248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1571eb6764c4a73006eee32e19e3afc6eab100a2ce16Jason Ekstrand if (cmd_buffer->state.dirty & ANV_CMD_DIRTY_DYNAMIC_VIEWPORT) 1572248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand gen8_cmd_buffer_emit_viewport(cmd_buffer); 1573eb6764c4a73006eee32e19e3afc6eab100a2ce16Jason Ekstrand 1574eb6764c4a73006eee32e19e3afc6eab100a2ce16Jason Ekstrand if (cmd_buffer->state.dirty & (ANV_CMD_DIRTY_DYNAMIC_VIEWPORT | 1575eb6764c4a73006eee32e19e3afc6eab100a2ce16Jason Ekstrand ANV_CMD_DIRTY_PIPELINE)) { 1576eb6764c4a73006eee32e19e3afc6eab100a2ce16Jason Ekstrand gen8_cmd_buffer_emit_depth_viewport(cmd_buffer, 1577eb6764c4a73006eee32e19e3afc6eab100a2ce16Jason Ekstrand pipeline->depth_clamp_enable); 15788a46b505cb2c7255ad430b56c1ce0dfa9c13c559Jason Ekstrand } 1579248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1580248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (cmd_buffer->state.dirty & ANV_CMD_DIRTY_DYNAMIC_SCISSOR) 1581248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand gen7_cmd_buffer_emit_scissor(cmd_buffer); 1582248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1583248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand genX(cmd_buffer_flush_dynamic_state)(cmd_buffer); 15843a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 15853a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand genX(cmd_buffer_apply_pipe_flushes)(cmd_buffer); 1586248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand} 1587248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1588bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergstatic void 1589bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergemit_base_vertex_instance_bo(struct anv_cmd_buffer *cmd_buffer, 1590bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_bo *bo, uint32_t offset) 1591bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg{ 1592bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t *p = anv_batch_emitn(&cmd_buffer->batch, 5, 1593bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg GENX(3DSTATE_VERTEX_BUFFERS)); 1594bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1595bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg GENX(VERTEX_BUFFER_STATE_pack)(&cmd_buffer->batch, p + 1, 1596bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg &(struct GENX(VERTEX_BUFFER_STATE)) { 1597bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .VertexBufferIndex = 32, /* Reserved for this */ 1598bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .AddressModifyEnable = true, 1599bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .BufferPitch = 0, 1600371b4a5b33a13f35fa7783510d2d90685a9a2e8aJason Ekstrand#if (GEN_GEN >= 8) 1601bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .MemoryObjectControlState = GENX(MOCS), 1602bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .BufferStartingAddress = { bo, offset }, 1603bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .BufferSize = 8 1604bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#else 1605bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .VertexBufferMemoryObjectControlState = GENX(MOCS), 1606bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .BufferStartingAddress = { bo, offset }, 1607bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .EndAddress = { bo, offset + 8 }, 1608bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#endif 1609bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg }); 1610bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg} 1611bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1612bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergstatic void 1613bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergemit_base_vertex_instance(struct anv_cmd_buffer *cmd_buffer, 1614bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t base_vertex, uint32_t base_instance) 1615bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg{ 1616bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_state id_state = 1617bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg anv_cmd_buffer_alloc_dynamic_state(cmd_buffer, 8, 4); 1618bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1619bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ((uint32_t *)id_state.map)[0] = base_vertex; 1620bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ((uint32_t *)id_state.map)[1] = base_instance; 1621bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1622bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg if (!cmd_buffer->device->info.has_llc) 1623bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg anv_state_clflush(id_state); 1624bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1625bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_base_vertex_instance_bo(cmd_buffer, 1626bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg &cmd_buffer->device->dynamic_state_block_pool.bo, id_state.offset); 1627bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg} 1628bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1629bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergvoid genX(CmdDraw)( 1630bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkCommandBuffer commandBuffer, 1631bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t vertexCount, 1632bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t instanceCount, 1633bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t firstVertex, 1634bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t firstInstance) 1635bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg{ 1636bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 1637bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_pipeline *pipeline = cmd_buffer->state.pipeline; 16382b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg const struct brw_vs_prog_data *vs_prog_data = get_vs_prog_data(pipeline); 1639bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1640bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg genX(cmd_buffer_flush_state)(cmd_buffer); 1641bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 16422b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg if (vs_prog_data->uses_basevertex || vs_prog_data->uses_baseinstance) 1643bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_base_vertex_instance(cmd_buffer, firstVertex, firstInstance); 1644bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 164550018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DPRIMITIVE), prim) { 16461d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.VertexAccessType = SEQUENTIAL; 16471d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.PrimitiveTopologyType = pipeline->topology; 16481d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.VertexCountPerInstance = vertexCount; 16491d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.StartVertexLocation = firstVertex; 16501d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.InstanceCount = instanceCount; 16511d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.StartInstanceLocation = firstInstance; 16521d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.BaseVertexLocation = 0; 16531d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand } 1654bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg} 1655bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1656bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergvoid genX(CmdDrawIndexed)( 1657bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkCommandBuffer commandBuffer, 1658bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t indexCount, 1659bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t instanceCount, 1660bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t firstIndex, 1661bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg int32_t vertexOffset, 1662bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t firstInstance) 1663bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg{ 1664bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 1665bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_pipeline *pipeline = cmd_buffer->state.pipeline; 16662b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg const struct brw_vs_prog_data *vs_prog_data = get_vs_prog_data(pipeline); 1667bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1668bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg genX(cmd_buffer_flush_state)(cmd_buffer); 1669bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 16702b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg if (vs_prog_data->uses_basevertex || vs_prog_data->uses_baseinstance) 1671bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_base_vertex_instance(cmd_buffer, vertexOffset, firstInstance); 1672bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 167350018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DPRIMITIVE), prim) { 16741d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.VertexAccessType = RANDOM; 16751d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.PrimitiveTopologyType = pipeline->topology; 16761d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.VertexCountPerInstance = indexCount; 16771d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.StartVertexLocation = firstIndex; 16781d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.InstanceCount = instanceCount; 16791d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.StartInstanceLocation = firstInstance; 16801d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.BaseVertexLocation = vertexOffset; 16811d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand } 1682bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg} 1683bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1684bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg/* Auto-Draw / Indirect Registers */ 1685bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#define GEN7_3DPRIM_END_OFFSET 0x2420 1686bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#define GEN7_3DPRIM_START_VERTEX 0x2430 1687bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#define GEN7_3DPRIM_VERTEX_COUNT 0x2434 1688bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#define GEN7_3DPRIM_INSTANCE_COUNT 0x2438 1689bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#define GEN7_3DPRIM_START_INSTANCE 0x243C 1690bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#define GEN7_3DPRIM_BASE_VERTEX 0x2440 1691bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1692bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergvoid genX(CmdDrawIndirect)( 1693bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkCommandBuffer commandBuffer, 1694bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkBuffer _buffer, 1695bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkDeviceSize offset, 1696bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t drawCount, 1697bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t stride) 1698bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg{ 1699bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 1700bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ANV_FROM_HANDLE(anv_buffer, buffer, _buffer); 1701bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_pipeline *pipeline = cmd_buffer->state.pipeline; 17022b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg const struct brw_vs_prog_data *vs_prog_data = get_vs_prog_data(pipeline); 1703bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_bo *bo = buffer->bo; 1704bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t bo_offset = buffer->offset + offset; 1705bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1706bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg genX(cmd_buffer_flush_state)(cmd_buffer); 1707bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 17082b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg if (vs_prog_data->uses_basevertex || vs_prog_data->uses_baseinstance) 1709bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_base_vertex_instance_bo(cmd_buffer, bo, bo_offset + 8); 1710bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1711bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_VERTEX_COUNT, bo, bo_offset); 1712bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_INSTANCE_COUNT, bo, bo_offset + 4); 1713bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_START_VERTEX, bo, bo_offset + 8); 1714bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_START_INSTANCE, bo, bo_offset + 12); 1715bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lri(&cmd_buffer->batch, GEN7_3DPRIM_BASE_VERTEX, 0); 1716bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 171750018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DPRIMITIVE), prim) { 17181d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.IndirectParameterEnable = true; 17191d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.VertexAccessType = SEQUENTIAL; 17201d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.PrimitiveTopologyType = pipeline->topology; 17211d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand } 1722bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg} 1723bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1724bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergvoid genX(CmdDrawIndexedIndirect)( 1725bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkCommandBuffer commandBuffer, 1726bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkBuffer _buffer, 1727bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkDeviceSize offset, 1728bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t drawCount, 1729bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t stride) 1730bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg{ 1731bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 1732bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ANV_FROM_HANDLE(anv_buffer, buffer, _buffer); 1733bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_pipeline *pipeline = cmd_buffer->state.pipeline; 17342b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg const struct brw_vs_prog_data *vs_prog_data = get_vs_prog_data(pipeline); 1735bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_bo *bo = buffer->bo; 1736bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t bo_offset = buffer->offset + offset; 1737bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1738bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg genX(cmd_buffer_flush_state)(cmd_buffer); 1739bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1740bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg /* TODO: We need to stomp base vertex to 0 somehow */ 17412b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg if (vs_prog_data->uses_basevertex || vs_prog_data->uses_baseinstance) 1742bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_base_vertex_instance_bo(cmd_buffer, bo, bo_offset + 12); 1743bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1744bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_VERTEX_COUNT, bo, bo_offset); 1745bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_INSTANCE_COUNT, bo, bo_offset + 4); 1746bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_START_VERTEX, bo, bo_offset + 8); 1747bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_BASE_VERTEX, bo, bo_offset + 12); 1748bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_START_INSTANCE, bo, bo_offset + 16); 1749bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 175050018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DPRIMITIVE), prim) { 17511d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.IndirectParameterEnable = true; 17521d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.VertexAccessType = RANDOM; 17531d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.PrimitiveTopologyType = pipeline->topology; 17541d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand } 1755bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg} 17566c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 17571f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrandstatic VkResult 17581f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrandflush_compute_descriptor_set(struct anv_cmd_buffer *cmd_buffer) 17591f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand{ 17601f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand struct anv_pipeline *pipeline = cmd_buffer->state.compute_pipeline; 17611f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand struct anv_state surfaces = { 0, }, samplers = { 0, }; 17621f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand VkResult result; 17631f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 17647998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand result = emit_binding_table(cmd_buffer, MESA_SHADER_COMPUTE, &surfaces); 1765722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand if (result != VK_SUCCESS) { 17663ef8dff865fd7365ba36b49c43b5c858d26587edJason Ekstrand assert(result == VK_ERROR_OUT_OF_DEVICE_MEMORY); 1767722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand result = anv_cmd_buffer_new_binding_table_block(cmd_buffer); 1768722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand assert(result == VK_SUCCESS); 1769722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand 1770722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand /* Re-emit state base addresses so we get the new surface state base 1771722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand * address before we start emitting binding tables etc. 1772722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand */ 1773722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand genX(cmd_buffer_emit_state_base_address)(cmd_buffer); 1774722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand 1775722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand result = emit_binding_table(cmd_buffer, MESA_SHADER_COMPUTE, &surfaces); 1776722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand assert(result == VK_SUCCESS); 1777722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand } 1778054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand 1779722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand result = emit_samplers(cmd_buffer, MESA_SHADER_COMPUTE, &samplers); 1780722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand assert(result == VK_SUCCESS); 1781722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand 1782d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand uint32_t iface_desc_data_dw[GENX(INTERFACE_DESCRIPTOR_DATA_length)]; 1783d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand struct GENX(INTERFACE_DESCRIPTOR_DATA) desc = { 1784d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand .BindingTablePointer = surfaces.offset, 1785d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand .SamplerStatePointer = samplers.offset, 1786d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand }; 1787d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand GENX(INTERFACE_DESCRIPTOR_DATA_pack)(NULL, iface_desc_data_dw, &desc); 17881f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 17891f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand struct anv_state state = 1790d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand anv_cmd_buffer_merge_dynamic(cmd_buffer, iface_desc_data_dw, 1791d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand pipeline->interface_descriptor_data, 1792d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand GENX(INTERFACE_DESCRIPTOR_DATA_length), 1793d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand 64); 17941f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 17951f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand uint32_t size = GENX(INTERFACE_DESCRIPTOR_DATA_length) * sizeof(uint32_t); 17961f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, 17971f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand GENX(MEDIA_INTERFACE_DESCRIPTOR_LOAD), mid) { 17981f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand mid.InterfaceDescriptorTotalLength = size; 17991f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand mid.InterfaceDescriptorDataStartAddress = state.offset; 18001f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand } 18011f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 18021f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand return VK_SUCCESS; 18031f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand} 18041f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 18051f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrandvoid 18061f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason EkstrandgenX(cmd_buffer_flush_compute_state)(struct anv_cmd_buffer *cmd_buffer) 18071f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand{ 18081f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand struct anv_pipeline *pipeline = cmd_buffer->state.compute_pipeline; 18091f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand MAYBE_UNUSED VkResult result; 18101f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 18111f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand assert(pipeline->active_stages == VK_SHADER_STAGE_COMPUTE_BIT); 18121f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 18131f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand genX(cmd_buffer_config_l3)(cmd_buffer, pipeline->urb.l3_config); 18141f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 18151f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand genX(flush_pipeline_select_gpgpu)(cmd_buffer); 18161f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 1817f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand if (cmd_buffer->state.compute_dirty & ANV_CMD_DIRTY_PIPELINE) { 1818f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand /* From the Sky Lake PRM Vol 2a, MEDIA_VFE_STATE: 1819f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand * 1820f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand * "A stalling PIPE_CONTROL is required before MEDIA_VFE_STATE unless 1821f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand * the only bits that are changed are scoreboard related: Scoreboard 1822f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand * Enable, Scoreboard Type, Scoreboard Mask, Scoreboard * Delta. For 1823f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand * these scoreboard related states, a MEDIA_STATE_FLUSH is 1824f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand * sufficient." 1825f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand */ 1826f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand cmd_buffer->state.pending_pipe_bits |= ANV_PIPE_CS_STALL_BIT; 1827f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand genX(cmd_buffer_apply_pipe_flushes)(cmd_buffer); 1828f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand 18291f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand anv_batch_emit_batch(&cmd_buffer->batch, &pipeline->batch); 1830f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand } 18311f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 18327a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand if ((cmd_buffer->state.descriptors_dirty & VK_SHADER_STAGE_COMPUTE_BIT) || 18337a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand (cmd_buffer->state.compute_dirty & ANV_CMD_DIRTY_PIPELINE)) { 18347a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand /* FIXME: figure out descriptors for gen7 */ 18357a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand result = flush_compute_descriptor_set(cmd_buffer); 18367a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand assert(result == VK_SUCCESS); 18377a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand cmd_buffer->state.descriptors_dirty &= ~VK_SHADER_STAGE_COMPUTE_BIT; 18387a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand } 18397a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand 1840054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand if (cmd_buffer->state.push_constants_dirty & VK_SHADER_STAGE_COMPUTE_BIT) { 1841054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand struct anv_state push_state = 1842054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand anv_cmd_buffer_cs_push_constants(cmd_buffer); 1843054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand 1844054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand if (push_state.alloc_size) { 1845054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(MEDIA_CURBE_LOAD), curbe) { 1846054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand curbe.CURBETotalDataLength = push_state.alloc_size; 1847054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand curbe.CURBEDataStartAddress = push_state.offset; 1848054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand } 1849054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand } 1850054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand } 1851054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand 18521f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand cmd_buffer->state.compute_dirty = 0; 18531f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 18541f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand genX(cmd_buffer_apply_pipe_flushes)(cmd_buffer); 18551f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand} 18561f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 18578dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen#if GEN_GEN == 7 18588dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen 18598dbfa265a439904628c2d875885e80bc45a90a05Jordan Justenstatic bool 18608dbfa265a439904628c2d875885e80bc45a90a05Jordan Justenverify_cmd_parser(const struct anv_device *device, 18618dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen int required_version, 18628dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen const char *function) 18638dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen{ 18648dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen if (device->instance->physicalDevice.cmd_parser_version < required_version) { 18658dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen vk_errorf(VK_ERROR_FEATURE_NOT_PRESENT, 18668dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen "cmd parser version %d is required for %s", 18678dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen required_version, function); 18688dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen return false; 18698dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen } else { 18708dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen return true; 18718dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen } 18728dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen} 18738dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen 18748dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen#endif 18756c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 18766c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsbergvoid genX(CmdDispatch)( 18776c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg VkCommandBuffer commandBuffer, 18786c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg uint32_t x, 18796c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg uint32_t y, 18806c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg uint32_t z) 18816c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg{ 18826c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 18836c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg struct anv_pipeline *pipeline = cmd_buffer->state.compute_pipeline; 18842b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg const struct brw_cs_prog_data *prog_data = get_cs_prog_data(pipeline); 18856c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 18866c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg if (prog_data->uses_num_work_groups) { 18876c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg struct anv_state state = 18886c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg anv_cmd_buffer_alloc_dynamic_state(cmd_buffer, 12, 4); 18896c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg uint32_t *sizes = state.map; 18906c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg sizes[0] = x; 18916c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg sizes[1] = y; 18926c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg sizes[2] = z; 18936c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg if (!cmd_buffer->device->info.has_llc) 18946c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg anv_state_clflush(state); 18956c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg cmd_buffer->state.num_workgroups_offset = state.offset; 18966c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg cmd_buffer->state.num_workgroups_bo = 18976c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg &cmd_buffer->device->dynamic_state_block_pool.bo; 18986c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg } 18996c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 19006c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg genX(cmd_buffer_flush_compute_state)(cmd_buffer); 19016c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 190250018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(GPGPU_WALKER), ggw) { 1903deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.SIMDSize = prog_data->simd_size / 16; 1904deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadDepthCounterMaximum = 0; 1905deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadHeightCounterMaximum = 0; 19061b79e7ebbd77a7e714fafadd91459059aacf2407Jordan Justen ggw.ThreadWidthCounterMaximum = prog_data->threads - 1; 1907deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadGroupIDXDimension = x; 1908deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadGroupIDYDimension = y; 1909deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadGroupIDZDimension = z; 1910deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.RightExecutionMask = pipeline->cs_right_mask; 1911deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.BottomExecutionMask = 0xffffffff; 1912deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 1913deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand 191450018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(MEDIA_STATE_FLUSH), msf); 19156c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg} 19166c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 19176c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg#define GPGPU_DISPATCHDIMX 0x2500 19186c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg#define GPGPU_DISPATCHDIMY 0x2504 19196c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg#define GPGPU_DISPATCHDIMZ 0x2508 19206c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 192198cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen#define MI_PREDICATE_SRC0 0x2400 192298cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen#define MI_PREDICATE_SRC1 0x2408 192398cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 19246c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsbergvoid genX(CmdDispatchIndirect)( 19256c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg VkCommandBuffer commandBuffer, 19266c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg VkBuffer _buffer, 19276c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg VkDeviceSize offset) 19286c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg{ 19296c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 19306c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg ANV_FROM_HANDLE(anv_buffer, buffer, _buffer); 19316c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg struct anv_pipeline *pipeline = cmd_buffer->state.compute_pipeline; 19322b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg const struct brw_cs_prog_data *prog_data = get_cs_prog_data(pipeline); 19336c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg struct anv_bo *bo = buffer->bo; 19346c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg uint32_t bo_offset = buffer->offset + offset; 1935da4745104cc02fc0052a2e05e37c69a4dce76eefJordan Justen struct anv_batch *batch = &cmd_buffer->batch; 19366c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 19378dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen#if GEN_GEN == 7 19388dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen /* Linux 4.4 added command parser version 5 which allows the GPGPU 19398dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen * indirect dispatch registers to be written. 19408dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen */ 1941f56f538ce4753a6fdd969b610f35433fd657e4eeJordan Justen if (!verify_cmd_parser(cmd_buffer->device, 5, "vkCmdDispatchIndirect")) 19428dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen return; 19438dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen#endif 19448dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen 19456c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg if (prog_data->uses_num_work_groups) { 19466c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg cmd_buffer->state.num_workgroups_offset = bo_offset; 19476c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg cmd_buffer->state.num_workgroups_bo = bo; 19486c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg } 19496c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 19506c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg genX(cmd_buffer_flush_compute_state)(cmd_buffer); 19516c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 1952da4745104cc02fc0052a2e05e37c69a4dce76eefJordan Justen emit_lrm(batch, GPGPU_DISPATCHDIMX, bo, bo_offset); 1953da4745104cc02fc0052a2e05e37c69a4dce76eefJordan Justen emit_lrm(batch, GPGPU_DISPATCHDIMY, bo, bo_offset + 4); 1954da4745104cc02fc0052a2e05e37c69a4dce76eefJordan Justen emit_lrm(batch, GPGPU_DISPATCHDIMZ, bo, bo_offset + 8); 19556c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 195698cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen#if GEN_GEN <= 7 195798cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* Clear upper 32-bits of SRC0 and all 64-bits of SRC1 */ 195898cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen emit_lri(batch, MI_PREDICATE_SRC0 + 4, 0); 195998cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen emit_lri(batch, MI_PREDICATE_SRC1 + 0, 0); 196098cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen emit_lri(batch, MI_PREDICATE_SRC1 + 4, 0); 196198cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 196298cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* Load compute_dispatch_indirect_x_size into SRC0 */ 196398cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen emit_lrm(batch, MI_PREDICATE_SRC0, bo, bo_offset + 0); 196498cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 196598cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* predicate = (compute_dispatch_indirect_x_size == 0); */ 196650018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_PREDICATE), mip) { 1967deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.LoadOperation = LOAD_LOAD; 1968deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CombineOperation = COMBINE_SET; 1969deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CompareOperation = COMPARE_SRCS_EQUAL; 1970deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 197198cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 197298cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* Load compute_dispatch_indirect_y_size into SRC0 */ 197398cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen emit_lrm(batch, MI_PREDICATE_SRC0, bo, bo_offset + 4); 197498cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 197598cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* predicate |= (compute_dispatch_indirect_y_size == 0); */ 197650018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_PREDICATE), mip) { 1977deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.LoadOperation = LOAD_LOAD; 1978deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CombineOperation = COMBINE_OR; 1979deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CompareOperation = COMPARE_SRCS_EQUAL; 1980deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 198198cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 198298cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* Load compute_dispatch_indirect_z_size into SRC0 */ 198398cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen emit_lrm(batch, MI_PREDICATE_SRC0, bo, bo_offset + 8); 198498cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 198598cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* predicate |= (compute_dispatch_indirect_z_size == 0); */ 198650018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_PREDICATE), mip) { 1987deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.LoadOperation = LOAD_LOAD; 1988deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CombineOperation = COMBINE_OR; 1989deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CompareOperation = COMPARE_SRCS_EQUAL; 1990deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 199198cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 199298cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* predicate = !predicate; */ 199398cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen#define COMPARE_FALSE 1 199450018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_PREDICATE), mip) { 1995deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.LoadOperation = LOAD_LOADINV; 1996deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CombineOperation = COMBINE_OR; 1997deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CompareOperation = COMPARE_FALSE; 1998deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 199998cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen#endif 200098cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 200150018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(GPGPU_WALKER), ggw) { 2002deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.IndirectParameterEnable = true; 2003deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.PredicateEnable = GEN_GEN <= 7; 2004deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.SIMDSize = prog_data->simd_size / 16; 2005deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadDepthCounterMaximum = 0; 2006deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadHeightCounterMaximum = 0; 20071b79e7ebbd77a7e714fafadd91459059aacf2407Jordan Justen ggw.ThreadWidthCounterMaximum = prog_data->threads - 1; 2008deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.RightExecutionMask = pipeline->cs_right_mask; 2009deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.BottomExecutionMask = 0xffffffff; 2010deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 2011deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand 201250018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MEDIA_STATE_FLUSH), msf); 20136c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg} 2014832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg 2015c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justenstatic void 2016c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justenflush_pipeline_before_pipeline_select(struct anv_cmd_buffer *cmd_buffer, 2017c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen uint32_t pipeline) 2018c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen{ 2019c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen#if GEN_GEN >= 8 && GEN_GEN < 10 2020c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen /* From the Broadwell PRM, Volume 2a: Instructions, PIPELINE_SELECT: 2021c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * 2022c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * Software must clear the COLOR_CALC_STATE Valid field in 2023c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * 3DSTATE_CC_STATE_POINTERS command prior to send a PIPELINE_SELECT 2024c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * with Pipeline Select set to GPGPU. 2025c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * 2026c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * The internal hardware docs recommend the same workaround for Gen9 2027c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * hardware too. 2028c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen */ 2029c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen if (pipeline == GPGPU) 203050018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_CC_STATE_POINTERS), t); 2031b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen#elif GEN_GEN <= 7 2032b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen /* From "BXML » GT » MI » vol1a GPU Overview » [Instruction] 2033b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen * PIPELINE_SELECT [DevBWR+]": 2034b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen * 2035b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen * Project: DEVSNB+ 2036b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen * 2037b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen * Software must ensure all the write caches are flushed through a 2038b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen * stalling PIPE_CONTROL command followed by another PIPE_CONTROL 2039b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen * command to invalidate read only caches prior to programming 2040b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen * MI_PIPELINE_SELECT command to change the Pipeline Select Mode. 2041b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen */ 204250018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 204356453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.RenderTargetCacheFlushEnable = true; 204456453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DepthCacheFlushEnable = true; 204556453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DCFlushEnable = true; 204656453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.PostSyncOperation = NoWrite; 204756453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.CommandStreamerStallEnable = true; 204856453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 2049b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen 205050018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 205156453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.TextureCacheInvalidationEnable = true; 205256453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.ConstantCacheInvalidationEnable = true; 205356453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.StateCacheInvalidationEnable = true; 205456453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.InstructionCacheInvalidateEnable = true; 205556453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.PostSyncOperation = NoWrite; 205656453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 2057c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen#endif 2058c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen} 2059c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen 2060832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsbergvoid 2061832f73f512e9e6c21d495d7b07e229482371ef2fKristian HøgsberggenX(flush_pipeline_select_3d)(struct anv_cmd_buffer *cmd_buffer) 2062832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg{ 2063832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg if (cmd_buffer->state.current_pipeline != _3D) { 2064c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen flush_pipeline_before_pipeline_select(cmd_buffer, _3D); 2065c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen 206650018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPELINE_SELECT), ps) { 2067371b4a5b33a13f35fa7783510d2d90685a9a2e8aJason Ekstrand#if GEN_GEN >= 9 2068deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ps.MaskBits = 3; 2069832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg#endif 2070deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ps.PipelineSelection = _3D; 2071deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 2072deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand 2073832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg cmd_buffer->state.current_pipeline = _3D; 2074832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg } 2075832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg} 207685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 20771b126305ded36f6b416ada08e29ff84faeafef99Jordan Justenvoid 20781b126305ded36f6b416ada08e29ff84faeafef99Jordan JustengenX(flush_pipeline_select_gpgpu)(struct anv_cmd_buffer *cmd_buffer) 20791b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen{ 20801b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen if (cmd_buffer->state.current_pipeline != GPGPU) { 2081c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen flush_pipeline_before_pipeline_select(cmd_buffer, GPGPU); 20821b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen 208350018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPELINE_SELECT), ps) { 20841b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen#if GEN_GEN >= 9 2085deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ps.MaskBits = 3; 20861b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen#endif 2087deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ps.PipelineSelection = GPGPU; 2088deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 2089deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand 20901b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen cmd_buffer->state.current_pipeline = GPGPU; 20911b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen } 20921b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen} 20931b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen 2094a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrandvoid 2095a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason EkstrandgenX(cmd_buffer_emit_gen7_depth_flush)(struct anv_cmd_buffer *cmd_buffer) 2096a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand{ 2097a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand if (GEN_GEN >= 8) 2098a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand return; 2099a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand 2100a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand /* From the Haswell PRM, documentation for 3DSTATE_DEPTH_BUFFER: 2101a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * 2102a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * "Restriction: Prior to changing Depth/Stencil Buffer state (i.e., any 2103a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * combination of 3DSTATE_DEPTH_BUFFER, 3DSTATE_CLEAR_PARAMS, 2104a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * 3DSTATE_STENCIL_BUFFER, 3DSTATE_HIER_DEPTH_BUFFER) SW must first 2105a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * issue a pipelined depth stall (PIPE_CONTROL with Depth Stall bit 2106a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * set), followed by a pipelined depth cache flush (PIPE_CONTROL with 2107a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * Depth Flush Bit set, followed by another pipelined depth stall 2108a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * (PIPE_CONTROL with Depth Stall Bit set), unless SW can otherwise 2109a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * guarantee that the pipeline from WM onwards is already flushed (e.g., 2110a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * via a preceding MI_FLUSH)." 2111a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand */ 2112a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pipe) { 2113a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand pipe.DepthStallEnable = true; 2114a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand } 2115a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pipe) { 2116a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand pipe.DepthCacheFlushEnable = true; 2117a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand } 2118a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pipe) { 2119a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand pipe.DepthStallEnable = true; 2120a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand } 2121a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand} 2122a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand 2123d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrandstatic uint32_t 2124d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstranddepth_stencil_surface_type(enum isl_surf_dim dim) 2125d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand{ 2126d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand switch (dim) { 2127d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand case ISL_SURF_DIM_1D: 2128d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand if (GEN_GEN >= 9) { 2129d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand /* From the Sky Lake PRM, 3DSTATAE_DEPTH_BUFFER::SurfaceType 2130d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * 2131d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * Programming Notes: 2132d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * The Surface Type of the depth buffer must be the same as the 2133d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * Surface Type of the render target(s) (defined in 2134d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * SURFACE_STATE), unless either the depth buffer or render 2135d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * targets are SURFTYPE_NULL (see exception below for SKL). 1D 2136d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * surface type not allowed for depth surface and stencil surface. 2137d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * 2138d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * Workaround: 2139d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * If depth/stencil is enabled with 1D render target, 2140d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * depth/stencil surface type needs to be set to 2D surface type 2141d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * and height set to 1. Depth will use (legacy) TileY and stencil 2142d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * will use TileW. For this case only, the Surface Type of the 2143d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * depth buffer can be 2D while the Surface Type of the render 2144d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * target(s) are 1D, representing an exception to a programming 2145d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * note above. 2146d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand */ 2147d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand return SURFTYPE_2D; 2148d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } else { 2149d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand return SURFTYPE_1D; 2150d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } 2151d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand case ISL_SURF_DIM_2D: 2152d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand return SURFTYPE_2D; 2153d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand case ISL_SURF_DIM_3D: 2154d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand if (GEN_GEN >= 9) { 2155d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand /* The Sky Lake docs list the value for 3D as "Reserved". However, 2156d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * they have the exact same layout as 2D arrays on gen9+, so we can 2157d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * just use 2D here. 2158d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand */ 2159d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand return SURFTYPE_2D; 2160d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } else { 2161d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand return SURFTYPE_3D; 2162d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } 2163d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand default: 2164d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand unreachable("Invalid surface dimension"); 2165d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } 2166d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand} 2167d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand 216885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsbergstatic void 216985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsbergcmd_buffer_emit_depth_stencil(struct anv_cmd_buffer *cmd_buffer) 217085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg{ 217185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg struct anv_device *device = cmd_buffer->device; 217285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg const struct anv_framebuffer *fb = cmd_buffer->state.framebuffer; 217385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg const struct anv_image_view *iview = 217485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg anv_cmd_buffer_get_depth_stencil_view(cmd_buffer); 217585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg const struct anv_image *image = iview ? iview->image : NULL; 2176234ecf26c65a8909e91313a8b35e2a8a8bbfc0efJason Ekstrand const bool has_depth = image && (image->aspects & VK_IMAGE_ASPECT_DEPTH_BIT); 2177168985fca1b59d345471277d5c8ce4a82cdc74f4Nanley Chery const uint32_t ds = cmd_buffer->state.subpass->depth_stencil_attachment; 2178168985fca1b59d345471277d5c8ce4a82cdc74f4Nanley Chery const bool has_hiz = image != NULL && 2179168985fca1b59d345471277d5c8ce4a82cdc74f4Nanley Chery cmd_buffer->state.attachments[ds].aux_usage == ISL_AUX_USAGE_HIZ; 2180234ecf26c65a8909e91313a8b35e2a8a8bbfc0efJason Ekstrand const bool has_stencil = 2181234ecf26c65a8909e91313a8b35e2a8a8bbfc0efJason Ekstrand image && (image->aspects & VK_IMAGE_ASPECT_STENCIL_BIT); 218285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 218385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg /* FIXME: Implement the PMA stall W/A */ 218485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg /* FIXME: Width and Height are wrong */ 218585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2186a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand genX(cmd_buffer_emit_gen7_depth_flush)(cmd_buffer); 2187a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand 218885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg /* Emit 3DSTATE_DEPTH_BUFFER */ 218985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg if (has_depth) { 219050018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_DEPTH_BUFFER), db) { 2191d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand db.SurfaceType = 2192d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand depth_stencil_surface_type(image->depth_surface.isl.dim); 2193a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.DepthWriteEnable = true; 2194a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.StencilWriteEnable = has_stencil; 219564fb5b0d51751f452b7bf4c5fff06b5549eed4a8Nanley Chery db.HierarchicalDepthBufferEnable = has_hiz; 2196a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand 2197a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.SurfaceFormat = isl_surf_get_depth_format(&device->isl_dev, 2198a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand &image->depth_surface.isl); 2199a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand 2200a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.SurfaceBaseAddress = (struct anv_address) { 220185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg .bo = image->bo, 220222d8666d74f6fa6de53366f76a56277976eced21Kristian Høgsberg .offset = image->offset + image->depth_surface.offset, 2203a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand }; 2204696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin db.DepthBufferObjectControlState = GENX(MOCS); 2205a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand 2206a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.SurfacePitch = image->depth_surface.isl.row_pitch - 1; 220720e95a746df34923eb4aac5e7f1ab6d722432d89Jason Ekstrand db.Height = image->extent.height - 1; 220820e95a746df34923eb4aac5e7f1ab6d722432d89Jason Ekstrand db.Width = image->extent.width - 1; 220929e289fa655938f7814bdbb3de7996a8a0f04b60Jason Ekstrand db.LOD = iview->isl.base_level; 221029e289fa655938f7814bdbb3de7996a8a0f04b60Jason Ekstrand db.MinimumArrayElement = iview->isl.base_array_layer; 2211a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand 221261992e0afe5f717aad7321d9748588b2cd27f8eeNanley Chery assert(image->depth_surface.isl.dim != ISL_SURF_DIM_3D); 221361992e0afe5f717aad7321d9748588b2cd27f8eeNanley Chery db.Depth = 221461992e0afe5f717aad7321d9748588b2cd27f8eeNanley Chery db.RenderTargetViewExtent = 221561992e0afe5f717aad7321d9748588b2cd27f8eeNanley Chery iview->isl.array_len - iview->isl.base_array_layer - 1; 221661992e0afe5f717aad7321d9748588b2cd27f8eeNanley Chery 2217371b4a5b33a13f35fa7783510d2d90685a9a2e8aJason Ekstrand#if GEN_GEN >= 8 2218a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.SurfaceQPitch = 2219696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin isl_surf_get_array_pitch_el_rows(&image->depth_surface.isl) >> 2; 222085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg#endif 2221a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand } 222285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg } else { 222385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg /* Even when no depth buffer is present, the hardware requires that 222485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH_BUFFER be programmed correctly. The Broadwell PRM says: 222585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 222685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * If a null depth buffer is bound, the driver must instead bind depth as: 222785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH.SurfaceType = SURFTYPE_2D 222885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH.Width = 1 222985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH.Height = 1 223085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH.SuraceFormat = D16_UNORM 223185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH.SurfaceBaseAddress = 0 223285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH.HierarchicalDepthBufferEnable = 0 223385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_WM_DEPTH_STENCIL.DepthTestEnable = 0 223485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_WM_DEPTH_STENCIL.DepthBufferWriteEnable = 0 223585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 223685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * The PRM is wrong, though. The width and height must be programmed to 223785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * actual framebuffer's width and height, even when neither depth buffer 22387c1660aa14094e40fba9f39ce194cb6238311b65Jason Ekstrand * nor stencil buffer is present. Also, D16_UNORM is not allowed to 22397c1660aa14094e40fba9f39ce194cb6238311b65Jason Ekstrand * be combined with a stencil buffer so we use D32_FLOAT instead. 224085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg */ 224150018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_DEPTH_BUFFER), db) { 2242d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand if (has_stencil) { 224327433b26b197b8b69d4ca8c9aed567f04950648eJason Ekstrand db.SurfaceType = 2244d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand depth_stencil_surface_type(image->stencil_surface.isl.dim); 2245d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } else { 2246d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand db.SurfaceType = SURFTYPE_2D; 2247d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } 2248a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.SurfaceFormat = D32_FLOAT; 2249dcca706b4e2d2086b90d77cced0cff6ce4eac953Kenneth Graunke db.Width = MAX2(fb->width, 1) - 1; 2250dcca706b4e2d2086b90d77cced0cff6ce4eac953Kenneth Graunke db.Height = MAX2(fb->height, 1) - 1; 2251a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.StencilWriteEnable = has_stencil; 2252a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand } 225385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg } 225485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 225578d074b87a75d599e65ef34f5b866da577b80de3Chad Versace if (has_hiz) { 225678d074b87a75d599e65ef34f5b866da577b80de3Chad Versace anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_HIER_DEPTH_BUFFER), hdb) { 225778d074b87a75d599e65ef34f5b866da577b80de3Chad Versace hdb.HierarchicalDepthBufferObjectControlState = GENX(MOCS); 2258c3eb58664e5e537b21a75172916b42bd4b5504b3Jason Ekstrand hdb.SurfacePitch = image->aux_surface.isl.row_pitch - 1; 225978d074b87a75d599e65ef34f5b866da577b80de3Chad Versace hdb.SurfaceBaseAddress = (struct anv_address) { 226078d074b87a75d599e65ef34f5b866da577b80de3Chad Versace .bo = image->bo, 2261c3eb58664e5e537b21a75172916b42bd4b5504b3Jason Ekstrand .offset = image->offset + image->aux_surface.offset, 226278d074b87a75d599e65ef34f5b866da577b80de3Chad Versace }; 226378d074b87a75d599e65ef34f5b866da577b80de3Chad Versace#if GEN_GEN >= 8 226478d074b87a75d599e65ef34f5b866da577b80de3Chad Versace /* From the SKL PRM Vol2a: 226578d074b87a75d599e65ef34f5b866da577b80de3Chad Versace * 226678d074b87a75d599e65ef34f5b866da577b80de3Chad Versace * The interpretation of this field is dependent on Surface Type 226778d074b87a75d599e65ef34f5b866da577b80de3Chad Versace * as follows: 226878d074b87a75d599e65ef34f5b866da577b80de3Chad Versace * - SURFTYPE_1D: distance in pixels between array slices 226978d074b87a75d599e65ef34f5b866da577b80de3Chad Versace * - SURFTYPE_2D/CUBE: distance in rows between array slices 227078d074b87a75d599e65ef34f5b866da577b80de3Chad Versace * - SURFTYPE_3D: distance in rows between R - slices 2271f469235a6e0c239166ba803e121994063b47ddd3Jason Ekstrand * 2272f469235a6e0c239166ba803e121994063b47ddd3Jason Ekstrand * Unfortunately, the docs aren't 100% accurate here. They fail to 2273f469235a6e0c239166ba803e121994063b47ddd3Jason Ekstrand * mention that the 1-D rule only applies to linear 1-D images. 2274f469235a6e0c239166ba803e121994063b47ddd3Jason Ekstrand * Since depth and HiZ buffers are always tiled, they are treated as 2275f469235a6e0c239166ba803e121994063b47ddd3Jason Ekstrand * 2-D images. Prior to Sky Lake, this field is always in rows. 227678d074b87a75d599e65ef34f5b866da577b80de3Chad Versace */ 227778d074b87a75d599e65ef34f5b866da577b80de3Chad Versace hdb.SurfaceQPitch = 22789f1d3a0c971e95c9e04cf6bfcd60f8b0d8c6742bNanley Chery isl_surf_get_array_pitch_sa_rows(&image->aux_surface.isl) >> 2; 227978d074b87a75d599e65ef34f5b866da577b80de3Chad Versace#endif 228078d074b87a75d599e65ef34f5b866da577b80de3Chad Versace } 228178d074b87a75d599e65ef34f5b866da577b80de3Chad Versace } else { 228278d074b87a75d599e65ef34f5b866da577b80de3Chad Versace anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_HIER_DEPTH_BUFFER), hdb); 228378d074b87a75d599e65ef34f5b866da577b80de3Chad Versace } 228478d074b87a75d599e65ef34f5b866da577b80de3Chad Versace 228585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg /* Emit 3DSTATE_STENCIL_BUFFER */ 228685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg if (has_stencil) { 228750018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_STENCIL_BUFFER), sb) { 2288371b4a5b33a13f35fa7783510d2d90685a9a2e8aJason Ekstrand#if GEN_GEN >= 8 || GEN_IS_HASWELL 2289696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin sb.StencilBufferEnable = true; 229085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg#endif 2291696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin sb.StencilBufferObjectControlState = GENX(MOCS); 229285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2293696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin sb.SurfacePitch = image->stencil_surface.isl.row_pitch - 1; 229485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2295371b4a5b33a13f35fa7783510d2d90685a9a2e8aJason Ekstrand#if GEN_GEN >= 8 2296696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin sb.SurfaceQPitch = isl_surf_get_array_pitch_el_rows(&image->stencil_surface.isl) >> 2; 229785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg#endif 2298a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand sb.SurfaceBaseAddress = (struct anv_address) { 229985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg .bo = image->bo, 230085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg .offset = image->offset + image->stencil_surface.offset, 2301a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand }; 2302a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand } 230385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg } else { 230450018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_STENCIL_BUFFER), sb); 230585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg } 230685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2307d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery /* From the IVB PRM Vol2P1, 11.5.5.4 3DSTATE_CLEAR_PARAMS: 2308d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * 2309d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * 3DSTATE_CLEAR_PARAMS must always be programmed in the along with 2310d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * the other Depth/Stencil state commands(i.e. 3DSTATE_DEPTH_BUFFER, 2311d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * 3DSTATE_STENCIL_BUFFER, or 3DSTATE_HIER_DEPTH_BUFFER) 2312d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * 2313d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * Testing also shows that some variant of this restriction may exist HSW+. 2314d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * On BDW+, it is not possible to emit 2 of these packets consecutively when 2315d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * both have DepthClearValueValid set. An analysis of such state programming 2316d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * on SKL showed that the GPU doesn't register the latter packet's clear 2317d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * value. 2318d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery */ 2319d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_CLEAR_PARAMS), cp) { 2320d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery if (has_hiz) { 2321d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery cp.DepthClearValueValid = true; 2322b62d8ad2aee2f67fb290332b285a0a5aa93e7724Nanley Chery cp.DepthClearValue = ANV_HZ_FC_VAL; 2323d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery } 2324d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery } 232585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg} 232685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2327b548fdbed5c16f5c0dfc26f65b0037a85c567735Jason Ekstrandstatic void 232885f67cf16e9823c858215e8a7359d18762c2653cKristian HøgsberggenX(cmd_buffer_set_subpass)(struct anv_cmd_buffer *cmd_buffer, 232985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg struct anv_subpass *subpass) 233085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg{ 233185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg cmd_buffer->state.subpass = subpass; 233285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2333fe4e276b02615b5db8acbf4c65fcfa68982e2e0fJason Ekstrand cmd_buffer->state.dirty |= ANV_CMD_DIRTY_RENDER_TARGETS; 233485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2335462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery const struct anv_image_view *iview = 2336462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery anv_cmd_buffer_get_depth_stencil_view(cmd_buffer); 2337462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery 233858af6156360a309578241acba949e540acf72cb1Nanley Chery if (iview && iview->image->aux_usage == ISL_AUX_USAGE_HIZ) { 233958af6156360a309578241acba949e540acf72cb1Nanley Chery const uint32_t ds = subpass->depth_stencil_attachment; 234058af6156360a309578241acba949e540acf72cb1Nanley Chery transition_depth_buffer(cmd_buffer, iview->image, 234158af6156360a309578241acba949e540acf72cb1Nanley Chery cmd_buffer->state.attachments[ds].current_layout, 234258af6156360a309578241acba949e540acf72cb1Nanley Chery cmd_buffer->state.subpass->depth_stencil_layout); 234358af6156360a309578241acba949e540acf72cb1Nanley Chery cmd_buffer->state.attachments[ds].current_layout = 234458af6156360a309578241acba949e540acf72cb1Nanley Chery cmd_buffer->state.subpass->depth_stencil_layout; 234558af6156360a309578241acba949e540acf72cb1Nanley Chery cmd_buffer->state.attachments[ds].aux_usage = 234664272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery layout_to_hiz_usage(cmd_buffer->state.subpass->depth_stencil_layout, 234764272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery iview->image->samples); 2348462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery } 2349462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery 235085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg cmd_buffer_emit_depth_stencil(cmd_buffer); 2351c81ec84c1ec24f11f86b2fb725956437c721fe18Jason Ekstrand 2352c81ec84c1ec24f11f86b2fb725956437c721fe18Jason Ekstrand anv_cmd_buffer_clear_subpass(cmd_buffer); 235385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg} 235485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 235585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsbergvoid genX(CmdBeginRenderPass)( 235685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg VkCommandBuffer commandBuffer, 235785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg const VkRenderPassBeginInfo* pRenderPassBegin, 235885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg VkSubpassContents contents) 235985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg{ 236085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 236185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg ANV_FROM_HANDLE(anv_render_pass, pass, pRenderPassBegin->renderPass); 236285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg ANV_FROM_HANDLE(anv_framebuffer, framebuffer, pRenderPassBegin->framebuffer); 236385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 236485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg cmd_buffer->state.framebuffer = framebuffer; 236585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg cmd_buffer->state.pass = pass; 2366b26bd6790dd1b09e377bd926e9145ec20ce6ac3fJason Ekstrand cmd_buffer->state.render_area = pRenderPassBegin->renderArea; 2367d1d6b788989e73edd2426999d891230500dc1a73Jason Ekstrand genX(cmd_buffer_setup_attachments)(cmd_buffer, pass, pRenderPassBegin); 236885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 236985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg genX(flush_pipeline_select_3d)(cmd_buffer); 237085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 237185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg genX(cmd_buffer_set_subpass)(cmd_buffer, pass->subpasses); 237285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg} 237385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 237485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsbergvoid genX(CmdNextSubpass)( 237585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg VkCommandBuffer commandBuffer, 237685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg VkSubpassContents contents) 237785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg{ 237885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 237985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 238085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg assert(cmd_buffer->level == VK_COMMAND_BUFFER_LEVEL_PRIMARY); 238185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2382462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery const struct anv_image_view *iview = 2383462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery anv_cmd_buffer_get_depth_stencil_view(cmd_buffer); 2384462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery 238558af6156360a309578241acba949e540acf72cb1Nanley Chery if (iview && iview->image->aux_usage == ISL_AUX_USAGE_HIZ) { 238658af6156360a309578241acba949e540acf72cb1Nanley Chery const uint32_t ds = cmd_buffer->state.subpass->depth_stencil_attachment; 238758af6156360a309578241acba949e540acf72cb1Nanley Chery 238858af6156360a309578241acba949e540acf72cb1Nanley Chery if (cmd_buffer->state.subpass - cmd_buffer->state.pass->subpasses == 238958af6156360a309578241acba949e540acf72cb1Nanley Chery cmd_buffer->state.pass->attachments[ds].last_subpass_idx) { 239058af6156360a309578241acba949e540acf72cb1Nanley Chery transition_depth_buffer(cmd_buffer, iview->image, 239158af6156360a309578241acba949e540acf72cb1Nanley Chery cmd_buffer->state.attachments[ds].current_layout, 239258af6156360a309578241acba949e540acf72cb1Nanley Chery cmd_buffer->state.pass->attachments[ds].final_layout); 239358af6156360a309578241acba949e540acf72cb1Nanley Chery } 2394462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery } 2395462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery 239685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg anv_cmd_buffer_resolve_subpass(cmd_buffer); 239785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg genX(cmd_buffer_set_subpass)(cmd_buffer, cmd_buffer->state.subpass + 1); 239885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg} 239985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 240085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsbergvoid genX(CmdEndRenderPass)( 240185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg VkCommandBuffer commandBuffer) 240285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg{ 240385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 240485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2405462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery const struct anv_image_view *iview = 2406462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery anv_cmd_buffer_get_depth_stencil_view(cmd_buffer); 2407462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery 240858af6156360a309578241acba949e540acf72cb1Nanley Chery if (iview && iview->image->aux_usage == ISL_AUX_USAGE_HIZ) { 240958af6156360a309578241acba949e540acf72cb1Nanley Chery const uint32_t ds = cmd_buffer->state.subpass->depth_stencil_attachment; 241058af6156360a309578241acba949e540acf72cb1Nanley Chery 241158af6156360a309578241acba949e540acf72cb1Nanley Chery if (cmd_buffer->state.subpass - cmd_buffer->state.pass->subpasses == 241258af6156360a309578241acba949e540acf72cb1Nanley Chery cmd_buffer->state.pass->attachments[ds].last_subpass_idx) { 241358af6156360a309578241acba949e540acf72cb1Nanley Chery transition_depth_buffer(cmd_buffer, iview->image, 241458af6156360a309578241acba949e540acf72cb1Nanley Chery cmd_buffer->state.attachments[ds].current_layout, 241558af6156360a309578241acba949e540acf72cb1Nanley Chery cmd_buffer->state.pass->attachments[ds].final_layout); 241658af6156360a309578241acba949e540acf72cb1Nanley Chery } 2417462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery } 2418462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery 241985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg anv_cmd_buffer_resolve_subpass(cmd_buffer); 2420ac7eeebce4ae9107863623321b74b1c08389f180Jason Ekstrand 2421ac7eeebce4ae9107863623321b74b1c08389f180Jason Ekstrand#ifndef NDEBUG 2422ac7eeebce4ae9107863623321b74b1c08389f180Jason Ekstrand anv_dump_add_framebuffer(cmd_buffer, cmd_buffer->state.framebuffer); 2423ac7eeebce4ae9107863623321b74b1c08389f180Jason Ekstrand#endif 242485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg} 242581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 242681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenstatic void 24271e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrandemit_ps_depth_count(struct anv_cmd_buffer *cmd_buffer, 242881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen struct anv_bo *bo, uint32_t offset) 242981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 24301e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 243156453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DestinationAddressType = DAT_PPGTT; 243256453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.PostSyncOperation = WritePSDepthCount; 243356453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DepthStallEnable = true; 243456453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.Address = (struct anv_address) { bo, offset }; 2435a6c3d0f92b754e11e74cea9d6bd5ac329c73a8baJason Ekstrand 2436a6c3d0f92b754e11e74cea9d6bd5ac329c73a8baJason Ekstrand if (GEN_GEN == 9 && cmd_buffer->device->info.gt == 4) 2437a6c3d0f92b754e11e74cea9d6bd5ac329c73a8baJason Ekstrand pc.CommandStreamerStallEnable = true; 243856453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 243981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 244081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 244181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenstatic void 24421e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrandemit_query_availability(struct anv_cmd_buffer *cmd_buffer, 244381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen struct anv_bo *bo, uint32_t offset) 244481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 24451e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 244656453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DestinationAddressType = DAT_PPGTT; 244756453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.PostSyncOperation = WriteImmediateData; 244856453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.Address = (struct anv_address) { bo, offset }; 244956453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.ImmediateData = 1; 245056453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 245181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 245281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 245381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenvoid genX(CmdBeginQuery)( 245481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkCommandBuffer commandBuffer, 245581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkQueryPool queryPool, 245681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t query, 245781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkQueryControlFlags flags) 245881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 245981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 246081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_query_pool, pool, queryPool); 246181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 246281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen /* Workaround: When meta uses the pipeline with the VS disabled, it seems 246381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen * that the pipelining of the depth write breaks. What we see is that 246481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen * samples from the render pass clear leaks into the first query 246581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen * immediately after the clear. Doing a pipecontrol with a post-sync 246681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen * operation and DepthStallEnable seems to work around the issue. 246781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen */ 246881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen if (cmd_buffer->state.need_query_wa) { 246981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen cmd_buffer->state.need_query_wa = false; 247050018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 247156453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DepthCacheFlushEnable = true; 247256453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DepthStallEnable = true; 247356453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 247481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 247581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 247681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen switch (pool->type) { 247781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_QUERY_TYPE_OCCLUSION: 24781e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrand emit_ps_depth_count(cmd_buffer, &pool->bo, 247981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen query * sizeof(struct anv_query_pool_slot)); 248081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen break; 248181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 248281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_QUERY_TYPE_PIPELINE_STATISTICS: 248381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen default: 248481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen unreachable(""); 248581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 248681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 248781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 248881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenvoid genX(CmdEndQuery)( 248981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkCommandBuffer commandBuffer, 249081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkQueryPool queryPool, 249181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t query) 249281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 249381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 249481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_query_pool, pool, queryPool); 249581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 249681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen switch (pool->type) { 249781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_QUERY_TYPE_OCCLUSION: 24981e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrand emit_ps_depth_count(cmd_buffer, &pool->bo, 249981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen query * sizeof(struct anv_query_pool_slot) + 8); 250081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 25011e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrand emit_query_availability(cmd_buffer, &pool->bo, 250281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen query * sizeof(struct anv_query_pool_slot) + 16); 250381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen break; 250481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 250581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_QUERY_TYPE_PIPELINE_STATISTICS: 250681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen default: 250781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen unreachable(""); 250881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 250981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 251081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 251181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define TIMESTAMP 0x2358 251281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 251381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenvoid genX(CmdWriteTimestamp)( 251481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkCommandBuffer commandBuffer, 251581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkPipelineStageFlagBits pipelineStage, 251681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkQueryPool queryPool, 251781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t query) 251881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 251981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 252081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_query_pool, pool, queryPool); 252181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t offset = query * sizeof(struct anv_query_pool_slot); 252281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 252381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen assert(pool->type == VK_QUERY_TYPE_TIMESTAMP); 252481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 252581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen switch (pipelineStage) { 252681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT: 252750018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(MI_STORE_REGISTER_MEM), srm) { 25288a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.RegisterAddress = TIMESTAMP; 25298a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.MemoryAddress = (struct anv_address) { &pool->bo, offset }; 25308a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 253150018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(MI_STORE_REGISTER_MEM), srm) { 25328a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.RegisterAddress = TIMESTAMP + 4; 25338a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.MemoryAddress = (struct anv_address) { &pool->bo, offset + 4 }; 25348a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 253581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen break; 253681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 253781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen default: 253881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen /* Everything else is bottom-of-pipe */ 253950018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 2540696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin pc.DestinationAddressType = DAT_PPGTT; 2541696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin pc.PostSyncOperation = WriteTimestamp; 25428a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand pc.Address = (struct anv_address) { &pool->bo, offset }; 2543a6c3d0f92b754e11e74cea9d6bd5ac329c73a8baJason Ekstrand 2544a6c3d0f92b754e11e74cea9d6bd5ac329c73a8baJason Ekstrand if (GEN_GEN == 9 && cmd_buffer->device->info.gt == 4) 2545a6c3d0f92b754e11e74cea9d6bd5ac329c73a8baJason Ekstrand pc.CommandStreamerStallEnable = true; 25468a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 254781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen break; 254881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 254981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 25501e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrand emit_query_availability(cmd_buffer, &pool->bo, query + 16); 255181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 255281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 255381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#if GEN_GEN > 7 || GEN_IS_HASWELL 255481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 255581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define alu_opcode(v) __gen_uint((v), 20, 31) 255681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define alu_operand1(v) __gen_uint((v), 10, 19) 255781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define alu_operand2(v) __gen_uint((v), 0, 9) 255881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define alu(opcode, operand1, operand2) \ 255981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen alu_opcode(opcode) | alu_operand1(operand1) | alu_operand2(operand2) 256081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 256181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_NOOP 0x000 256281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_LOAD 0x080 256381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_LOADINV 0x480 256481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_LOAD0 0x081 256581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_LOAD1 0x481 256681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_ADD 0x100 256781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_SUB 0x101 256881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_AND 0x102 256981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_OR 0x103 257081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_XOR 0x104 257181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_STORE 0x180 257281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_STOREINV 0x580 257381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 257481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_R0 0x00 257581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_R1 0x01 257681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_R2 0x02 257781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_R3 0x03 257881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_R4 0x04 257981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_SRCA 0x20 258081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_SRCB 0x21 258181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_ACCU 0x31 258281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_ZF 0x32 258381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_CF 0x33 258481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 258581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define CS_GPR(n) (0x2600 + (n) * 8) 258681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 258781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenstatic void 258881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenemit_load_alu_reg_u64(struct anv_batch *batch, uint32_t reg, 258981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen struct anv_bo *bo, uint32_t offset) 259081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 259150018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_LOAD_REGISTER_MEM), lrm) { 25928a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand lrm.RegisterAddress = reg, 25938a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand lrm.MemoryAddress = (struct anv_address) { bo, offset }; 25948a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 259550018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_LOAD_REGISTER_MEM), lrm) { 25968a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand lrm.RegisterAddress = reg + 4; 25978a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand lrm.MemoryAddress = (struct anv_address) { bo, offset + 4 }; 25988a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 259981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 260081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 260181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenstatic void 260281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenstore_query_result(struct anv_batch *batch, uint32_t reg, 260381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen struct anv_bo *bo, uint32_t offset, VkQueryResultFlags flags) 260481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 260550018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_STORE_REGISTER_MEM), srm) { 26068a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.RegisterAddress = reg; 26078a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.MemoryAddress = (struct anv_address) { bo, offset }; 26088a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 26098a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand 26108a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand if (flags & VK_QUERY_RESULT_64_BIT) { 261150018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_STORE_REGISTER_MEM), srm) { 26128a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.RegisterAddress = reg + 4; 26138a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.MemoryAddress = (struct anv_address) { bo, offset + 4 }; 26148a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 26158a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 261681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 261781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 261881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenvoid genX(CmdCopyQueryPoolResults)( 261981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkCommandBuffer commandBuffer, 262081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkQueryPool queryPool, 262181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t firstQuery, 262281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t queryCount, 262381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkBuffer destBuffer, 262481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkDeviceSize destOffset, 262581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkDeviceSize destStride, 262681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkQueryResultFlags flags) 262781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 262881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 262981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_query_pool, pool, queryPool); 263081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_buffer, buffer, destBuffer); 263181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t slot_offset, dst_offset; 263281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 263356453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand if (flags & VK_QUERY_RESULT_WAIT_BIT) { 263450018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 263556453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.CommandStreamerStallEnable = true; 263656453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.StallAtPixelScoreboard = true; 263756453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 263856453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 263981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 264081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen dst_offset = buffer->offset + destOffset; 264181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen for (uint32_t i = 0; i < queryCount; i++) { 264281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 264381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen slot_offset = (firstQuery + i) * sizeof(struct anv_query_pool_slot); 264481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen switch (pool->type) { 264581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_QUERY_TYPE_OCCLUSION: 264681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen emit_load_alu_reg_u64(&cmd_buffer->batch, 264781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen CS_GPR(0), &pool->bo, slot_offset); 264881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen emit_load_alu_reg_u64(&cmd_buffer->batch, 264981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen CS_GPR(1), &pool->bo, slot_offset + 8); 265081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 265181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen /* FIXME: We need to clamp the result for 32 bit. */ 265281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 265381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t *dw = anv_batch_emitn(&cmd_buffer->batch, 5, GENX(MI_MATH)); 265481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen dw[1] = alu(OPCODE_LOAD, OPERAND_SRCA, OPERAND_R1); 265581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen dw[2] = alu(OPCODE_LOAD, OPERAND_SRCB, OPERAND_R0); 265681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen dw[3] = alu(OPCODE_SUB, 0, 0); 265781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen dw[4] = alu(OPCODE_STORE, OPERAND_R2, OPERAND_ACCU); 265881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen break; 265981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 266081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_QUERY_TYPE_TIMESTAMP: 266181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen emit_load_alu_reg_u64(&cmd_buffer->batch, 266281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen CS_GPR(2), &pool->bo, slot_offset); 266381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen break; 266481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 266581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen default: 266681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen unreachable("unhandled query type"); 266781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 266881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 266981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen store_query_result(&cmd_buffer->batch, 267081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen CS_GPR(2), buffer->bo, dst_offset, flags); 267181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 267281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen if (flags & VK_QUERY_RESULT_WITH_AVAILABILITY_BIT) { 267381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen emit_load_alu_reg_u64(&cmd_buffer->batch, CS_GPR(0), 267481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen &pool->bo, slot_offset + 16); 267581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen if (flags & VK_QUERY_RESULT_64_BIT) 267681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen store_query_result(&cmd_buffer->batch, 267781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen CS_GPR(0), buffer->bo, dst_offset + 8, flags); 267881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen else 267981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen store_query_result(&cmd_buffer->batch, 268081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen CS_GPR(0), buffer->bo, dst_offset + 4, flags); 268181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 268281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 268381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen dst_offset += destStride; 268481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 268581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 268681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 2687b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand#else 2688b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrandvoid genX(CmdCopyQueryPoolResults)( 2689b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand VkCommandBuffer commandBuffer, 2690b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand VkQueryPool queryPool, 2691b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand uint32_t firstQuery, 2692b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand uint32_t queryCount, 2693b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand VkBuffer destBuffer, 2694b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand VkDeviceSize destOffset, 2695b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand VkDeviceSize destStride, 2696b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand VkQueryResultFlags flags) 2697b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand{ 2698b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand anv_finishme("Queries not yet supported on Ivy Bridge"); 2699b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand} 270081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#endif 2701