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 6469973db02a04621598bf504fcc7797522ee5046deJason Ekstrand /* The secondary command buffer doesn't know which textures etc. have been 6479973db02a04621598bf504fcc7797522ee5046deJason Ekstrand * flushed prior to their execution. Apply those flushes now. 6489973db02a04621598bf504fcc7797522ee5046deJason Ekstrand */ 6499973db02a04621598bf504fcc7797522ee5046deJason Ekstrand genX(cmd_buffer_apply_pipe_flushes)(primary); 6509973db02a04621598bf504fcc7797522ee5046deJason Ekstrand 6512314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand for (uint32_t i = 0; i < commandBufferCount; i++) { 6522314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand ANV_FROM_HANDLE(anv_cmd_buffer, secondary, pCmdBuffers[i]); 6532314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 6542314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand assert(secondary->level == VK_COMMAND_BUFFER_LEVEL_SECONDARY); 6552314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 656d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (secondary->usage_flags & 657d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT) { 658d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand /* If we're continuing a render pass from the primary, we need to 659d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand * copy the surface states for the current subpass into the storage 660d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand * we allocated for them in BeginCommandBuffer. 661d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand */ 662d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_bo *ss_bo = &primary->device->surface_state_block_pool.bo; 663d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_state src_state = primary->state.render_pass_states; 664d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_state dst_state = secondary->state.render_pass_states; 665d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand assert(src_state.alloc_size == dst_state.alloc_size); 666d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 667d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand genX(cmd_buffer_gpu_memcpy)(primary, ss_bo, dst_state.offset, 668d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand ss_bo, src_state.offset, 669d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand src_state.alloc_size); 670d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 671d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 6722314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand anv_cmd_buffer_add_secondary(primary, secondary); 6732314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand } 6742314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 6752314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand /* Each of the secondary command buffers will use its own state base 6762314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * address. We need to re-emit state base address for the primary after 6772314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * all of the secondaries are done. 6782314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * 6792314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * TODO: Maybe we want to make this a dirty bit to avoid extra state base 6802314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * address calls? 6812314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand */ 6822314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand genX(cmd_buffer_emit_state_base_address)(primary); 6832314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand} 6842314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 6857e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#define IVB_L3SQCREG1_SQGHPCI_DEFAULT 0x00730000 6867e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#define VLV_L3SQCREG1_SQGHPCI_DEFAULT 0x00d30000 6877e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#define HSW_L3SQCREG1_SQGHPCI_DEFAULT 0x00610000 6887e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 6897e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand/** 6907e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * Program the hardware to use the specified L3 configuration. 6917e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand */ 6927e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrandvoid 6937e891f90c701aa1c851f1846857daa75bbb65876Jason EkstrandgenX(cmd_buffer_config_l3)(struct anv_cmd_buffer *cmd_buffer, 6947e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const struct gen_l3_config *cfg) 6957e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand{ 6967e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand assert(cfg); 6977e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand if (cfg == cmd_buffer->state.current_l3_config) 6987e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand return; 6997e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7007e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand if (unlikely(INTEL_DEBUG & DEBUG_L3)) { 7017e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand fprintf(stderr, "L3 config transition: "); 7027e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand gen_dump_l3_config(cfg, stderr); 7037e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand } 7047e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7057e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const bool has_slm = cfg->n[GEN_L3P_SLM]; 7067e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7077e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* According to the hardware docs, the L3 partitioning can only be changed 7087e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * while the pipeline is completely drained and the caches are flushed, 7097e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * which involves a first PIPE_CONTROL flush which stalls the pipeline... 7107e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand */ 7117e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 7127e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.DCFlushEnable = true; 7137e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.PostSyncOperation = NoWrite; 7147e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.CommandStreamerStallEnable = true; 7157e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand } 7167e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7177e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* ...followed by a second pipelined PIPE_CONTROL that initiates 7187e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * invalidation of the relevant caches. Note that because RO invalidation 7197e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * happens at the top of the pipeline (i.e. right away as the PIPE_CONTROL 7207e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * command is processed by the CS) we cannot combine it with the previous 7217e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * stalling flush as the hardware documentation suggests, because that 7227e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * would cause the CS to stall on previous rendering *after* RO 7237e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * invalidation and wouldn't prevent the RO caches from being polluted by 7247e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * concurrent rendering before the stall completes. This intentionally 7257e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * doesn't implement the SKL+ hardware workaround suggesting to enable CS 7267e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * stall on PIPE_CONTROLs with the texture cache invalidation bit set for 7277e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * GPGPU workloads because the previous and subsequent PIPE_CONTROLs 7287e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * already guarantee that there is no concurrent GPGPU kernel execution 7297e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * (see SKL HSD 2132585). 7307e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand */ 7317e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 7327e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.TextureCacheInvalidationEnable = true; 7337e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.ConstantCacheInvalidationEnable = true; 7347e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.InstructionCacheInvalidateEnable = true; 7357e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.StateCacheInvalidationEnable = true; 7367e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.PostSyncOperation = NoWrite; 7377e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand } 7387e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7397e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* Now send a third stalling flush to make sure that invalidation is 7407e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * complete when the L3 configuration registers are modified. 7417e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand */ 7427e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 7437e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.DCFlushEnable = true; 7447e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.PostSyncOperation = NoWrite; 7457e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.CommandStreamerStallEnable = true; 7467e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand } 7477e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7487e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#if GEN_GEN >= 8 7497e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7507e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand assert(!cfg->n[GEN_L3P_IS] && !cfg->n[GEN_L3P_C] && !cfg->n[GEN_L3P_T]); 7517e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7527e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand uint32_t l3cr; 7537e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_pack_struct(&l3cr, GENX(L3CNTLREG), 7547e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .SLMEnable = has_slm, 7557e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .URBAllocation = cfg->n[GEN_L3P_URB], 7567e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ROAllocation = cfg->n[GEN_L3P_RO], 7577e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .DCAllocation = cfg->n[GEN_L3P_DC], 7587e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .AllAllocation = cfg->n[GEN_L3P_ALL]); 7597e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7607e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* Set up the L3 partitioning. */ 7617e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand emit_lri(&cmd_buffer->batch, GENX(L3CNTLREG_num), l3cr); 7627e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7637e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#else 7647e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7657e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const bool has_dc = cfg->n[GEN_L3P_DC] || cfg->n[GEN_L3P_ALL]; 7667e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const bool has_is = cfg->n[GEN_L3P_IS] || cfg->n[GEN_L3P_RO] || 7677e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand cfg->n[GEN_L3P_ALL]; 7687e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const bool has_c = cfg->n[GEN_L3P_C] || cfg->n[GEN_L3P_RO] || 7697e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand cfg->n[GEN_L3P_ALL]; 7707e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const bool has_t = cfg->n[GEN_L3P_T] || cfg->n[GEN_L3P_RO] || 7717e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand cfg->n[GEN_L3P_ALL]; 7727e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7737e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand assert(!cfg->n[GEN_L3P_ALL]); 7747e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7757e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* When enabled SLM only uses a portion of the L3 on half of the banks, 7767e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * the matching space on the remaining banks has to be allocated to a 7777e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * client (URB for all validated configurations) set to the 7787e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * lower-bandwidth 2-bank address hashing mode. 7797e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand */ 7807e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const struct gen_device_info *devinfo = &cmd_buffer->device->info; 7817e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const bool urb_low_bw = has_slm && !devinfo->is_baytrail; 7827e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand assert(!urb_low_bw || cfg->n[GEN_L3P_URB] == cfg->n[GEN_L3P_SLM]); 7837e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7847e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* Minimum number of ways that can be allocated to the URB. */ 7853a1b15c3921d25ea2e6e81f500c3f45c84b95817Grazvydas Ignotas MAYBE_UNUSED const unsigned n0_urb = devinfo->is_baytrail ? 32 : 0; 7867e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand assert(cfg->n[GEN_L3P_URB] >= n0_urb); 7877e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7887e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand uint32_t l3sqcr1, l3cr2, l3cr3; 7897e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_pack_struct(&l3sqcr1, GENX(L3SQCREG1), 7907e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ConvertDC_UC = !has_dc, 7917e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ConvertIS_UC = !has_is, 7927e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ConvertC_UC = !has_c, 7937e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ConvertT_UC = !has_t); 7947e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand l3sqcr1 |= 7957e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand GEN_IS_HASWELL ? HSW_L3SQCREG1_SQGHPCI_DEFAULT : 7967e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand devinfo->is_baytrail ? VLV_L3SQCREG1_SQGHPCI_DEFAULT : 7977e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand IVB_L3SQCREG1_SQGHPCI_DEFAULT; 7987e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7997e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_pack_struct(&l3cr2, GENX(L3CNTLREG2), 8007e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .SLMEnable = has_slm, 8017e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .URBLowBandwidth = urb_low_bw, 8027e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .URBAllocation = cfg->n[GEN_L3P_URB], 8037e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#if !GEN_IS_HASWELL 8047e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ALLAllocation = cfg->n[GEN_L3P_ALL], 8057e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#endif 8067e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ROAllocation = cfg->n[GEN_L3P_RO], 8077e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .DCAllocation = cfg->n[GEN_L3P_DC]); 8087e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 8097e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_pack_struct(&l3cr3, GENX(L3CNTLREG3), 8107e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ISAllocation = cfg->n[GEN_L3P_IS], 8117e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ISLowBandwidth = 0, 8127e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .CAllocation = cfg->n[GEN_L3P_C], 8137e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .CLowBandwidth = 0, 8147e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .TAllocation = cfg->n[GEN_L3P_T], 8157e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .TLowBandwidth = 0); 8167e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 8177e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* Set up the L3 partitioning. */ 8187e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand emit_lri(&cmd_buffer->batch, GENX(L3SQCREG1_num), l3sqcr1); 8197e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand emit_lri(&cmd_buffer->batch, GENX(L3CNTLREG2_num), l3cr2); 8207e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand emit_lri(&cmd_buffer->batch, GENX(L3CNTLREG3_num), l3cr3); 8217e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 8227e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#if GEN_IS_HASWELL 8237e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand if (cmd_buffer->device->instance->physicalDevice.cmd_parser_version >= 4) { 8247e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* Enable L3 atomics on HSW if we have a DC partition, otherwise keep 8257e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * them disabled to avoid crashing the system hard. 8267e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand */ 8277e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand uint32_t scratch1, chicken3; 8287e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_pack_struct(&scratch1, GENX(SCRATCH1), 8297e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .L3AtomicDisable = !has_dc); 8307e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_pack_struct(&chicken3, GENX(CHICKEN3), 83189a96c8f43370cc84adf92ab32e3de302a1fa1d0Jason Ekstrand .L3AtomicDisableMask = true, 8327e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .L3AtomicDisable = !has_dc); 8337e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand emit_lri(&cmd_buffer->batch, GENX(SCRATCH1_num), scratch1); 8347e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand emit_lri(&cmd_buffer->batch, GENX(CHICKEN3_num), chicken3); 8357e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand } 8367e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#endif 8377e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 8387e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#endif 8397e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 8407e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand cmd_buffer->state.current_l3_config = cfg; 8417e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand} 8427e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 8433a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrandvoid 8443a83c176eab8c513eb723554a240af1a7308d701Jason EkstrandgenX(cmd_buffer_apply_pipe_flushes)(struct anv_cmd_buffer *cmd_buffer) 8453a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand{ 8463a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand enum anv_pipe_bits bits = cmd_buffer->state.pending_pipe_bits; 8473a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8483a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand /* Flushes are pipelined while invalidations are handled immediately. 8493a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * Therefore, if we're flushing anything then we need to schedule a stall 8503a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * before any invalidations can happen. 8513a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand */ 8523a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand if (bits & ANV_PIPE_FLUSH_BITS) 8533a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits |= ANV_PIPE_NEEDS_CS_STALL_BIT; 8543a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8553a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand /* If we're going to do an invalidate and we have a pending CS stall that 8563a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * has yet to be resolved, we do the CS stall now. 8573a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand */ 8583a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand if ((bits & ANV_PIPE_INVALIDATE_BITS) && 8593a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand (bits & ANV_PIPE_NEEDS_CS_STALL_BIT)) { 8603a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits |= ANV_PIPE_CS_STALL_BIT; 8613a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits &= ~ANV_PIPE_NEEDS_CS_STALL_BIT; 8623a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand } 8633a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8643a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand if (bits & (ANV_PIPE_FLUSH_BITS | ANV_PIPE_CS_STALL_BIT)) { 8653a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pipe) { 8663a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.DepthCacheFlushEnable = bits & ANV_PIPE_DEPTH_CACHE_FLUSH_BIT; 8673a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.DCFlushEnable = bits & ANV_PIPE_DATA_CACHE_FLUSH_BIT; 8683a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.RenderTargetCacheFlushEnable = 8693a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits & ANV_PIPE_RENDER_TARGET_CACHE_FLUSH_BIT; 8703a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8713a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.DepthStallEnable = bits & ANV_PIPE_DEPTH_STALL_BIT; 8723a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.CommandStreamerStallEnable = bits & ANV_PIPE_CS_STALL_BIT; 8733a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.StallAtPixelScoreboard = bits & ANV_PIPE_STALL_AT_SCOREBOARD_BIT; 8743a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8753a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand /* 8763a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * According to the Broadwell documentation, any PIPE_CONTROL with the 8773a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * "Command Streamer Stall" bit set must also have another bit set, 8783a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * with five different options: 8793a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * 8803a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * - Render Target Cache Flush 8813a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * - Depth Cache Flush 8823a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * - Stall at Pixel Scoreboard 8833a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * - Post-Sync Operation 8843a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * - Depth Stall 8853a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * - DC Flush Enable 8863a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * 8873a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * I chose "Stall at Pixel Scoreboard" since that's what we use in 8883a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * mesa and it seems to work fine. The choice is fairly arbitrary. 8893a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand */ 8903a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand if ((bits & ANV_PIPE_CS_STALL_BIT) && 8913a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand !(bits & (ANV_PIPE_FLUSH_BITS | ANV_PIPE_DEPTH_STALL_BIT | 8923a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand ANV_PIPE_STALL_AT_SCOREBOARD_BIT))) 8933a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.StallAtPixelScoreboard = true; 8943a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand } 8953a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8963a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits &= ~(ANV_PIPE_FLUSH_BITS | ANV_PIPE_CS_STALL_BIT); 8973a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand } 8983a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8993a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand if (bits & ANV_PIPE_INVALIDATE_BITS) { 9003a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pipe) { 9013a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.StateCacheInvalidationEnable = 9023a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits & ANV_PIPE_STATE_CACHE_INVALIDATE_BIT; 9033a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.ConstantCacheInvalidationEnable = 9043a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits & ANV_PIPE_CONSTANT_CACHE_INVALIDATE_BIT; 9053a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.VFCacheInvalidationEnable = 9063a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits & ANV_PIPE_VF_CACHE_INVALIDATE_BIT; 9073a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.TextureCacheInvalidationEnable = 9083a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits & ANV_PIPE_TEXTURE_CACHE_INVALIDATE_BIT; 9093a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.InstructionCacheInvalidateEnable = 9103a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits & ANV_PIPE_INSTRUCTION_CACHE_INVALIDATE_BIT; 9113a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand } 9123a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 9133a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits &= ~ANV_PIPE_INVALIDATE_BITS; 9143a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand } 9153a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 9163a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand cmd_buffer->state.pending_pipe_bits = bits; 9173a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand} 9183a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 9196f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrandvoid genX(CmdPipelineBarrier)( 920a89a485e79ad40793a85979d86d45760362be21aJason Ekstrand VkCommandBuffer commandBuffer, 9216f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand VkPipelineStageFlags srcStageMask, 9226f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand VkPipelineStageFlags destStageMask, 9236f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand VkBool32 byRegion, 924c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand uint32_t memoryBarrierCount, 925c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand const VkMemoryBarrier* pMemoryBarriers, 926c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand uint32_t bufferMemoryBarrierCount, 927c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand const VkBufferMemoryBarrier* pBufferMemoryBarriers, 928c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand uint32_t imageMemoryBarrierCount, 929c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand const VkImageMemoryBarrier* pImageMemoryBarriers) 9306f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand{ 931a89a485e79ad40793a85979d86d45760362be21aJason Ekstrand ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 9323a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand uint32_t b; 9336f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 9346f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand /* XXX: Right now, we're really dumb and just flush whatever categories 9356f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * the app asks for. One of these days we may make this a bit better 9366f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * but right now that's all the hardware allows for in most areas. 9376f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand */ 938b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand VkAccessFlags src_flags = 0; 939b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand VkAccessFlags dst_flags = 0; 9406f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 941c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand for (uint32_t i = 0; i < memoryBarrierCount; i++) { 942c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand src_flags |= pMemoryBarriers[i].srcAccessMask; 943c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand dst_flags |= pMemoryBarriers[i].dstAccessMask; 944c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand } 945c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand 946c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand for (uint32_t i = 0; i < bufferMemoryBarrierCount; i++) { 947c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand src_flags |= pBufferMemoryBarriers[i].srcAccessMask; 948c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand dst_flags |= pBufferMemoryBarriers[i].dstAccessMask; 949c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand } 950c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand 951c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand for (uint32_t i = 0; i < imageMemoryBarrierCount; i++) { 952c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand src_flags |= pImageMemoryBarriers[i].srcAccessMask; 953c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand dst_flags |= pImageMemoryBarriers[i].dstAccessMask; 95458af6156360a309578241acba949e540acf72cb1Nanley Chery ANV_FROM_HANDLE(anv_image, image, pImageMemoryBarriers[i].image); 95558af6156360a309578241acba949e540acf72cb1Nanley Chery if (pImageMemoryBarriers[i].subresourceRange.aspectMask & 95658af6156360a309578241acba949e540acf72cb1Nanley Chery VK_IMAGE_ASPECT_DEPTH_BIT) { 95758af6156360a309578241acba949e540acf72cb1Nanley Chery transition_depth_buffer(cmd_buffer, image, 95858af6156360a309578241acba949e540acf72cb1Nanley Chery pImageMemoryBarriers[i].oldLayout, 95958af6156360a309578241acba949e540acf72cb1Nanley Chery pImageMemoryBarriers[i].newLayout); 96058af6156360a309578241acba949e540acf72cb1Nanley Chery } 9616f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand } 9626f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 9633a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand enum anv_pipe_bits pipe_bits = 0; 9645e92e91c6177bfe31214b8a0ebd0d4c47969b61dKristian Høgsberg 965924fbfc9a1fc46a3698fa23649e6dccc3e3e6782Jason Ekstrand for_each_bit(b, src_flags) { 966b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand switch ((VkAccessFlagBits)(1 << b)) { 967b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_SHADER_WRITE_BIT: 9683a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_DATA_CACHE_FLUSH_BIT; 9696f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand break; 970b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT: 9713a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_RENDER_TARGET_CACHE_FLUSH_BIT; 9726f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand break; 973b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: 9743a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_DEPTH_CACHE_FLUSH_BIT; 9756f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand break; 976b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_TRANSFER_WRITE_BIT: 9773a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_RENDER_TARGET_CACHE_FLUSH_BIT; 9783a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_DEPTH_CACHE_FLUSH_BIT; 9796f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand break; 9806f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand default: 9813a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand break; /* Nothing to do */ 9826f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand } 9836f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand } 9846f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 985924fbfc9a1fc46a3698fa23649e6dccc3e3e6782Jason Ekstrand for_each_bit(b, dst_flags) { 986b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand switch ((VkAccessFlagBits)(1 << b)) { 987b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_INDIRECT_COMMAND_READ_BIT: 988b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_INDEX_READ_BIT: 989b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT: 9903a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_VF_CACHE_INVALIDATE_BIT; 9916f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand break; 992b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_UNIFORM_READ_BIT: 9933a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_CONSTANT_CACHE_INVALIDATE_BIT; 9943a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_TEXTURE_CACHE_INVALIDATE_BIT; 9956f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand break; 9963a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand case VK_ACCESS_SHADER_READ_BIT: 99757174d60421e9e63569335a269cd806703f5da5dJason Ekstrand case VK_ACCESS_INPUT_ATTACHMENT_READ_BIT: 998b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_TRANSFER_READ_BIT: 9993a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_TEXTURE_CACHE_INVALIDATE_BIT; 1000b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand break; 1001b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand default: 10023a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand break; /* Nothing to do */ 10036f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand } 10046f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand } 10056f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 10063a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand cmd_buffer->state.pending_pipe_bits |= pipe_bits; 10076f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand} 1008bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 100954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrandstatic void 101054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrandcmd_buffer_alloc_push_constants(struct anv_cmd_buffer *cmd_buffer) 101154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand{ 101254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand VkShaderStageFlags stages = cmd_buffer->state.pipeline->active_stages; 101354324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 101454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand /* In order to avoid thrash, we assume that vertex and fragment stages 101554324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * always exist. In the rare case where one is missing *and* the other 101654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * uses push concstants, this may be suboptimal. However, avoiding stalls 101754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * seems more important. 101854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand */ 101954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand stages |= VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_VERTEX_BIT; 102054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 102154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand if (stages == cmd_buffer->state.push_constant_stages) 102254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand return; 102354324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 102454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand#if GEN_GEN >= 8 102554324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand const unsigned push_constant_kb = 32; 102654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand#elif GEN_IS_HASWELL 102754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand const unsigned push_constant_kb = cmd_buffer->device->info.gt == 3 ? 32 : 16; 102854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand#else 102954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand const unsigned push_constant_kb = 16; 103054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand#endif 103154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 103254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand const unsigned num_stages = 103354324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand _mesa_bitcount(stages & VK_SHADER_STAGE_ALL_GRAPHICS); 103454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand unsigned size_per_stage = push_constant_kb / num_stages; 103554324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 103654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand /* Broadwell+ and Haswell gt3 require that the push constant sizes be in 103754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * units of 2KB. Incidentally, these are the same platforms that have 103854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * 32KB worth of push constant space. 103954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand */ 104054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand if (push_constant_kb == 32) 104154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand size_per_stage &= ~1u; 104254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 104354324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand uint32_t kb_used = 0; 104454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand for (int i = MESA_SHADER_VERTEX; i < MESA_SHADER_FRAGMENT; i++) { 104554324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand unsigned push_size = (stages & (1 << i)) ? size_per_stage : 0; 104654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, 104754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand GENX(3DSTATE_PUSH_CONSTANT_ALLOC_VS), alloc) { 104854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand alloc._3DCommandSubOpcode = 18 + i; 104954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand alloc.ConstantBufferOffset = (push_size > 0) ? kb_used : 0; 105054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand alloc.ConstantBufferSize = push_size; 105154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand } 105254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand kb_used += push_size; 105354324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand } 105454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 105554324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, 105654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand GENX(3DSTATE_PUSH_CONSTANT_ALLOC_PS), alloc) { 105754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand alloc.ConstantBufferOffset = kb_used; 105854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand alloc.ConstantBufferSize = push_constant_kb - kb_used; 105954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand } 106054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 106154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand cmd_buffer->state.push_constant_stages = stages; 106254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 106354324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand /* From the BDW PRM for 3DSTATE_PUSH_CONSTANT_ALLOC_VS: 106454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * 106554324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * "The 3DSTATE_CONSTANT_VS must be reprogrammed prior to 106654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * the next 3DPRIMITIVE command after programming the 106754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * 3DSTATE_PUSH_CONSTANT_ALLOC_VS" 106854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * 106954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * Since 3DSTATE_PUSH_CONSTANT_ALLOC_VS is programmed as part of 107054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * pipeline setup, we need to dirty push constants. 107154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand */ 107254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand cmd_buffer->state.push_constants_dirty |= VK_SHADER_STAGE_ALL_GRAPHICS; 107354324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand} 107454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 10757998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandstatic VkResult 10767998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandemit_binding_table(struct anv_cmd_buffer *cmd_buffer, 10777998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand gl_shader_stage stage, 10787998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_state *bt_state) 10797998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand{ 10807998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_subpass *subpass = cmd_buffer->state.subpass; 10817998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_pipeline *pipeline; 10827998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t bias, state_offset; 10837998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10847998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand switch (stage) { 10857998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case MESA_SHADER_COMPUTE: 10867998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand pipeline = cmd_buffer->state.compute_pipeline; 10877998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand bias = 1; 10887998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 10897998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand default: 10907998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand pipeline = cmd_buffer->state.pipeline; 10917998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand bias = 0; 10927998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 10937998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 10947998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10957998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (!anv_pipeline_has_stage(pipeline, stage)) { 10967998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *bt_state = (struct anv_state) { 0, }; 10977998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_SUCCESS; 10987998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 10997998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11007998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_pipeline_bind_map *map = &pipeline->shaders[stage]->bind_map; 11017998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (bias + map->surface_count == 0) { 11027998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *bt_state = (struct anv_state) { 0, }; 11037998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_SUCCESS; 11047998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 11057998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11067998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *bt_state = anv_cmd_buffer_alloc_binding_table(cmd_buffer, 11077998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand bias + map->surface_count, 11087998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand &state_offset); 11097998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t *bt_map = bt_state->map; 11107998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11117998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (bt_state->map == NULL) 11127998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_ERROR_OUT_OF_DEVICE_MEMORY; 11137998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11147998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (stage == MESA_SHADER_COMPUTE && 11157998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand get_cs_prog_data(cmd_buffer->state.compute_pipeline)->uses_num_work_groups) { 11167998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_bo *bo = cmd_buffer->state.num_workgroups_bo; 11177998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t bo_offset = cmd_buffer->state.num_workgroups_offset; 11187998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11197998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_state surface_state; 11207998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand surface_state = 11217998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_cmd_buffer_alloc_surface_state(cmd_buffer); 11227998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11237998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand const enum isl_format format = 11247998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_isl_format_for_descriptor_type(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER); 11257998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_fill_buffer_surface_state(cmd_buffer->device, surface_state, 11267998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand format, bo_offset, 12, 1); 11277998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11287998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand bt_map[0] = surface_state.offset + state_offset; 11299be9f5f1c71a5c8942b1f41d0512479a9899df42Jason Ekstrand add_surface_state_reloc(cmd_buffer, surface_state, bo, bo_offset); 11307998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 11317998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11327998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (map->surface_count == 0) 11337998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand goto out; 11347998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11357998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (map->image_count > 0) { 11367998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand VkResult result = 11377998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_cmd_buffer_ensure_push_constant_field(cmd_buffer, stage, images); 11387998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (result != VK_SUCCESS) 11397998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return result; 11407998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11417998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand cmd_buffer->state.push_constants_dirty |= 1 << stage; 11427998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 11437998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11447998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t image = 0; 11457998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand for (uint32_t s = 0; s < map->surface_count; s++) { 11467998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_pipeline_binding *binding = &map->surface_to_descriptor[s]; 11477998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11487998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_state surface_state; 11497998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11507998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (binding->set == ANV_DESCRIPTOR_SET_COLOR_ATTACHMENTS) { 11517998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand /* Color attachment binding */ 11527998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(stage == MESA_SHADER_FRAGMENT); 11537998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(binding->binding == 0); 11547998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (binding->index < subpass->color_count) { 1155d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand const unsigned att = subpass->color_attachments[binding->index]; 1156d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand surface_state = cmd_buffer->state.attachments[att].color_rt_state; 11577998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } else { 1158d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand surface_state = cmd_buffer->state.null_surface_state; 11597998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 11607998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11617998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand bt_map[bias + s] = surface_state.offset + state_offset; 11627998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand continue; 11637998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 11647998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11657998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_descriptor_set *set = 11667998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand cmd_buffer->state.descriptors[binding->set]; 11677998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t offset = set->layout->binding[binding->binding].descriptor_index; 11687998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_descriptor *desc = &set->descriptors[offset + binding->index]; 11697998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11707998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand switch (desc->type) { 11717998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_SAMPLER: 11727998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand /* Nothing for us to do here */ 11737998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand continue; 11747998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11757998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: 11767998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: 11777998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand surface_state = desc->image_view->sampler_surface_state; 11787998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(surface_state.alloc_size); 1179338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand add_image_view_relocs(cmd_buffer, desc->image_view, 1180edb7f67bd9c320cd47af20dc0a854e65fced7d9bJason Ekstrand desc->image_view->image->aux_usage, 1181edb7f67bd9c320cd47af20dc0a854e65fced7d9bJason Ekstrand surface_state); 11827998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 11837998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11841d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: 11851d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand assert(stage == MESA_SHADER_FRAGMENT); 118605d1c8aa020cb61b9a53cdec92fdbf4dc56f966aNanley Chery if (desc->image_view->aspect_mask != VK_IMAGE_ASPECT_COLOR_BIT) { 118705d1c8aa020cb61b9a53cdec92fdbf4dc56f966aNanley Chery /* For depth and stencil input attachments, we treat it like any 118805d1c8aa020cb61b9a53cdec92fdbf4dc56f966aNanley Chery * old texture that a user may have bound. 11891d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand */ 11901d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand surface_state = desc->image_view->sampler_surface_state; 11911d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand assert(surface_state.alloc_size); 11921d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand add_image_view_relocs(cmd_buffer, desc->image_view, 11931d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand desc->image_view->image->aux_usage, 11941d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand surface_state); 11951d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand } else { 119605d1c8aa020cb61b9a53cdec92fdbf4dc56f966aNanley Chery /* For color input attachments, we create the surface state at 119705d1c8aa020cb61b9a53cdec92fdbf4dc56f966aNanley Chery * vkBeginRenderPass time so that we can include aux and clear 119805d1c8aa020cb61b9a53cdec92fdbf4dc56f966aNanley Chery * color information. 11991d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand */ 12001d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand assert(binding->input_attachment_index < subpass->input_count); 12011d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand const unsigned subpass_att = binding->input_attachment_index; 12021d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand const unsigned att = subpass->input_attachments[subpass_att]; 12031d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand surface_state = cmd_buffer->state.attachments[att].input_att_state; 12041d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand } 12051d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand break; 12061d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand 12077998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: { 12087998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand surface_state = desc->image_view->storage_surface_state; 12097998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(surface_state.alloc_size); 1210338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand add_image_view_relocs(cmd_buffer, desc->image_view, 1211edb7f67bd9c320cd47af20dc0a854e65fced7d9bJason Ekstrand desc->image_view->image->aux_usage, 1212edb7f67bd9c320cd47af20dc0a854e65fced7d9bJason Ekstrand surface_state); 12137998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12147998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct brw_image_param *image_param = 12157998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand &cmd_buffer->state.push_constants[stage]->images[image++]; 12167998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12177998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *image_param = desc->image_view->storage_image_param; 12187998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand image_param->surface_idx = bias + s; 12197998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 12207998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 12217998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12227998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: 12237998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: 12247998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: 12257998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: 12267998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: 12277998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand surface_state = desc->buffer_view->surface_state; 12287998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(surface_state.alloc_size); 1229818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand add_surface_state_reloc(cmd_buffer, surface_state, 1230818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand desc->buffer_view->bo, 1231818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand desc->buffer_view->offset); 12327998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 12337998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12347998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: 12357998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand surface_state = desc->buffer_view->storage_surface_state; 12367998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(surface_state.alloc_size); 1237818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand add_surface_state_reloc(cmd_buffer, surface_state, 1238818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand desc->buffer_view->bo, 1239818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand desc->buffer_view->offset); 12407998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12417998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct brw_image_param *image_param = 12427998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand &cmd_buffer->state.push_constants[stage]->images[image++]; 12437998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12447998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *image_param = desc->buffer_view->storage_image_param; 12457998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand image_param->surface_idx = bias + s; 12467998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 12477998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12487998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand default: 12497998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(!"Invalid descriptor type"); 12507998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand continue; 12517998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 12527998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12537998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand bt_map[bias + s] = surface_state.offset + state_offset; 12547998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 12557998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(image == map->image_count); 12567998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12577998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand out: 12587998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (!cmd_buffer->device->info.has_llc) 12597998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_state_clflush(*bt_state); 12607998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12617998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_SUCCESS; 12627998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand} 12637998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12647998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandstatic VkResult 12657998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandemit_samplers(struct anv_cmd_buffer *cmd_buffer, 12667998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand gl_shader_stage stage, 12677998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_state *state) 12687998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand{ 12697998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_pipeline *pipeline; 12707998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12717998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (stage == MESA_SHADER_COMPUTE) 12727998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand pipeline = cmd_buffer->state.compute_pipeline; 12737998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand else 12747998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand pipeline = cmd_buffer->state.pipeline; 12757998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12767998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (!anv_pipeline_has_stage(pipeline, stage)) { 12777998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *state = (struct anv_state) { 0, }; 12787998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_SUCCESS; 12797998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 12807998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12817998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_pipeline_bind_map *map = &pipeline->shaders[stage]->bind_map; 12827998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (map->sampler_count == 0) { 12837998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *state = (struct anv_state) { 0, }; 12847998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_SUCCESS; 12857998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 12867998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12877998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t size = map->sampler_count * 16; 12887998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *state = anv_cmd_buffer_alloc_dynamic_state(cmd_buffer, size, 32); 12897998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12907998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (state->map == NULL) 12917998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_ERROR_OUT_OF_DEVICE_MEMORY; 12927998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12937998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand for (uint32_t s = 0; s < map->sampler_count; s++) { 12947998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_pipeline_binding *binding = &map->sampler_to_descriptor[s]; 12957998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_descriptor_set *set = 12967998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand cmd_buffer->state.descriptors[binding->set]; 12977998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t offset = set->layout->binding[binding->binding].descriptor_index; 12987998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_descriptor *desc = &set->descriptors[offset + binding->index]; 12997998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13007998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (desc->type != VK_DESCRIPTOR_TYPE_SAMPLER && 13017998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand desc->type != VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) 13027998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand continue; 13037998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13047998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_sampler *sampler = desc->sampler; 13057998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13067998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand /* This can happen if we have an unfilled slot since TYPE_SAMPLER 13077998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand * happens to be zero. 13087998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand */ 13097998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (sampler == NULL) 13107998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand continue; 13117998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13127998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand memcpy(state->map + (s * 16), 13137998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand sampler->state, sizeof(sampler->state)); 13147998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 13157998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13167998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (!cmd_buffer->device->info.has_llc) 13177998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_state_clflush(*state); 13187998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13197998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_SUCCESS; 13207998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand} 13217998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13227998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandstatic uint32_t 13237998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandflush_descriptor_sets(struct anv_cmd_buffer *cmd_buffer) 13247998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand{ 13257998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand VkShaderStageFlags dirty = cmd_buffer->state.descriptors_dirty & 13267998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand cmd_buffer->state.pipeline->active_stages; 13277998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13287998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand VkResult result = VK_SUCCESS; 13297998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_foreach_stage(s, dirty) { 13307998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand result = emit_samplers(cmd_buffer, s, &cmd_buffer->state.samplers[s]); 13317998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (result != VK_SUCCESS) 13327998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 13337998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand result = emit_binding_table(cmd_buffer, s, 13347998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand &cmd_buffer->state.binding_tables[s]); 13357998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (result != VK_SUCCESS) 13367998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 13377998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 13387998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13397998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (result != VK_SUCCESS) { 13407998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(result == VK_ERROR_OUT_OF_DEVICE_MEMORY); 13417998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13427998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand result = anv_cmd_buffer_new_binding_table_block(cmd_buffer); 13437998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(result == VK_SUCCESS); 13447998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13457998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand /* Re-emit state base addresses so we get the new surface state base 13467998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand * address before we start emitting binding tables etc. 13477998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand */ 13487998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand genX(cmd_buffer_emit_state_base_address)(cmd_buffer); 13497998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13507998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand /* Re-emit all active binding tables */ 13517998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand dirty |= cmd_buffer->state.pipeline->active_stages; 13527998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_foreach_stage(s, dirty) { 13537998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand result = emit_samplers(cmd_buffer, s, &cmd_buffer->state.samplers[s]); 13547998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (result != VK_SUCCESS) 13557998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return result; 13567998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand result = emit_binding_table(cmd_buffer, s, 13577998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand &cmd_buffer->state.binding_tables[s]); 13587998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (result != VK_SUCCESS) 13597998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return result; 13607998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 13617998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 13627998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13637998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand cmd_buffer->state.descriptors_dirty &= ~dirty; 13647998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13657998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return dirty; 13667998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand} 13677998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13687998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandstatic void 13692bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrandcmd_buffer_emit_descriptor_pointers(struct anv_cmd_buffer *cmd_buffer, 13702bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand uint32_t stages) 13712bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand{ 13722bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand static const uint32_t sampler_state_opcodes[] = { 13732bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_VERTEX] = 43, 13742bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_TESS_CTRL] = 44, /* HS */ 13752bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_TESS_EVAL] = 45, /* DS */ 13762bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_GEOMETRY] = 46, 13772bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_FRAGMENT] = 47, 13782bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_COMPUTE] = 0, 13792bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand }; 13802bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand 13812bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand static const uint32_t binding_table_opcodes[] = { 13822bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_VERTEX] = 38, 13832bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_TESS_CTRL] = 39, 13842bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_TESS_EVAL] = 40, 13852bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_GEOMETRY] = 41, 13862bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_FRAGMENT] = 42, 13872bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_COMPUTE] = 0, 13882bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand }; 13892bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand 13902bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand anv_foreach_stage(s, stages) { 13912bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand if (cmd_buffer->state.samplers[s].alloc_size > 0) { 13922bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand anv_batch_emit(&cmd_buffer->batch, 13932bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand GENX(3DSTATE_SAMPLER_STATE_POINTERS_VS), ssp) { 13942bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand ssp._3DCommandSubOpcode = sampler_state_opcodes[s]; 13952bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand ssp.PointertoVSSamplerState = cmd_buffer->state.samplers[s].offset; 13962bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand } 13972bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand } 13982bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand 13992bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand /* Always emit binding table pointers if we're asked to, since on SKL 14002bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand * this is what flushes push constants. */ 14012bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand anv_batch_emit(&cmd_buffer->batch, 14022bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand GENX(3DSTATE_BINDING_TABLE_POINTERS_VS), btp) { 14032bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand btp._3DCommandSubOpcode = binding_table_opcodes[s]; 14042bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand btp.PointertoVSBindingTable = cmd_buffer->state.binding_tables[s].offset; 14052bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand } 14062bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand } 14072bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand} 14082bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand 1409248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrandstatic uint32_t 1410248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrandcmd_buffer_flush_push_constants(struct anv_cmd_buffer *cmd_buffer) 1411248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand{ 1412248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand static const uint32_t push_constant_opcodes[] = { 1413248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand [MESA_SHADER_VERTEX] = 21, 1414248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand [MESA_SHADER_TESS_CTRL] = 25, /* HS */ 1415248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand [MESA_SHADER_TESS_EVAL] = 26, /* DS */ 1416248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand [MESA_SHADER_GEOMETRY] = 22, 1417248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand [MESA_SHADER_FRAGMENT] = 23, 1418248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand [MESA_SHADER_COMPUTE] = 0, 1419248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand }; 1420248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1421248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand VkShaderStageFlags flushed = 0; 1422248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1423248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand anv_foreach_stage(stage, cmd_buffer->state.push_constants_dirty) { 1424248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (stage == MESA_SHADER_COMPUTE) 1425248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand continue; 1426248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1427248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand struct anv_state state = anv_cmd_buffer_push_constants(cmd_buffer, stage); 1428248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1429248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (state.offset == 0) { 143050018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_CONSTANT_VS), c) 143106fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand c._3DCommandSubOpcode = push_constant_opcodes[stage]; 1432248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } else { 143350018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_CONSTANT_VS), c) { 143406fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand c._3DCommandSubOpcode = push_constant_opcodes[stage], 143506fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand c.ConstantBody = (struct GENX(3DSTATE_CONSTANT_BODY)) { 1436248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#if GEN_GEN >= 9 143706fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand .PointerToConstantBuffer2 = { &cmd_buffer->device->dynamic_state_block_pool.bo, state.offset }, 143806fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand .ConstantBuffer2ReadLength = DIV_ROUND_UP(state.alloc_size, 32), 1439248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#else 144006fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand .PointerToConstantBuffer0 = { .offset = state.offset }, 144106fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand .ConstantBuffer0ReadLength = DIV_ROUND_UP(state.alloc_size, 32), 1442248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#endif 144306fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand }; 144406fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand } 1445248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1446248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1447248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand flushed |= mesa_to_vk_shader_stage(stage); 1448248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1449248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1450248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand cmd_buffer->state.push_constants_dirty &= ~VK_SHADER_STAGE_ALL_GRAPHICS; 1451248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1452248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand return flushed; 1453248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand} 1454248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1455248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrandvoid 1456248ab61740c4082517424f5aa94b2f4e7b210d76Jason EkstrandgenX(cmd_buffer_flush_state)(struct anv_cmd_buffer *cmd_buffer) 1457248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand{ 1458248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand struct anv_pipeline *pipeline = cmd_buffer->state.pipeline; 1459248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand uint32_t *p; 1460248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1461248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand uint32_t vb_emit = cmd_buffer->state.vb_dirty & pipeline->vb_used; 1462248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1463248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand assert((pipeline->active_stages & VK_SHADER_STAGE_COMPUTE_BIT) == 0); 1464248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 14657e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand genX(cmd_buffer_config_l3)(cmd_buffer, pipeline->urb.l3_config); 1466248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1467248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand genX(flush_pipeline_select_3d)(cmd_buffer); 1468248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1469248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (vb_emit) { 1470248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand const uint32_t num_buffers = __builtin_popcount(vb_emit); 1471248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand const uint32_t num_dwords = 1 + num_buffers * 4; 1472248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1473248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand p = anv_batch_emitn(&cmd_buffer->batch, num_dwords, 1474248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand GENX(3DSTATE_VERTEX_BUFFERS)); 1475248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand uint32_t vb, i = 0; 1476248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand for_each_bit(vb, vb_emit) { 1477248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand struct anv_buffer *buffer = cmd_buffer->state.vertex_bindings[vb].buffer; 1478248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand uint32_t offset = cmd_buffer->state.vertex_bindings[vb].offset; 1479248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1480248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand struct GENX(VERTEX_BUFFER_STATE) state = { 1481248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .VertexBufferIndex = vb, 1482248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1483248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#if GEN_GEN >= 8 1484248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .MemoryObjectControlState = GENX(MOCS), 1485248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#else 1486248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .BufferAccessType = pipeline->instancing_enable[vb] ? INSTANCEDATA : VERTEXDATA, 1487248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .InstanceDataStepRate = 1, 1488248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .VertexBufferMemoryObjectControlState = GENX(MOCS), 1489248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#endif 1490248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1491248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .AddressModifyEnable = true, 1492248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .BufferPitch = pipeline->binding_stride[vb], 1493248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .BufferStartingAddress = { buffer->bo, buffer->offset + offset }, 1494248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1495248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#if GEN_GEN >= 8 1496248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .BufferSize = buffer->size - offset 1497248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#else 1498248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .EndAddress = { buffer->bo, buffer->offset + buffer->size - 1}, 1499248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#endif 1500248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand }; 1501248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1502248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand GENX(VERTEX_BUFFER_STATE_pack)(&cmd_buffer->batch, &p[1 + i * 4], &state); 1503248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand i++; 1504248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1505248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1506248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1507248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand cmd_buffer->state.vb_dirty &= ~vb_emit; 1508248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1509248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (cmd_buffer->state.dirty & ANV_CMD_DIRTY_PIPELINE) { 1510248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand anv_batch_emit_batch(&cmd_buffer->batch, &pipeline->batch); 1511248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 151235b53c8d47d3a0b53ee2549d73296d5db8e3cca0Jason Ekstrand /* The exact descriptor layout is pulled from the pipeline, so we need 151335b53c8d47d3a0b53ee2549d73296d5db8e3cca0Jason Ekstrand * to re-emit binding tables on every pipeline change. 151435b53c8d47d3a0b53ee2549d73296d5db8e3cca0Jason Ekstrand */ 151535b53c8d47d3a0b53ee2549d73296d5db8e3cca0Jason Ekstrand cmd_buffer->state.descriptors_dirty |= 151635b53c8d47d3a0b53ee2549d73296d5db8e3cca0Jason Ekstrand cmd_buffer->state.pipeline->active_stages; 151735b53c8d47d3a0b53ee2549d73296d5db8e3cca0Jason Ekstrand 151854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand /* If the pipeline changed, we may need to re-allocate push constant 151954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * space in the URB. 1520248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand */ 152154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand cmd_buffer_alloc_push_constants(cmd_buffer); 1522248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1523248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1524248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#if GEN_GEN <= 7 1525248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (cmd_buffer->state.descriptors_dirty & VK_SHADER_STAGE_VERTEX_BIT || 1526248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand cmd_buffer->state.push_constants_dirty & VK_SHADER_STAGE_VERTEX_BIT) { 1527248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand /* From the IVB PRM Vol. 2, Part 1, Section 3.2.1: 1528248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * 1529248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * "A PIPE_CONTROL with Post-Sync Operation set to 1h and a depth 1530248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * stall needs to be sent just prior to any 3DSTATE_VS, 1531248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * 3DSTATE_URB_VS, 3DSTATE_CONSTANT_VS, 1532248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * 3DSTATE_BINDING_TABLE_POINTER_VS, 1533248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * 3DSTATE_SAMPLER_STATE_POINTER_VS command. Only one 1534248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * PIPE_CONTROL needs to be sent before any combination of VS 1535248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * associated 3DSTATE." 1536248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand */ 153750018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 153856453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DepthStallEnable = true; 153956453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.PostSyncOperation = WriteImmediateData; 154056453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.Address = 154156453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand (struct anv_address) { &cmd_buffer->device->workaround_bo, 0 }; 154256453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 1543248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1544248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#endif 1545248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1546fe4e276b02615b5db8acbf4c65fcfa68982e2e0fJason Ekstrand /* Render targets live in the same binding table as fragment descriptors */ 1547fe4e276b02615b5db8acbf4c65fcfa68982e2e0fJason Ekstrand if (cmd_buffer->state.dirty & ANV_CMD_DIRTY_RENDER_TARGETS) 1548fe4e276b02615b5db8acbf4c65fcfa68982e2e0fJason Ekstrand cmd_buffer->state.descriptors_dirty |= VK_SHADER_STAGE_FRAGMENT_BIT; 1549fe4e276b02615b5db8acbf4c65fcfa68982e2e0fJason Ekstrand 1550248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand /* We emit the binding tables and sampler tables first, then emit push 1551248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * constants and then finally emit binding table and sampler table 1552248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * pointers. It has to happen in this order, since emitting the binding 1553248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * tables may change the push constants (in case of storage images). After 1554248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * emitting push constants, on SKL+ we have to emit the corresponding 1555248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * 3DSTATE_BINDING_TABLE_POINTER_* for the push constants to take effect. 1556248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand */ 1557248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand uint32_t dirty = 0; 1558248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (cmd_buffer->state.descriptors_dirty) 15597998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand dirty = flush_descriptor_sets(cmd_buffer); 1560248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1561248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (cmd_buffer->state.push_constants_dirty) { 1562248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#if GEN_GEN >= 9 1563248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand /* On Sky Lake and later, the binding table pointers commands are 1564248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * what actually flush the changes to push constant state so we need 1565248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * to dirty them so they get re-emitted below. 1566248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand */ 1567248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand dirty |= cmd_buffer_flush_push_constants(cmd_buffer); 1568248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#else 1569248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand cmd_buffer_flush_push_constants(cmd_buffer); 1570248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#endif 1571248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1572248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1573248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (dirty) 15742bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand cmd_buffer_emit_descriptor_pointers(cmd_buffer, dirty); 1575248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1576eb6764c4a73006eee32e19e3afc6eab100a2ce16Jason Ekstrand if (cmd_buffer->state.dirty & ANV_CMD_DIRTY_DYNAMIC_VIEWPORT) 1577248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand gen8_cmd_buffer_emit_viewport(cmd_buffer); 1578eb6764c4a73006eee32e19e3afc6eab100a2ce16Jason Ekstrand 1579eb6764c4a73006eee32e19e3afc6eab100a2ce16Jason Ekstrand if (cmd_buffer->state.dirty & (ANV_CMD_DIRTY_DYNAMIC_VIEWPORT | 1580eb6764c4a73006eee32e19e3afc6eab100a2ce16Jason Ekstrand ANV_CMD_DIRTY_PIPELINE)) { 1581eb6764c4a73006eee32e19e3afc6eab100a2ce16Jason Ekstrand gen8_cmd_buffer_emit_depth_viewport(cmd_buffer, 1582eb6764c4a73006eee32e19e3afc6eab100a2ce16Jason Ekstrand pipeline->depth_clamp_enable); 15838a46b505cb2c7255ad430b56c1ce0dfa9c13c559Jason Ekstrand } 1584248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1585248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (cmd_buffer->state.dirty & ANV_CMD_DIRTY_DYNAMIC_SCISSOR) 1586248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand gen7_cmd_buffer_emit_scissor(cmd_buffer); 1587248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1588248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand genX(cmd_buffer_flush_dynamic_state)(cmd_buffer); 15893a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 15903a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand genX(cmd_buffer_apply_pipe_flushes)(cmd_buffer); 1591248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand} 1592248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1593bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergstatic void 1594bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergemit_base_vertex_instance_bo(struct anv_cmd_buffer *cmd_buffer, 1595bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_bo *bo, uint32_t offset) 1596bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg{ 1597bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t *p = anv_batch_emitn(&cmd_buffer->batch, 5, 1598bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg GENX(3DSTATE_VERTEX_BUFFERS)); 1599bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1600bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg GENX(VERTEX_BUFFER_STATE_pack)(&cmd_buffer->batch, p + 1, 1601bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg &(struct GENX(VERTEX_BUFFER_STATE)) { 1602bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .VertexBufferIndex = 32, /* Reserved for this */ 1603bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .AddressModifyEnable = true, 1604bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .BufferPitch = 0, 1605371b4a5b33a13f35fa7783510d2d90685a9a2e8aJason Ekstrand#if (GEN_GEN >= 8) 1606bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .MemoryObjectControlState = GENX(MOCS), 1607bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .BufferStartingAddress = { bo, offset }, 1608bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .BufferSize = 8 1609bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#else 1610bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .VertexBufferMemoryObjectControlState = GENX(MOCS), 1611bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .BufferStartingAddress = { bo, offset }, 1612bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .EndAddress = { bo, offset + 8 }, 1613bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#endif 1614bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg }); 1615bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg} 1616bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1617bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergstatic void 1618bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergemit_base_vertex_instance(struct anv_cmd_buffer *cmd_buffer, 1619bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t base_vertex, uint32_t base_instance) 1620bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg{ 1621bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_state id_state = 1622bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg anv_cmd_buffer_alloc_dynamic_state(cmd_buffer, 8, 4); 1623bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1624bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ((uint32_t *)id_state.map)[0] = base_vertex; 1625bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ((uint32_t *)id_state.map)[1] = base_instance; 1626bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1627bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg if (!cmd_buffer->device->info.has_llc) 1628bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg anv_state_clflush(id_state); 1629bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1630bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_base_vertex_instance_bo(cmd_buffer, 1631bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg &cmd_buffer->device->dynamic_state_block_pool.bo, id_state.offset); 1632bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg} 1633bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1634bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergvoid genX(CmdDraw)( 1635bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkCommandBuffer commandBuffer, 1636bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t vertexCount, 1637bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t instanceCount, 1638bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t firstVertex, 1639bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t firstInstance) 1640bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg{ 1641bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 1642bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_pipeline *pipeline = cmd_buffer->state.pipeline; 16432b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg const struct brw_vs_prog_data *vs_prog_data = get_vs_prog_data(pipeline); 1644bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1645bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg genX(cmd_buffer_flush_state)(cmd_buffer); 1646bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 16472b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg if (vs_prog_data->uses_basevertex || vs_prog_data->uses_baseinstance) 1648bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_base_vertex_instance(cmd_buffer, firstVertex, firstInstance); 1649bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 165050018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DPRIMITIVE), prim) { 16511d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.VertexAccessType = SEQUENTIAL; 16521d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.PrimitiveTopologyType = pipeline->topology; 16531d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.VertexCountPerInstance = vertexCount; 16541d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.StartVertexLocation = firstVertex; 16551d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.InstanceCount = instanceCount; 16561d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.StartInstanceLocation = firstInstance; 16571d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.BaseVertexLocation = 0; 16581d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand } 1659bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg} 1660bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1661bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergvoid genX(CmdDrawIndexed)( 1662bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkCommandBuffer commandBuffer, 1663bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t indexCount, 1664bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t instanceCount, 1665bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t firstIndex, 1666bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg int32_t vertexOffset, 1667bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t firstInstance) 1668bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg{ 1669bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 1670bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_pipeline *pipeline = cmd_buffer->state.pipeline; 16712b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg const struct brw_vs_prog_data *vs_prog_data = get_vs_prog_data(pipeline); 1672bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1673bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg genX(cmd_buffer_flush_state)(cmd_buffer); 1674bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 16752b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg if (vs_prog_data->uses_basevertex || vs_prog_data->uses_baseinstance) 1676bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_base_vertex_instance(cmd_buffer, vertexOffset, firstInstance); 1677bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 167850018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DPRIMITIVE), prim) { 16791d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.VertexAccessType = RANDOM; 16801d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.PrimitiveTopologyType = pipeline->topology; 16811d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.VertexCountPerInstance = indexCount; 16821d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.StartVertexLocation = firstIndex; 16831d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.InstanceCount = instanceCount; 16841d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.StartInstanceLocation = firstInstance; 16851d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.BaseVertexLocation = vertexOffset; 16861d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand } 1687bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg} 1688bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1689bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg/* Auto-Draw / Indirect Registers */ 1690bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#define GEN7_3DPRIM_END_OFFSET 0x2420 1691bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#define GEN7_3DPRIM_START_VERTEX 0x2430 1692bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#define GEN7_3DPRIM_VERTEX_COUNT 0x2434 1693bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#define GEN7_3DPRIM_INSTANCE_COUNT 0x2438 1694bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#define GEN7_3DPRIM_START_INSTANCE 0x243C 1695bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#define GEN7_3DPRIM_BASE_VERTEX 0x2440 1696bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1697bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergvoid genX(CmdDrawIndirect)( 1698bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkCommandBuffer commandBuffer, 1699bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkBuffer _buffer, 1700bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkDeviceSize offset, 1701bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t drawCount, 1702bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t stride) 1703bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg{ 1704bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 1705bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ANV_FROM_HANDLE(anv_buffer, buffer, _buffer); 1706bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_pipeline *pipeline = cmd_buffer->state.pipeline; 17072b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg const struct brw_vs_prog_data *vs_prog_data = get_vs_prog_data(pipeline); 1708bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_bo *bo = buffer->bo; 1709bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t bo_offset = buffer->offset + offset; 1710bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1711bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg genX(cmd_buffer_flush_state)(cmd_buffer); 1712bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 17132b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg if (vs_prog_data->uses_basevertex || vs_prog_data->uses_baseinstance) 1714bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_base_vertex_instance_bo(cmd_buffer, bo, bo_offset + 8); 1715bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1716bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_VERTEX_COUNT, bo, bo_offset); 1717bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_INSTANCE_COUNT, bo, bo_offset + 4); 1718bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_START_VERTEX, bo, bo_offset + 8); 1719bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_START_INSTANCE, bo, bo_offset + 12); 1720bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lri(&cmd_buffer->batch, GEN7_3DPRIM_BASE_VERTEX, 0); 1721bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 172250018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DPRIMITIVE), prim) { 17231d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.IndirectParameterEnable = true; 17241d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.VertexAccessType = SEQUENTIAL; 17251d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.PrimitiveTopologyType = pipeline->topology; 17261d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand } 1727bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg} 1728bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1729bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergvoid genX(CmdDrawIndexedIndirect)( 1730bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkCommandBuffer commandBuffer, 1731bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkBuffer _buffer, 1732bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkDeviceSize offset, 1733bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t drawCount, 1734bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t stride) 1735bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg{ 1736bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 1737bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ANV_FROM_HANDLE(anv_buffer, buffer, _buffer); 1738bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_pipeline *pipeline = cmd_buffer->state.pipeline; 17392b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg const struct brw_vs_prog_data *vs_prog_data = get_vs_prog_data(pipeline); 1740bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_bo *bo = buffer->bo; 1741bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t bo_offset = buffer->offset + offset; 1742bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1743bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg genX(cmd_buffer_flush_state)(cmd_buffer); 1744bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1745bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg /* TODO: We need to stomp base vertex to 0 somehow */ 17462b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg if (vs_prog_data->uses_basevertex || vs_prog_data->uses_baseinstance) 1747bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_base_vertex_instance_bo(cmd_buffer, bo, bo_offset + 12); 1748bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1749bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_VERTEX_COUNT, bo, bo_offset); 1750bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_INSTANCE_COUNT, bo, bo_offset + 4); 1751bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_START_VERTEX, bo, bo_offset + 8); 1752bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_BASE_VERTEX, bo, bo_offset + 12); 1753bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_START_INSTANCE, bo, bo_offset + 16); 1754bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 175550018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DPRIMITIVE), prim) { 17561d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.IndirectParameterEnable = true; 17571d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.VertexAccessType = RANDOM; 17581d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.PrimitiveTopologyType = pipeline->topology; 17591d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand } 1760bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg} 17616c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 17621f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrandstatic VkResult 17631f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrandflush_compute_descriptor_set(struct anv_cmd_buffer *cmd_buffer) 17641f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand{ 17651f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand struct anv_pipeline *pipeline = cmd_buffer->state.compute_pipeline; 17661f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand struct anv_state surfaces = { 0, }, samplers = { 0, }; 17671f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand VkResult result; 17681f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 17697998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand result = emit_binding_table(cmd_buffer, MESA_SHADER_COMPUTE, &surfaces); 1770722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand if (result != VK_SUCCESS) { 17713ef8dff865fd7365ba36b49c43b5c858d26587edJason Ekstrand assert(result == VK_ERROR_OUT_OF_DEVICE_MEMORY); 1772722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand result = anv_cmd_buffer_new_binding_table_block(cmd_buffer); 1773722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand assert(result == VK_SUCCESS); 1774722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand 1775722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand /* Re-emit state base addresses so we get the new surface state base 1776722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand * address before we start emitting binding tables etc. 1777722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand */ 1778722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand genX(cmd_buffer_emit_state_base_address)(cmd_buffer); 1779722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand 1780722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand result = emit_binding_table(cmd_buffer, MESA_SHADER_COMPUTE, &surfaces); 1781722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand assert(result == VK_SUCCESS); 1782722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand } 1783054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand 1784722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand result = emit_samplers(cmd_buffer, MESA_SHADER_COMPUTE, &samplers); 1785722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand assert(result == VK_SUCCESS); 1786722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand 1787d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand uint32_t iface_desc_data_dw[GENX(INTERFACE_DESCRIPTOR_DATA_length)]; 1788d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand struct GENX(INTERFACE_DESCRIPTOR_DATA) desc = { 1789d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand .BindingTablePointer = surfaces.offset, 1790d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand .SamplerStatePointer = samplers.offset, 1791d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand }; 1792d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand GENX(INTERFACE_DESCRIPTOR_DATA_pack)(NULL, iface_desc_data_dw, &desc); 17931f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 17941f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand struct anv_state state = 1795d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand anv_cmd_buffer_merge_dynamic(cmd_buffer, iface_desc_data_dw, 1796d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand pipeline->interface_descriptor_data, 1797d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand GENX(INTERFACE_DESCRIPTOR_DATA_length), 1798d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand 64); 17991f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 18001f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand uint32_t size = GENX(INTERFACE_DESCRIPTOR_DATA_length) * sizeof(uint32_t); 18011f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, 18021f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand GENX(MEDIA_INTERFACE_DESCRIPTOR_LOAD), mid) { 18031f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand mid.InterfaceDescriptorTotalLength = size; 18041f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand mid.InterfaceDescriptorDataStartAddress = state.offset; 18051f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand } 18061f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 18071f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand return VK_SUCCESS; 18081f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand} 18091f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 18101f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrandvoid 18111f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason EkstrandgenX(cmd_buffer_flush_compute_state)(struct anv_cmd_buffer *cmd_buffer) 18121f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand{ 18131f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand struct anv_pipeline *pipeline = cmd_buffer->state.compute_pipeline; 18141f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand MAYBE_UNUSED VkResult result; 18151f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 18161f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand assert(pipeline->active_stages == VK_SHADER_STAGE_COMPUTE_BIT); 18171f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 18181f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand genX(cmd_buffer_config_l3)(cmd_buffer, pipeline->urb.l3_config); 18191f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 18201f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand genX(flush_pipeline_select_gpgpu)(cmd_buffer); 18211f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 1822f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand if (cmd_buffer->state.compute_dirty & ANV_CMD_DIRTY_PIPELINE) { 1823f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand /* From the Sky Lake PRM Vol 2a, MEDIA_VFE_STATE: 1824f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand * 1825f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand * "A stalling PIPE_CONTROL is required before MEDIA_VFE_STATE unless 1826f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand * the only bits that are changed are scoreboard related: Scoreboard 1827f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand * Enable, Scoreboard Type, Scoreboard Mask, Scoreboard * Delta. For 1828f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand * these scoreboard related states, a MEDIA_STATE_FLUSH is 1829f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand * sufficient." 1830f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand */ 1831f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand cmd_buffer->state.pending_pipe_bits |= ANV_PIPE_CS_STALL_BIT; 1832f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand genX(cmd_buffer_apply_pipe_flushes)(cmd_buffer); 1833f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand 18341f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand anv_batch_emit_batch(&cmd_buffer->batch, &pipeline->batch); 1835f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand } 18361f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 18377a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand if ((cmd_buffer->state.descriptors_dirty & VK_SHADER_STAGE_COMPUTE_BIT) || 18387a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand (cmd_buffer->state.compute_dirty & ANV_CMD_DIRTY_PIPELINE)) { 18397a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand /* FIXME: figure out descriptors for gen7 */ 18407a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand result = flush_compute_descriptor_set(cmd_buffer); 18417a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand assert(result == VK_SUCCESS); 18427a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand cmd_buffer->state.descriptors_dirty &= ~VK_SHADER_STAGE_COMPUTE_BIT; 18437a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand } 18447a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand 1845054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand if (cmd_buffer->state.push_constants_dirty & VK_SHADER_STAGE_COMPUTE_BIT) { 1846054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand struct anv_state push_state = 1847054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand anv_cmd_buffer_cs_push_constants(cmd_buffer); 1848054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand 1849054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand if (push_state.alloc_size) { 1850054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(MEDIA_CURBE_LOAD), curbe) { 1851054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand curbe.CURBETotalDataLength = push_state.alloc_size; 1852054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand curbe.CURBEDataStartAddress = push_state.offset; 1853054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand } 1854054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand } 1855054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand } 1856054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand 18571f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand cmd_buffer->state.compute_dirty = 0; 18581f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 18591f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand genX(cmd_buffer_apply_pipe_flushes)(cmd_buffer); 18601f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand} 18611f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 18628dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen#if GEN_GEN == 7 18638dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen 18648dbfa265a439904628c2d875885e80bc45a90a05Jordan Justenstatic bool 18658dbfa265a439904628c2d875885e80bc45a90a05Jordan Justenverify_cmd_parser(const struct anv_device *device, 18668dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen int required_version, 18678dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen const char *function) 18688dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen{ 18698dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen if (device->instance->physicalDevice.cmd_parser_version < required_version) { 18708dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen vk_errorf(VK_ERROR_FEATURE_NOT_PRESENT, 18718dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen "cmd parser version %d is required for %s", 18728dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen required_version, function); 18738dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen return false; 18748dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen } else { 18758dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen return true; 18768dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen } 18778dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen} 18788dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen 18798dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen#endif 18806c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 18816c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsbergvoid genX(CmdDispatch)( 18826c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg VkCommandBuffer commandBuffer, 18836c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg uint32_t x, 18846c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg uint32_t y, 18856c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg uint32_t z) 18866c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg{ 18876c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 18886c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg struct anv_pipeline *pipeline = cmd_buffer->state.compute_pipeline; 18892b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg const struct brw_cs_prog_data *prog_data = get_cs_prog_data(pipeline); 18906c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 18916c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg if (prog_data->uses_num_work_groups) { 18926c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg struct anv_state state = 18936c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg anv_cmd_buffer_alloc_dynamic_state(cmd_buffer, 12, 4); 18946c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg uint32_t *sizes = state.map; 18956c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg sizes[0] = x; 18966c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg sizes[1] = y; 18976c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg sizes[2] = z; 18986c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg if (!cmd_buffer->device->info.has_llc) 18996c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg anv_state_clflush(state); 19006c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg cmd_buffer->state.num_workgroups_offset = state.offset; 19016c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg cmd_buffer->state.num_workgroups_bo = 19026c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg &cmd_buffer->device->dynamic_state_block_pool.bo; 19036c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg } 19046c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 19056c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg genX(cmd_buffer_flush_compute_state)(cmd_buffer); 19066c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 190750018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(GPGPU_WALKER), ggw) { 1908deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.SIMDSize = prog_data->simd_size / 16; 1909deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadDepthCounterMaximum = 0; 1910deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadHeightCounterMaximum = 0; 19111b79e7ebbd77a7e714fafadd91459059aacf2407Jordan Justen ggw.ThreadWidthCounterMaximum = prog_data->threads - 1; 1912deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadGroupIDXDimension = x; 1913deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadGroupIDYDimension = y; 1914deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadGroupIDZDimension = z; 1915deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.RightExecutionMask = pipeline->cs_right_mask; 1916deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.BottomExecutionMask = 0xffffffff; 1917deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 1918deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand 191950018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(MEDIA_STATE_FLUSH), msf); 19206c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg} 19216c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 19226c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg#define GPGPU_DISPATCHDIMX 0x2500 19236c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg#define GPGPU_DISPATCHDIMY 0x2504 19246c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg#define GPGPU_DISPATCHDIMZ 0x2508 19256c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 192698cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen#define MI_PREDICATE_SRC0 0x2400 192798cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen#define MI_PREDICATE_SRC1 0x2408 192898cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 19296c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsbergvoid genX(CmdDispatchIndirect)( 19306c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg VkCommandBuffer commandBuffer, 19316c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg VkBuffer _buffer, 19326c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg VkDeviceSize offset) 19336c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg{ 19346c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 19356c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg ANV_FROM_HANDLE(anv_buffer, buffer, _buffer); 19366c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg struct anv_pipeline *pipeline = cmd_buffer->state.compute_pipeline; 19372b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg const struct brw_cs_prog_data *prog_data = get_cs_prog_data(pipeline); 19386c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg struct anv_bo *bo = buffer->bo; 19396c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg uint32_t bo_offset = buffer->offset + offset; 1940da4745104cc02fc0052a2e05e37c69a4dce76eefJordan Justen struct anv_batch *batch = &cmd_buffer->batch; 19416c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 19428dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen#if GEN_GEN == 7 19438dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen /* Linux 4.4 added command parser version 5 which allows the GPGPU 19448dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen * indirect dispatch registers to be written. 19458dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen */ 1946f56f538ce4753a6fdd969b610f35433fd657e4eeJordan Justen if (!verify_cmd_parser(cmd_buffer->device, 5, "vkCmdDispatchIndirect")) 19478dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen return; 19488dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen#endif 19498dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen 19506c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg if (prog_data->uses_num_work_groups) { 19516c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg cmd_buffer->state.num_workgroups_offset = bo_offset; 19526c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg cmd_buffer->state.num_workgroups_bo = bo; 19536c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg } 19546c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 19556c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg genX(cmd_buffer_flush_compute_state)(cmd_buffer); 19566c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 1957da4745104cc02fc0052a2e05e37c69a4dce76eefJordan Justen emit_lrm(batch, GPGPU_DISPATCHDIMX, bo, bo_offset); 1958da4745104cc02fc0052a2e05e37c69a4dce76eefJordan Justen emit_lrm(batch, GPGPU_DISPATCHDIMY, bo, bo_offset + 4); 1959da4745104cc02fc0052a2e05e37c69a4dce76eefJordan Justen emit_lrm(batch, GPGPU_DISPATCHDIMZ, bo, bo_offset + 8); 19606c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 196198cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen#if GEN_GEN <= 7 196298cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* Clear upper 32-bits of SRC0 and all 64-bits of SRC1 */ 196398cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen emit_lri(batch, MI_PREDICATE_SRC0 + 4, 0); 196498cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen emit_lri(batch, MI_PREDICATE_SRC1 + 0, 0); 196598cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen emit_lri(batch, MI_PREDICATE_SRC1 + 4, 0); 196698cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 196798cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* Load compute_dispatch_indirect_x_size into SRC0 */ 196898cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen emit_lrm(batch, MI_PREDICATE_SRC0, bo, bo_offset + 0); 196998cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 197098cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* predicate = (compute_dispatch_indirect_x_size == 0); */ 197150018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_PREDICATE), mip) { 1972deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.LoadOperation = LOAD_LOAD; 1973deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CombineOperation = COMBINE_SET; 1974deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CompareOperation = COMPARE_SRCS_EQUAL; 1975deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 197698cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 197798cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* Load compute_dispatch_indirect_y_size into SRC0 */ 197898cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen emit_lrm(batch, MI_PREDICATE_SRC0, bo, bo_offset + 4); 197998cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 198098cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* predicate |= (compute_dispatch_indirect_y_size == 0); */ 198150018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_PREDICATE), mip) { 1982deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.LoadOperation = LOAD_LOAD; 1983deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CombineOperation = COMBINE_OR; 1984deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CompareOperation = COMPARE_SRCS_EQUAL; 1985deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 198698cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 198798cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* Load compute_dispatch_indirect_z_size into SRC0 */ 198898cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen emit_lrm(batch, MI_PREDICATE_SRC0, bo, bo_offset + 8); 198998cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 199098cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* predicate |= (compute_dispatch_indirect_z_size == 0); */ 199150018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_PREDICATE), mip) { 1992deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.LoadOperation = LOAD_LOAD; 1993deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CombineOperation = COMBINE_OR; 1994deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CompareOperation = COMPARE_SRCS_EQUAL; 1995deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 199698cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 199798cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* predicate = !predicate; */ 199898cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen#define COMPARE_FALSE 1 199950018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_PREDICATE), mip) { 2000deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.LoadOperation = LOAD_LOADINV; 2001deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CombineOperation = COMBINE_OR; 2002deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CompareOperation = COMPARE_FALSE; 2003deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 200498cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen#endif 200598cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 200650018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(GPGPU_WALKER), ggw) { 2007deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.IndirectParameterEnable = true; 2008deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.PredicateEnable = GEN_GEN <= 7; 2009deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.SIMDSize = prog_data->simd_size / 16; 2010deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadDepthCounterMaximum = 0; 2011deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadHeightCounterMaximum = 0; 20121b79e7ebbd77a7e714fafadd91459059aacf2407Jordan Justen ggw.ThreadWidthCounterMaximum = prog_data->threads - 1; 2013deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.RightExecutionMask = pipeline->cs_right_mask; 2014deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.BottomExecutionMask = 0xffffffff; 2015deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 2016deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand 201750018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MEDIA_STATE_FLUSH), msf); 20186c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg} 2019832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg 2020c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justenstatic void 2021c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justenflush_pipeline_before_pipeline_select(struct anv_cmd_buffer *cmd_buffer, 2022c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen uint32_t pipeline) 2023c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen{ 2024c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen#if GEN_GEN >= 8 && GEN_GEN < 10 2025c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen /* From the Broadwell PRM, Volume 2a: Instructions, PIPELINE_SELECT: 2026c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * 2027c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * Software must clear the COLOR_CALC_STATE Valid field in 2028c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * 3DSTATE_CC_STATE_POINTERS command prior to send a PIPELINE_SELECT 2029c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * with Pipeline Select set to GPGPU. 2030c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * 2031c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * The internal hardware docs recommend the same workaround for Gen9 2032c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * hardware too. 2033c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen */ 2034c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen if (pipeline == GPGPU) 203550018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_CC_STATE_POINTERS), t); 20369caf60b3a2c25d46c78c9cdba36e663b687ffd50Jason Ekstrand#endif 20371761f9d4b2f5a3ed5092a9fef390d5ae5cc07411Jason Ekstrand 20381761f9d4b2f5a3ed5092a9fef390d5ae5cc07411Jason Ekstrand /* From "BXML » GT » MI » vol1a GPU Overview » [Instruction] 20391761f9d4b2f5a3ed5092a9fef390d5ae5cc07411Jason Ekstrand * PIPELINE_SELECT [DevBWR+]": 20401761f9d4b2f5a3ed5092a9fef390d5ae5cc07411Jason Ekstrand * 20411761f9d4b2f5a3ed5092a9fef390d5ae5cc07411Jason Ekstrand * Project: DEVSNB+ 20421761f9d4b2f5a3ed5092a9fef390d5ae5cc07411Jason Ekstrand * 20431761f9d4b2f5a3ed5092a9fef390d5ae5cc07411Jason Ekstrand * Software must ensure all the write caches are flushed through a 20441761f9d4b2f5a3ed5092a9fef390d5ae5cc07411Jason Ekstrand * stalling PIPE_CONTROL command followed by another PIPE_CONTROL 20451761f9d4b2f5a3ed5092a9fef390d5ae5cc07411Jason Ekstrand * command to invalidate read only caches prior to programming 20461761f9d4b2f5a3ed5092a9fef390d5ae5cc07411Jason Ekstrand * MI_PIPELINE_SELECT command to change the Pipeline Select Mode. 20471761f9d4b2f5a3ed5092a9fef390d5ae5cc07411Jason Ekstrand */ 20481761f9d4b2f5a3ed5092a9fef390d5ae5cc07411Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 20491761f9d4b2f5a3ed5092a9fef390d5ae5cc07411Jason Ekstrand pc.RenderTargetCacheFlushEnable = true; 20501761f9d4b2f5a3ed5092a9fef390d5ae5cc07411Jason Ekstrand pc.DepthCacheFlushEnable = true; 20511761f9d4b2f5a3ed5092a9fef390d5ae5cc07411Jason Ekstrand pc.DCFlushEnable = true; 20521761f9d4b2f5a3ed5092a9fef390d5ae5cc07411Jason Ekstrand pc.PostSyncOperation = NoWrite; 20531761f9d4b2f5a3ed5092a9fef390d5ae5cc07411Jason Ekstrand pc.CommandStreamerStallEnable = true; 20541761f9d4b2f5a3ed5092a9fef390d5ae5cc07411Jason Ekstrand } 2055b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen 20561761f9d4b2f5a3ed5092a9fef390d5ae5cc07411Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 20571761f9d4b2f5a3ed5092a9fef390d5ae5cc07411Jason Ekstrand pc.TextureCacheInvalidationEnable = true; 20581761f9d4b2f5a3ed5092a9fef390d5ae5cc07411Jason Ekstrand pc.ConstantCacheInvalidationEnable = true; 20591761f9d4b2f5a3ed5092a9fef390d5ae5cc07411Jason Ekstrand pc.StateCacheInvalidationEnable = true; 20601761f9d4b2f5a3ed5092a9fef390d5ae5cc07411Jason Ekstrand pc.InstructionCacheInvalidateEnable = true; 20611761f9d4b2f5a3ed5092a9fef390d5ae5cc07411Jason Ekstrand pc.PostSyncOperation = NoWrite; 20621761f9d4b2f5a3ed5092a9fef390d5ae5cc07411Jason Ekstrand } 2063c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen} 2064c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen 2065832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsbergvoid 2066832f73f512e9e6c21d495d7b07e229482371ef2fKristian HøgsberggenX(flush_pipeline_select_3d)(struct anv_cmd_buffer *cmd_buffer) 2067832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg{ 2068832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg if (cmd_buffer->state.current_pipeline != _3D) { 2069c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen flush_pipeline_before_pipeline_select(cmd_buffer, _3D); 2070c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen 207150018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPELINE_SELECT), ps) { 2072371b4a5b33a13f35fa7783510d2d90685a9a2e8aJason Ekstrand#if GEN_GEN >= 9 2073deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ps.MaskBits = 3; 2074832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg#endif 2075deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ps.PipelineSelection = _3D; 2076deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 2077deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand 2078832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg cmd_buffer->state.current_pipeline = _3D; 2079832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg } 2080832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg} 208185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 20821b126305ded36f6b416ada08e29ff84faeafef99Jordan Justenvoid 20831b126305ded36f6b416ada08e29ff84faeafef99Jordan JustengenX(flush_pipeline_select_gpgpu)(struct anv_cmd_buffer *cmd_buffer) 20841b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen{ 20851b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen if (cmd_buffer->state.current_pipeline != GPGPU) { 2086c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen flush_pipeline_before_pipeline_select(cmd_buffer, GPGPU); 20871b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen 208850018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPELINE_SELECT), ps) { 20891b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen#if GEN_GEN >= 9 2090deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ps.MaskBits = 3; 20911b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen#endif 2092deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ps.PipelineSelection = GPGPU; 2093deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 2094deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand 20951b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen cmd_buffer->state.current_pipeline = GPGPU; 20961b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen } 20971b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen} 20981b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen 2099a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrandvoid 2100a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason EkstrandgenX(cmd_buffer_emit_gen7_depth_flush)(struct anv_cmd_buffer *cmd_buffer) 2101a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand{ 2102a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand if (GEN_GEN >= 8) 2103a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand return; 2104a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand 2105a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand /* From the Haswell PRM, documentation for 3DSTATE_DEPTH_BUFFER: 2106a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * 2107a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * "Restriction: Prior to changing Depth/Stencil Buffer state (i.e., any 2108a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * combination of 3DSTATE_DEPTH_BUFFER, 3DSTATE_CLEAR_PARAMS, 2109a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * 3DSTATE_STENCIL_BUFFER, 3DSTATE_HIER_DEPTH_BUFFER) SW must first 2110a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * issue a pipelined depth stall (PIPE_CONTROL with Depth Stall bit 2111a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * set), followed by a pipelined depth cache flush (PIPE_CONTROL with 2112a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * Depth Flush Bit set, followed by another pipelined depth stall 2113a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * (PIPE_CONTROL with Depth Stall Bit set), unless SW can otherwise 2114a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * guarantee that the pipeline from WM onwards is already flushed (e.g., 2115a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * via a preceding MI_FLUSH)." 2116a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand */ 2117a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pipe) { 2118a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand pipe.DepthStallEnable = true; 2119a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand } 2120a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pipe) { 2121a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand pipe.DepthCacheFlushEnable = true; 2122a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand } 2123a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pipe) { 2124a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand pipe.DepthStallEnable = true; 2125a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand } 2126a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand} 2127a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand 2128d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrandstatic uint32_t 2129d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstranddepth_stencil_surface_type(enum isl_surf_dim dim) 2130d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand{ 2131d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand switch (dim) { 2132d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand case ISL_SURF_DIM_1D: 2133d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand if (GEN_GEN >= 9) { 2134d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand /* From the Sky Lake PRM, 3DSTATAE_DEPTH_BUFFER::SurfaceType 2135d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * 2136d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * Programming Notes: 2137d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * The Surface Type of the depth buffer must be the same as the 2138d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * Surface Type of the render target(s) (defined in 2139d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * SURFACE_STATE), unless either the depth buffer or render 2140d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * targets are SURFTYPE_NULL (see exception below for SKL). 1D 2141d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * surface type not allowed for depth surface and stencil surface. 2142d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * 2143d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * Workaround: 2144d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * If depth/stencil is enabled with 1D render target, 2145d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * depth/stencil surface type needs to be set to 2D surface type 2146d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * and height set to 1. Depth will use (legacy) TileY and stencil 2147d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * will use TileW. For this case only, the Surface Type of the 2148d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * depth buffer can be 2D while the Surface Type of the render 2149d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * target(s) are 1D, representing an exception to a programming 2150d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * note above. 2151d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand */ 2152d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand return SURFTYPE_2D; 2153d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } else { 2154d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand return SURFTYPE_1D; 2155d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } 2156d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand case ISL_SURF_DIM_2D: 2157d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand return SURFTYPE_2D; 2158d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand case ISL_SURF_DIM_3D: 2159d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand if (GEN_GEN >= 9) { 2160d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand /* The Sky Lake docs list the value for 3D as "Reserved". However, 2161d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * they have the exact same layout as 2D arrays on gen9+, so we can 2162d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * just use 2D here. 2163d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand */ 2164d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand return SURFTYPE_2D; 2165d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } else { 2166d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand return SURFTYPE_3D; 2167d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } 2168d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand default: 2169d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand unreachable("Invalid surface dimension"); 2170d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } 2171d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand} 2172d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand 217385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsbergstatic void 217485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsbergcmd_buffer_emit_depth_stencil(struct anv_cmd_buffer *cmd_buffer) 217585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg{ 217685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg struct anv_device *device = cmd_buffer->device; 217785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg const struct anv_framebuffer *fb = cmd_buffer->state.framebuffer; 217885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg const struct anv_image_view *iview = 217985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg anv_cmd_buffer_get_depth_stencil_view(cmd_buffer); 218085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg const struct anv_image *image = iview ? iview->image : NULL; 2181234ecf26c65a8909e91313a8b35e2a8a8bbfc0efJason Ekstrand const bool has_depth = image && (image->aspects & VK_IMAGE_ASPECT_DEPTH_BIT); 2182168985fca1b59d345471277d5c8ce4a82cdc74f4Nanley Chery const uint32_t ds = cmd_buffer->state.subpass->depth_stencil_attachment; 2183168985fca1b59d345471277d5c8ce4a82cdc74f4Nanley Chery const bool has_hiz = image != NULL && 2184168985fca1b59d345471277d5c8ce4a82cdc74f4Nanley Chery cmd_buffer->state.attachments[ds].aux_usage == ISL_AUX_USAGE_HIZ; 2185234ecf26c65a8909e91313a8b35e2a8a8bbfc0efJason Ekstrand const bool has_stencil = 2186234ecf26c65a8909e91313a8b35e2a8a8bbfc0efJason Ekstrand image && (image->aspects & VK_IMAGE_ASPECT_STENCIL_BIT); 218785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 218885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg /* FIXME: Implement the PMA stall W/A */ 218985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg /* FIXME: Width and Height are wrong */ 219085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2191a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand genX(cmd_buffer_emit_gen7_depth_flush)(cmd_buffer); 2192a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand 219385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg /* Emit 3DSTATE_DEPTH_BUFFER */ 219485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg if (has_depth) { 219550018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_DEPTH_BUFFER), db) { 2196d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand db.SurfaceType = 2197d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand depth_stencil_surface_type(image->depth_surface.isl.dim); 2198a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.DepthWriteEnable = true; 2199a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.StencilWriteEnable = has_stencil; 220064fb5b0d51751f452b7bf4c5fff06b5549eed4a8Nanley Chery db.HierarchicalDepthBufferEnable = has_hiz; 2201a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand 2202a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.SurfaceFormat = isl_surf_get_depth_format(&device->isl_dev, 2203a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand &image->depth_surface.isl); 2204a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand 2205a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.SurfaceBaseAddress = (struct anv_address) { 220685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg .bo = image->bo, 220722d8666d74f6fa6de53366f76a56277976eced21Kristian Høgsberg .offset = image->offset + image->depth_surface.offset, 2208a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand }; 2209696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin db.DepthBufferObjectControlState = GENX(MOCS); 2210a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand 2211a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.SurfacePitch = image->depth_surface.isl.row_pitch - 1; 221220e95a746df34923eb4aac5e7f1ab6d722432d89Jason Ekstrand db.Height = image->extent.height - 1; 221320e95a746df34923eb4aac5e7f1ab6d722432d89Jason Ekstrand db.Width = image->extent.width - 1; 221429e289fa655938f7814bdbb3de7996a8a0f04b60Jason Ekstrand db.LOD = iview->isl.base_level; 221529e289fa655938f7814bdbb3de7996a8a0f04b60Jason Ekstrand db.MinimumArrayElement = iview->isl.base_array_layer; 2216a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand 221761992e0afe5f717aad7321d9748588b2cd27f8eeNanley Chery assert(image->depth_surface.isl.dim != ISL_SURF_DIM_3D); 221861992e0afe5f717aad7321d9748588b2cd27f8eeNanley Chery db.Depth = 221961992e0afe5f717aad7321d9748588b2cd27f8eeNanley Chery db.RenderTargetViewExtent = 222061992e0afe5f717aad7321d9748588b2cd27f8eeNanley Chery iview->isl.array_len - iview->isl.base_array_layer - 1; 222161992e0afe5f717aad7321d9748588b2cd27f8eeNanley Chery 2222371b4a5b33a13f35fa7783510d2d90685a9a2e8aJason Ekstrand#if GEN_GEN >= 8 2223a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.SurfaceQPitch = 2224696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin isl_surf_get_array_pitch_el_rows(&image->depth_surface.isl) >> 2; 222585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg#endif 2226a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand } 222785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg } else { 222885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg /* Even when no depth buffer is present, the hardware requires that 222985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH_BUFFER be programmed correctly. The Broadwell PRM says: 223085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 223185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * If a null depth buffer is bound, the driver must instead bind depth as: 223285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH.SurfaceType = SURFTYPE_2D 223385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH.Width = 1 223485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH.Height = 1 223585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH.SuraceFormat = D16_UNORM 223685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH.SurfaceBaseAddress = 0 223785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH.HierarchicalDepthBufferEnable = 0 223885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_WM_DEPTH_STENCIL.DepthTestEnable = 0 223985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_WM_DEPTH_STENCIL.DepthBufferWriteEnable = 0 224085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 224185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * The PRM is wrong, though. The width and height must be programmed to 224285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * actual framebuffer's width and height, even when neither depth buffer 22437c1660aa14094e40fba9f39ce194cb6238311b65Jason Ekstrand * nor stencil buffer is present. Also, D16_UNORM is not allowed to 22447c1660aa14094e40fba9f39ce194cb6238311b65Jason Ekstrand * be combined with a stencil buffer so we use D32_FLOAT instead. 224585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg */ 224650018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_DEPTH_BUFFER), db) { 2247d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand if (has_stencil) { 224827433b26b197b8b69d4ca8c9aed567f04950648eJason Ekstrand db.SurfaceType = 2249d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand depth_stencil_surface_type(image->stencil_surface.isl.dim); 2250d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } else { 2251d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand db.SurfaceType = SURFTYPE_2D; 2252d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } 2253a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.SurfaceFormat = D32_FLOAT; 2254dcca706b4e2d2086b90d77cced0cff6ce4eac953Kenneth Graunke db.Width = MAX2(fb->width, 1) - 1; 2255dcca706b4e2d2086b90d77cced0cff6ce4eac953Kenneth Graunke db.Height = MAX2(fb->height, 1) - 1; 2256a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.StencilWriteEnable = has_stencil; 2257a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand } 225885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg } 225985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 226078d074b87a75d599e65ef34f5b866da577b80de3Chad Versace if (has_hiz) { 226178d074b87a75d599e65ef34f5b866da577b80de3Chad Versace anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_HIER_DEPTH_BUFFER), hdb) { 226278d074b87a75d599e65ef34f5b866da577b80de3Chad Versace hdb.HierarchicalDepthBufferObjectControlState = GENX(MOCS); 2263c3eb58664e5e537b21a75172916b42bd4b5504b3Jason Ekstrand hdb.SurfacePitch = image->aux_surface.isl.row_pitch - 1; 226478d074b87a75d599e65ef34f5b866da577b80de3Chad Versace hdb.SurfaceBaseAddress = (struct anv_address) { 226578d074b87a75d599e65ef34f5b866da577b80de3Chad Versace .bo = image->bo, 2266c3eb58664e5e537b21a75172916b42bd4b5504b3Jason Ekstrand .offset = image->offset + image->aux_surface.offset, 226778d074b87a75d599e65ef34f5b866da577b80de3Chad Versace }; 226878d074b87a75d599e65ef34f5b866da577b80de3Chad Versace#if GEN_GEN >= 8 226978d074b87a75d599e65ef34f5b866da577b80de3Chad Versace /* From the SKL PRM Vol2a: 227078d074b87a75d599e65ef34f5b866da577b80de3Chad Versace * 227178d074b87a75d599e65ef34f5b866da577b80de3Chad Versace * The interpretation of this field is dependent on Surface Type 227278d074b87a75d599e65ef34f5b866da577b80de3Chad Versace * as follows: 227378d074b87a75d599e65ef34f5b866da577b80de3Chad Versace * - SURFTYPE_1D: distance in pixels between array slices 227478d074b87a75d599e65ef34f5b866da577b80de3Chad Versace * - SURFTYPE_2D/CUBE: distance in rows between array slices 227578d074b87a75d599e65ef34f5b866da577b80de3Chad Versace * - SURFTYPE_3D: distance in rows between R - slices 2276f469235a6e0c239166ba803e121994063b47ddd3Jason Ekstrand * 2277f469235a6e0c239166ba803e121994063b47ddd3Jason Ekstrand * Unfortunately, the docs aren't 100% accurate here. They fail to 2278f469235a6e0c239166ba803e121994063b47ddd3Jason Ekstrand * mention that the 1-D rule only applies to linear 1-D images. 2279f469235a6e0c239166ba803e121994063b47ddd3Jason Ekstrand * Since depth and HiZ buffers are always tiled, they are treated as 2280f469235a6e0c239166ba803e121994063b47ddd3Jason Ekstrand * 2-D images. Prior to Sky Lake, this field is always in rows. 228178d074b87a75d599e65ef34f5b866da577b80de3Chad Versace */ 228278d074b87a75d599e65ef34f5b866da577b80de3Chad Versace hdb.SurfaceQPitch = 22839f1d3a0c971e95c9e04cf6bfcd60f8b0d8c6742bNanley Chery isl_surf_get_array_pitch_sa_rows(&image->aux_surface.isl) >> 2; 228478d074b87a75d599e65ef34f5b866da577b80de3Chad Versace#endif 228578d074b87a75d599e65ef34f5b866da577b80de3Chad Versace } 228678d074b87a75d599e65ef34f5b866da577b80de3Chad Versace } else { 228778d074b87a75d599e65ef34f5b866da577b80de3Chad Versace anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_HIER_DEPTH_BUFFER), hdb); 228878d074b87a75d599e65ef34f5b866da577b80de3Chad Versace } 228978d074b87a75d599e65ef34f5b866da577b80de3Chad Versace 229085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg /* Emit 3DSTATE_STENCIL_BUFFER */ 229185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg if (has_stencil) { 229250018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_STENCIL_BUFFER), sb) { 2293371b4a5b33a13f35fa7783510d2d90685a9a2e8aJason Ekstrand#if GEN_GEN >= 8 || GEN_IS_HASWELL 2294696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin sb.StencilBufferEnable = true; 229585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg#endif 2296696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin sb.StencilBufferObjectControlState = GENX(MOCS); 229785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2298696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin sb.SurfacePitch = image->stencil_surface.isl.row_pitch - 1; 229985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2300371b4a5b33a13f35fa7783510d2d90685a9a2e8aJason Ekstrand#if GEN_GEN >= 8 2301696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin sb.SurfaceQPitch = isl_surf_get_array_pitch_el_rows(&image->stencil_surface.isl) >> 2; 230285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg#endif 2303a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand sb.SurfaceBaseAddress = (struct anv_address) { 230485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg .bo = image->bo, 230585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg .offset = image->offset + image->stencil_surface.offset, 2306a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand }; 2307a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand } 230885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg } else { 230950018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_STENCIL_BUFFER), sb); 231085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg } 231185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2312d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery /* From the IVB PRM Vol2P1, 11.5.5.4 3DSTATE_CLEAR_PARAMS: 2313d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * 2314d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * 3DSTATE_CLEAR_PARAMS must always be programmed in the along with 2315d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * the other Depth/Stencil state commands(i.e. 3DSTATE_DEPTH_BUFFER, 2316d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * 3DSTATE_STENCIL_BUFFER, or 3DSTATE_HIER_DEPTH_BUFFER) 2317d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * 2318d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * Testing also shows that some variant of this restriction may exist HSW+. 2319d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * On BDW+, it is not possible to emit 2 of these packets consecutively when 2320d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * both have DepthClearValueValid set. An analysis of such state programming 2321d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * on SKL showed that the GPU doesn't register the latter packet's clear 2322d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * value. 2323d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery */ 2324d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_CLEAR_PARAMS), cp) { 2325d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery if (has_hiz) { 2326d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery cp.DepthClearValueValid = true; 2327b62d8ad2aee2f67fb290332b285a0a5aa93e7724Nanley Chery cp.DepthClearValue = ANV_HZ_FC_VAL; 2328d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery } 2329d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery } 233085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg} 233185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2332b548fdbed5c16f5c0dfc26f65b0037a85c567735Jason Ekstrandstatic void 233385f67cf16e9823c858215e8a7359d18762c2653cKristian HøgsberggenX(cmd_buffer_set_subpass)(struct anv_cmd_buffer *cmd_buffer, 233485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg struct anv_subpass *subpass) 233585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg{ 233685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg cmd_buffer->state.subpass = subpass; 233785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2338fe4e276b02615b5db8acbf4c65fcfa68982e2e0fJason Ekstrand cmd_buffer->state.dirty |= ANV_CMD_DIRTY_RENDER_TARGETS; 233985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2340462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery const struct anv_image_view *iview = 2341462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery anv_cmd_buffer_get_depth_stencil_view(cmd_buffer); 2342462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery 234358af6156360a309578241acba949e540acf72cb1Nanley Chery if (iview && iview->image->aux_usage == ISL_AUX_USAGE_HIZ) { 234458af6156360a309578241acba949e540acf72cb1Nanley Chery const uint32_t ds = subpass->depth_stencil_attachment; 234558af6156360a309578241acba949e540acf72cb1Nanley Chery transition_depth_buffer(cmd_buffer, iview->image, 234658af6156360a309578241acba949e540acf72cb1Nanley Chery cmd_buffer->state.attachments[ds].current_layout, 234758af6156360a309578241acba949e540acf72cb1Nanley Chery cmd_buffer->state.subpass->depth_stencil_layout); 234858af6156360a309578241acba949e540acf72cb1Nanley Chery cmd_buffer->state.attachments[ds].current_layout = 234958af6156360a309578241acba949e540acf72cb1Nanley Chery cmd_buffer->state.subpass->depth_stencil_layout; 235058af6156360a309578241acba949e540acf72cb1Nanley Chery cmd_buffer->state.attachments[ds].aux_usage = 235164272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery layout_to_hiz_usage(cmd_buffer->state.subpass->depth_stencil_layout, 235264272d4f1bc8fe1b476ed26904d673f35b0f2c86Nanley Chery iview->image->samples); 2353462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery } 2354462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery 235585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg cmd_buffer_emit_depth_stencil(cmd_buffer); 2356c81ec84c1ec24f11f86b2fb725956437c721fe18Jason Ekstrand 2357c81ec84c1ec24f11f86b2fb725956437c721fe18Jason Ekstrand anv_cmd_buffer_clear_subpass(cmd_buffer); 235885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg} 235985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 236085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsbergvoid genX(CmdBeginRenderPass)( 236185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg VkCommandBuffer commandBuffer, 236285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg const VkRenderPassBeginInfo* pRenderPassBegin, 236385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg VkSubpassContents contents) 236485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg{ 236585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 236685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg ANV_FROM_HANDLE(anv_render_pass, pass, pRenderPassBegin->renderPass); 236785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg ANV_FROM_HANDLE(anv_framebuffer, framebuffer, pRenderPassBegin->framebuffer); 236885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 236985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg cmd_buffer->state.framebuffer = framebuffer; 237085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg cmd_buffer->state.pass = pass; 2371b26bd6790dd1b09e377bd926e9145ec20ce6ac3fJason Ekstrand cmd_buffer->state.render_area = pRenderPassBegin->renderArea; 2372d1d6b788989e73edd2426999d891230500dc1a73Jason Ekstrand genX(cmd_buffer_setup_attachments)(cmd_buffer, pass, pRenderPassBegin); 237385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 237485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg genX(flush_pipeline_select_3d)(cmd_buffer); 237585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 237685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg genX(cmd_buffer_set_subpass)(cmd_buffer, pass->subpasses); 237785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg} 237885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 237985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsbergvoid genX(CmdNextSubpass)( 238085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg VkCommandBuffer commandBuffer, 238185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg VkSubpassContents contents) 238285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg{ 238385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 238485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 238585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg assert(cmd_buffer->level == VK_COMMAND_BUFFER_LEVEL_PRIMARY); 238685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2387462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery const struct anv_image_view *iview = 2388462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery anv_cmd_buffer_get_depth_stencil_view(cmd_buffer); 2389462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery 239058af6156360a309578241acba949e540acf72cb1Nanley Chery if (iview && iview->image->aux_usage == ISL_AUX_USAGE_HIZ) { 239158af6156360a309578241acba949e540acf72cb1Nanley Chery const uint32_t ds = cmd_buffer->state.subpass->depth_stencil_attachment; 239258af6156360a309578241acba949e540acf72cb1Nanley Chery 239358af6156360a309578241acba949e540acf72cb1Nanley Chery if (cmd_buffer->state.subpass - cmd_buffer->state.pass->subpasses == 239458af6156360a309578241acba949e540acf72cb1Nanley Chery cmd_buffer->state.pass->attachments[ds].last_subpass_idx) { 239558af6156360a309578241acba949e540acf72cb1Nanley Chery transition_depth_buffer(cmd_buffer, iview->image, 239658af6156360a309578241acba949e540acf72cb1Nanley Chery cmd_buffer->state.attachments[ds].current_layout, 239758af6156360a309578241acba949e540acf72cb1Nanley Chery cmd_buffer->state.pass->attachments[ds].final_layout); 239858af6156360a309578241acba949e540acf72cb1Nanley Chery } 2399462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery } 2400462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery 240185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg anv_cmd_buffer_resolve_subpass(cmd_buffer); 240285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg genX(cmd_buffer_set_subpass)(cmd_buffer, cmd_buffer->state.subpass + 1); 240385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg} 240485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 240585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsbergvoid genX(CmdEndRenderPass)( 240685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg VkCommandBuffer commandBuffer) 240785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg{ 240885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 240985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2410462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery const struct anv_image_view *iview = 2411462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery anv_cmd_buffer_get_depth_stencil_view(cmd_buffer); 2412462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery 241358af6156360a309578241acba949e540acf72cb1Nanley Chery if (iview && iview->image->aux_usage == ISL_AUX_USAGE_HIZ) { 241458af6156360a309578241acba949e540acf72cb1Nanley Chery const uint32_t ds = cmd_buffer->state.subpass->depth_stencil_attachment; 241558af6156360a309578241acba949e540acf72cb1Nanley Chery 241658af6156360a309578241acba949e540acf72cb1Nanley Chery if (cmd_buffer->state.subpass - cmd_buffer->state.pass->subpasses == 241758af6156360a309578241acba949e540acf72cb1Nanley Chery cmd_buffer->state.pass->attachments[ds].last_subpass_idx) { 241858af6156360a309578241acba949e540acf72cb1Nanley Chery transition_depth_buffer(cmd_buffer, iview->image, 241958af6156360a309578241acba949e540acf72cb1Nanley Chery cmd_buffer->state.attachments[ds].current_layout, 242058af6156360a309578241acba949e540acf72cb1Nanley Chery cmd_buffer->state.pass->attachments[ds].final_layout); 242158af6156360a309578241acba949e540acf72cb1Nanley Chery } 2422462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery } 2423462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery 242485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg anv_cmd_buffer_resolve_subpass(cmd_buffer); 2425ac7eeebce4ae9107863623321b74b1c08389f180Jason Ekstrand 2426ac7eeebce4ae9107863623321b74b1c08389f180Jason Ekstrand#ifndef NDEBUG 2427ac7eeebce4ae9107863623321b74b1c08389f180Jason Ekstrand anv_dump_add_framebuffer(cmd_buffer, cmd_buffer->state.framebuffer); 2428ac7eeebce4ae9107863623321b74b1c08389f180Jason Ekstrand#endif 242985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg} 243081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 243181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenstatic void 24321e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrandemit_ps_depth_count(struct anv_cmd_buffer *cmd_buffer, 243381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen struct anv_bo *bo, uint32_t offset) 243481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 24351e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 243656453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DestinationAddressType = DAT_PPGTT; 243756453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.PostSyncOperation = WritePSDepthCount; 243856453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DepthStallEnable = true; 243956453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.Address = (struct anv_address) { bo, offset }; 2440a6c3d0f92b754e11e74cea9d6bd5ac329c73a8baJason Ekstrand 2441a6c3d0f92b754e11e74cea9d6bd5ac329c73a8baJason Ekstrand if (GEN_GEN == 9 && cmd_buffer->device->info.gt == 4) 2442a6c3d0f92b754e11e74cea9d6bd5ac329c73a8baJason Ekstrand pc.CommandStreamerStallEnable = true; 244356453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 244481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 244581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 244681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenstatic void 24471e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrandemit_query_availability(struct anv_cmd_buffer *cmd_buffer, 244881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen struct anv_bo *bo, uint32_t offset) 244981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 24501e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 245156453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DestinationAddressType = DAT_PPGTT; 245256453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.PostSyncOperation = WriteImmediateData; 245356453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.Address = (struct anv_address) { bo, offset }; 245456453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.ImmediateData = 1; 245556453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 245681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 245781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 2458c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrandvoid genX(CmdResetQueryPool)( 2459c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand VkCommandBuffer commandBuffer, 2460c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand VkQueryPool queryPool, 2461c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand uint32_t firstQuery, 2462c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand uint32_t queryCount) 2463c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand{ 2464c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 2465c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand ANV_FROM_HANDLE(anv_query_pool, pool, queryPool); 2466c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand 2467c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand for (uint32_t i = 0; i < queryCount; i++) { 2468c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand switch (pool->type) { 2469c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand case VK_QUERY_TYPE_OCCLUSION: 2470c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand case VK_QUERY_TYPE_TIMESTAMP: { 2471c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(MI_STORE_DATA_IMM), sdm) { 2472c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand sdm.Address = (struct anv_address) { 2473c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand .bo = &pool->bo, 2474c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand .offset = (firstQuery + i) * sizeof(struct anv_query_pool_slot) + 2475c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand offsetof(struct anv_query_pool_slot, available), 2476c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand }; 2477c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand sdm.DataDWord0 = 0; 2478c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand sdm.DataDWord1 = 0; 2479c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand } 2480c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand break; 2481c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand } 2482c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand default: 2483c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand assert(!"Invalid query type"); 2484c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand } 2485c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand } 2486c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand} 2487c23c6db9aa232de6934ec654d815e808a9895fe2Jason Ekstrand 248881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenvoid genX(CmdBeginQuery)( 248981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkCommandBuffer commandBuffer, 249081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkQueryPool queryPool, 249181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t query, 249281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkQueryControlFlags flags) 249381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 249481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 249581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_query_pool, pool, queryPool); 249681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 249781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen /* Workaround: When meta uses the pipeline with the VS disabled, it seems 249881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen * that the pipelining of the depth write breaks. What we see is that 249981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen * samples from the render pass clear leaks into the first query 250081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen * immediately after the clear. Doing a pipecontrol with a post-sync 250181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen * operation and DepthStallEnable seems to work around the issue. 250281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen */ 250381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen if (cmd_buffer->state.need_query_wa) { 250481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen cmd_buffer->state.need_query_wa = false; 250550018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 250656453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DepthCacheFlushEnable = true; 250756453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DepthStallEnable = true; 250856453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 250981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 251081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 251181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen switch (pool->type) { 251281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_QUERY_TYPE_OCCLUSION: 25131e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrand emit_ps_depth_count(cmd_buffer, &pool->bo, 251481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen query * sizeof(struct anv_query_pool_slot)); 251581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen break; 251681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 251781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_QUERY_TYPE_PIPELINE_STATISTICS: 251881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen default: 251981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen unreachable(""); 252081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 252181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 252281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 252381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenvoid genX(CmdEndQuery)( 252481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkCommandBuffer commandBuffer, 252581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkQueryPool queryPool, 252681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t query) 252781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 252881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 252981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_query_pool, pool, queryPool); 253081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 253181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen switch (pool->type) { 253281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_QUERY_TYPE_OCCLUSION: 25331e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrand emit_ps_depth_count(cmd_buffer, &pool->bo, 253481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen query * sizeof(struct anv_query_pool_slot) + 8); 253581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 25361e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrand emit_query_availability(cmd_buffer, &pool->bo, 253781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen query * sizeof(struct anv_query_pool_slot) + 16); 253881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen break; 253981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 254081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_QUERY_TYPE_PIPELINE_STATISTICS: 254181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen default: 254281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen unreachable(""); 254381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 254481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 254581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 254681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define TIMESTAMP 0x2358 254781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 254881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenvoid genX(CmdWriteTimestamp)( 254981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkCommandBuffer commandBuffer, 255081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkPipelineStageFlagBits pipelineStage, 255181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkQueryPool queryPool, 255281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t query) 255381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 255481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 255581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_query_pool, pool, queryPool); 255681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t offset = query * sizeof(struct anv_query_pool_slot); 255781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 255881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen assert(pool->type == VK_QUERY_TYPE_TIMESTAMP); 255981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 256081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen switch (pipelineStage) { 256181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT: 256250018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(MI_STORE_REGISTER_MEM), srm) { 25638a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.RegisterAddress = TIMESTAMP; 25648a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.MemoryAddress = (struct anv_address) { &pool->bo, offset }; 25658a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 256650018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(MI_STORE_REGISTER_MEM), srm) { 25678a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.RegisterAddress = TIMESTAMP + 4; 25688a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.MemoryAddress = (struct anv_address) { &pool->bo, offset + 4 }; 25698a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 257081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen break; 257181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 257281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen default: 257381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen /* Everything else is bottom-of-pipe */ 257450018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 2575696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin pc.DestinationAddressType = DAT_PPGTT; 2576696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin pc.PostSyncOperation = WriteTimestamp; 25778a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand pc.Address = (struct anv_address) { &pool->bo, offset }; 2578a6c3d0f92b754e11e74cea9d6bd5ac329c73a8baJason Ekstrand 2579a6c3d0f92b754e11e74cea9d6bd5ac329c73a8baJason Ekstrand if (GEN_GEN == 9 && cmd_buffer->device->info.gt == 4) 2580a6c3d0f92b754e11e74cea9d6bd5ac329c73a8baJason Ekstrand pc.CommandStreamerStallEnable = true; 25818a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 258281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen break; 258381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 258481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 2585fb00f22b835f76b88c996e479fc583e86e4d6006Jason Ekstrand emit_query_availability(cmd_buffer, &pool->bo, offset + 16); 258681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 258781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 258881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#if GEN_GEN > 7 || GEN_IS_HASWELL 258981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 259081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define alu_opcode(v) __gen_uint((v), 20, 31) 259181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define alu_operand1(v) __gen_uint((v), 10, 19) 259281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define alu_operand2(v) __gen_uint((v), 0, 9) 259381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define alu(opcode, operand1, operand2) \ 259481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen alu_opcode(opcode) | alu_operand1(operand1) | alu_operand2(operand2) 259581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 259681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_NOOP 0x000 259781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_LOAD 0x080 259881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_LOADINV 0x480 259981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_LOAD0 0x081 260081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_LOAD1 0x481 260181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_ADD 0x100 260281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_SUB 0x101 260381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_AND 0x102 260481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_OR 0x103 260581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_XOR 0x104 260681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_STORE 0x180 260781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_STOREINV 0x580 260881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 260981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_R0 0x00 261081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_R1 0x01 261181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_R2 0x02 261281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_R3 0x03 261381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_R4 0x04 261481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_SRCA 0x20 261581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_SRCB 0x21 261681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_ACCU 0x31 261781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_ZF 0x32 261881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_CF 0x33 261981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 262081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define CS_GPR(n) (0x2600 + (n) * 8) 262181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 262281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenstatic void 262381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenemit_load_alu_reg_u64(struct anv_batch *batch, uint32_t reg, 262481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen struct anv_bo *bo, uint32_t offset) 262581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 262650018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_LOAD_REGISTER_MEM), lrm) { 26278a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand lrm.RegisterAddress = reg, 26288a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand lrm.MemoryAddress = (struct anv_address) { bo, offset }; 26298a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 263050018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_LOAD_REGISTER_MEM), lrm) { 26318a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand lrm.RegisterAddress = reg + 4; 26328a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand lrm.MemoryAddress = (struct anv_address) { bo, offset + 4 }; 26338a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 263481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 263581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 263681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenstatic void 263781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenstore_query_result(struct anv_batch *batch, uint32_t reg, 263881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen struct anv_bo *bo, uint32_t offset, VkQueryResultFlags flags) 263981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 264050018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_STORE_REGISTER_MEM), srm) { 26418a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.RegisterAddress = reg; 26428a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.MemoryAddress = (struct anv_address) { bo, offset }; 26438a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 26448a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand 26458a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand if (flags & VK_QUERY_RESULT_64_BIT) { 264650018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_STORE_REGISTER_MEM), srm) { 26478a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.RegisterAddress = reg + 4; 26488a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.MemoryAddress = (struct anv_address) { bo, offset + 4 }; 26498a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 26508a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 265181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 265281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 265381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenvoid genX(CmdCopyQueryPoolResults)( 265481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkCommandBuffer commandBuffer, 265581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkQueryPool queryPool, 265681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t firstQuery, 265781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t queryCount, 265881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkBuffer destBuffer, 265981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkDeviceSize destOffset, 266081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkDeviceSize destStride, 266181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkQueryResultFlags flags) 266281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 266381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 266481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_query_pool, pool, queryPool); 266581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_buffer, buffer, destBuffer); 266681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t slot_offset, dst_offset; 266781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 266856453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand if (flags & VK_QUERY_RESULT_WAIT_BIT) { 266950018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 267056453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.CommandStreamerStallEnable = true; 267156453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.StallAtPixelScoreboard = true; 267256453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 267356453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 267481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 267581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen dst_offset = buffer->offset + destOffset; 267681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen for (uint32_t i = 0; i < queryCount; i++) { 267781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 267881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen slot_offset = (firstQuery + i) * sizeof(struct anv_query_pool_slot); 267981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen switch (pool->type) { 268081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_QUERY_TYPE_OCCLUSION: 268181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen emit_load_alu_reg_u64(&cmd_buffer->batch, 268281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen CS_GPR(0), &pool->bo, slot_offset); 268381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen emit_load_alu_reg_u64(&cmd_buffer->batch, 268481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen CS_GPR(1), &pool->bo, slot_offset + 8); 268581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 268681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen /* FIXME: We need to clamp the result for 32 bit. */ 268781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 268881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t *dw = anv_batch_emitn(&cmd_buffer->batch, 5, GENX(MI_MATH)); 268981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen dw[1] = alu(OPCODE_LOAD, OPERAND_SRCA, OPERAND_R1); 269081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen dw[2] = alu(OPCODE_LOAD, OPERAND_SRCB, OPERAND_R0); 269181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen dw[3] = alu(OPCODE_SUB, 0, 0); 269281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen dw[4] = alu(OPCODE_STORE, OPERAND_R2, OPERAND_ACCU); 269381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen break; 269481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 269581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_QUERY_TYPE_TIMESTAMP: 269681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen emit_load_alu_reg_u64(&cmd_buffer->batch, 269781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen CS_GPR(2), &pool->bo, slot_offset); 269881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen break; 269981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 270081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen default: 270181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen unreachable("unhandled query type"); 270281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 270381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 270481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen store_query_result(&cmd_buffer->batch, 270581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen CS_GPR(2), buffer->bo, dst_offset, flags); 270681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 270781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen if (flags & VK_QUERY_RESULT_WITH_AVAILABILITY_BIT) { 270881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen emit_load_alu_reg_u64(&cmd_buffer->batch, CS_GPR(0), 270981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen &pool->bo, slot_offset + 16); 271081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen if (flags & VK_QUERY_RESULT_64_BIT) 271181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen store_query_result(&cmd_buffer->batch, 271281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen CS_GPR(0), buffer->bo, dst_offset + 8, flags); 271381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen else 271481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen store_query_result(&cmd_buffer->batch, 271581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen CS_GPR(0), buffer->bo, dst_offset + 4, flags); 271681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 271781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 271881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen dst_offset += destStride; 271981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 272081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 272181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 2722b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand#else 2723b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrandvoid genX(CmdCopyQueryPoolResults)( 2724b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand VkCommandBuffer commandBuffer, 2725b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand VkQueryPool queryPool, 2726b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand uint32_t firstQuery, 2727b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand uint32_t queryCount, 2728b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand VkBuffer destBuffer, 2729b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand VkDeviceSize destOffset, 2730b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand VkDeviceSize destStride, 2731b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand VkQueryResultFlags flags) 2732b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand{ 2733b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand anv_finishme("Queries not yet supported on Ivy Bridge"); 2734b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand} 273581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#endif 2736