genX_cmd_buffer.c revision 2e2cf78a5104b3e08fea039d1b2d20a137d6a371
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/* XXX: Do we need this on more than just BDW? */ 59371b4a5b33a13f35fa7783510d2d90685a9a2e8aJason Ekstrand#if (GEN_GEN >= 8) 606f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand /* Emit a render target cache flush. 616f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * 626f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * This isn't documented anywhere in the PRM. However, it seems to be 636f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * necessary prior to changing the surface state base adress. Without 646f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * this, we get GPU hangs when using multi-level command buffers which 656f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * clear depth, reset state base address, and then go render stuff. 666f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand */ 6750018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 6856453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.RenderTargetCacheFlushEnable = true; 6956453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 706f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand#endif 716f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 7250018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(STATE_BASE_ADDRESS), sba) { 73c2f2c8e407207c31c29aab5570d23cd6e98d287aJason Ekstrand sba.GeneralStateBaseAddress = (struct anv_address) { NULL, 0 }; 7456453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.GeneralStateMemoryObjectControlState = GENX(MOCS); 7556453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.GeneralStateBaseAddressModifyEnable = true; 766f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 7756453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.SurfaceStateBaseAddress = 7856453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand anv_cmd_buffer_surface_base_address(cmd_buffer); 7956453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.SurfaceStateMemoryObjectControlState = GENX(MOCS); 8056453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.SurfaceStateBaseAddressModifyEnable = true; 816f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 8256453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.DynamicStateBaseAddress = 8356453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand (struct anv_address) { &device->dynamic_state_block_pool.bo, 0 }; 84696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin sba.DynamicStateMemoryObjectControlState = GENX(MOCS); 85696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin sba.DynamicStateBaseAddressModifyEnable = true; 866f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 8756453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.IndirectObjectBaseAddress = (struct anv_address) { NULL, 0 }; 8856453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.IndirectObjectMemoryObjectControlState = GENX(MOCS); 8956453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.IndirectObjectBaseAddressModifyEnable = true; 906f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 9156453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.InstructionBaseAddress = 9256453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand (struct anv_address) { &device->instruction_block_pool.bo, 0 }; 9356453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.InstructionMemoryObjectControlState = GENX(MOCS); 9456453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.InstructionBaseAddressModifyEnable = true; 956f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 96371b4a5b33a13f35fa7783510d2d90685a9a2e8aJason Ekstrand# if (GEN_GEN >= 8) 976f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand /* Broadwell requires that we specify a buffer size for a bunch of 986f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * these fields. However, since we will be growing the BO's live, we 996f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * just set them all to the maximum. 1006f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand */ 10156453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.GeneralStateBufferSize = 0xfffff; 10256453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.GeneralStateBufferSizeModifyEnable = true; 10356453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.DynamicStateBufferSize = 0xfffff; 10456453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.DynamicStateBufferSizeModifyEnable = true; 10556453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.IndirectObjectBufferSize = 0xfffff; 10656453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.IndirectObjectBufferSizeModifyEnable = true; 10756453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.InstructionBufferSize = 0xfffff; 10856453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand sba.InstructionBuffersizeModifyEnable = true; 1096f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand# endif 11056453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 1116f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 1126f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand /* After re-setting the surface state base address, we have to do some 1136f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * cache flusing so that the sampler engine will pick up the new 1146f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * SURFACE_STATE objects and binding tables. From the Broadwell PRM, 1156f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * Shared Function > 3D Sampler > State > State Caching (page 96): 1166f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * 1176f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * Coherency with system memory in the state cache, like the texture 1186f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * cache is handled partially by software. It is expected that the 1196f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * command stream or shader will issue Cache Flush operation or 1206f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * Cache_Flush sampler message to ensure that the L1 cache remains 1216f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * coherent with system memory. 1226f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * 1236f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * [...] 1246f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * 1256f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * Whenever the value of the Dynamic_State_Base_Addr, 1266f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * Surface_State_Base_Addr are altered, the L1 state cache must be 1276f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * invalidated to ensure the new surface or sampler state is fetched 1286f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * from system memory. 1296f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * 1306f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * The PIPE_CONTROL command has a "State Cache Invalidation Enable" bit 1316f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * which, according the PIPE_CONTROL instruction documentation in the 1326f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * Broadwell PRM: 1336f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * 1346f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * Setting this bit is independent of any other bit in this packet. 1356f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * This bit controls the invalidation of the L1 and L2 state caches 1366f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * at the top of the pipe i.e. at the parsing time. 1376f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * 1386f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * Unfortunately, experimentation seems to indicate that state cache 1396f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * invalidation through a PIPE_CONTROL does nothing whatsoever in 1406f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * regards to surface state and binding tables. In stead, it seems that 1416f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * invalidating the texture cache is what is actually needed. 1426f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * 1436f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * XXX: As far as we have been able to determine through 1446f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * experimentation, shows that flush the texture cache appears to be 1456f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * sufficient. The theory here is that all of the sampling/rendering 1466f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * units cache the binding table in the texture cache. However, we have 1476f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * yet to be able to actually confirm this. 1486f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand */ 14950018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 15056453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.TextureCacheInvalidationEnable = true; 15156453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 1526f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand} 1536f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 1549be9f5f1c71a5c8942b1f41d0512479a9899df42Jason Ekstrandstatic void 1559be9f5f1c71a5c8942b1f41d0512479a9899df42Jason Ekstrandadd_surface_state_reloc(struct anv_cmd_buffer *cmd_buffer, 1569be9f5f1c71a5c8942b1f41d0512479a9899df42Jason Ekstrand struct anv_state state, 1579be9f5f1c71a5c8942b1f41d0512479a9899df42Jason Ekstrand struct anv_bo *bo, uint32_t offset) 1589be9f5f1c71a5c8942b1f41d0512479a9899df42Jason Ekstrand{ 1599be9f5f1c71a5c8942b1f41d0512479a9899df42Jason Ekstrand const struct isl_device *isl_dev = &cmd_buffer->device->isl_dev; 1609be9f5f1c71a5c8942b1f41d0512479a9899df42Jason Ekstrand 1619be9f5f1c71a5c8942b1f41d0512479a9899df42Jason Ekstrand anv_reloc_list_add(&cmd_buffer->surface_relocs, &cmd_buffer->pool->alloc, 1629be9f5f1c71a5c8942b1f41d0512479a9899df42Jason Ekstrand state.offset + isl_dev->ss.addr_offset, bo, offset); 1639be9f5f1c71a5c8942b1f41d0512479a9899df42Jason Ekstrand} 1649be9f5f1c71a5c8942b1f41d0512479a9899df42Jason Ekstrand 165818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrandstatic void 166818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrandadd_image_view_relocs(struct anv_cmd_buffer *cmd_buffer, 167818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand const struct anv_image_view *iview, 168338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand enum isl_aux_usage aux_usage, 169818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand struct anv_state state) 170818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand{ 171818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand const struct isl_device *isl_dev = &cmd_buffer->device->isl_dev; 172818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand 173818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand anv_reloc_list_add(&cmd_buffer->surface_relocs, &cmd_buffer->pool->alloc, 174818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand state.offset + isl_dev->ss.addr_offset, 175818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand iview->bo, iview->offset); 176338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand 177338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand if (aux_usage != ISL_AUX_USAGE_NONE) { 178338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand uint32_t aux_offset = iview->offset + iview->image->aux_surface.offset; 179338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand 180338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand /* On gen7 and prior, the bottom 12 bits of the MCS base address are 181338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand * used to store other information. This should be ok, however, because 182338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand * surface buffer addresses are always 4K page alinged. 183338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand */ 184338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand assert((aux_offset & 0xfff) == 0); 185338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand uint32_t *aux_addr_dw = state.map + isl_dev->ss.aux_addr_offset; 186338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand aux_offset += *aux_addr_dw & 0xfff; 187338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand 188338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand anv_reloc_list_add(&cmd_buffer->surface_relocs, &cmd_buffer->pool->alloc, 189338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand state.offset + isl_dev->ss.aux_addr_offset, 190338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand iview->bo, aux_offset); 191338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand } 192338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand} 193338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand 1945e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrandstatic bool 1955e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrandcolor_is_zero_one(VkClearColorValue value, enum isl_format format) 196338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand{ 1975e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand if (isl_format_has_int_channel(format)) { 1985e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand for (unsigned i = 0; i < 4; i++) { 1995e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand if (value.int32[i] != 0 && value.int32[i] != 1) 2005e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand return false; 2015e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand } 2025e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand } else { 2035e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand for (unsigned i = 0; i < 4; i++) { 2045e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand if (value.float32[i] != 0.0f && value.float32[i] != 1.0f) 2055e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand return false; 2065e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand } 2075e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand } 208338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand 2095e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand return true; 2105e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand} 2115e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand 2125e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrandstatic void 2135e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrandcolor_attachment_compute_aux_usage(struct anv_device *device, 2145e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand struct anv_attachment_state *att_state, 2155e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand struct anv_image_view *iview, 2165e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand VkRect2D render_area, 2175e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand union isl_color_value *fast_clear_color) 2185e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand{ 2195e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand if (iview->image->aux_surface.isl.size == 0) { 2205e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand att_state->aux_usage = ISL_AUX_USAGE_NONE; 2215e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand att_state->input_aux_usage = ISL_AUX_USAGE_NONE; 2225e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand att_state->fast_clear = false; 2235e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand return; 2245e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand } 225338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand 226338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand assert(iview->image->aux_surface.isl.usage & ISL_SURF_USAGE_CCS_BIT); 227338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand 2285e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand att_state->clear_color_is_zero_one = 2295e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand color_is_zero_one(att_state->clear_value.color, iview->isl.format); 230338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand 2315e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand if (att_state->pending_clear_aspects == VK_IMAGE_ASPECT_COLOR_BIT) { 2325e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand /* Start off assuming fast clears are possible */ 2335e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand att_state->fast_clear = true; 2345e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand 2355e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand /* Potentially, we could do partial fast-clears but doing so has crazy 2365e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand * alignment restrictions. It's easier to just restrict to full size 2375e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand * fast clears for now. 2385e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand */ 2395e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand if (render_area.offset.x != 0 || 2405e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand render_area.offset.y != 0 || 2415e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand render_area.extent.width != iview->extent.width || 2425e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand render_area.extent.height != iview->extent.height) 2435e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand att_state->fast_clear = false; 2445e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand 2453fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand if (GEN_GEN <= 7) { 2463fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand /* On gen7, we can't do multi-LOD or multi-layer fast-clears. We 2473fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand * technically can, but it comes with crazy restrictions that we 2483fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand * don't want to deal with now. 2493fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand */ 2503fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand if (iview->isl.base_level > 0 || 2513fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand iview->isl.base_array_layer > 0 || 2523fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand iview->isl.array_len > 1) 2533fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand att_state->fast_clear = false; 2543fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand } 2553fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand 2563fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand /* On Broadwell and earlier, we can only handle 0/1 clear colors */ 2573fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand if (GEN_GEN <= 8 && !att_state->clear_color_is_zero_one) 2583fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand att_state->fast_clear = false; 2593fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand 2605e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand if (att_state->fast_clear) { 2615e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand memcpy(fast_clear_color->u32, att_state->clear_value.color.uint32, 2625e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand sizeof(fast_clear_color->u32)); 2635e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand } 2645e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand } else { 2655e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand att_state->fast_clear = false; 2665e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand } 2675e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand 2685e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand if (isl_format_supports_lossless_compression(&device->info, 2695e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand iview->isl.format)) { 2705e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand att_state->aux_usage = ISL_AUX_USAGE_CCS_E; 2715e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand att_state->input_aux_usage = ISL_AUX_USAGE_CCS_E; 2725e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand } else if (att_state->fast_clear) { 2735e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand att_state->aux_usage = ISL_AUX_USAGE_CCS_D; 2743fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand if (GEN_GEN >= 9) { 2753fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand /* From the Sky Lake PRM, RENDER_SURFACE_STATE::AuxiliarySurfaceMode: 2763fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand * 2773fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand * "If Number of Multisamples is MULTISAMPLECOUNT_1, AUX_CCS_D 2783fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand * setting is only allowed if Surface Format supported for Fast 2793fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand * Clear. In addition, if the surface is bound to the sampling 2803fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand * engine, Surface Format must be supported for Render Target 2813fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand * Compression for surfaces bound to the sampling engine." 2823fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand * 2833fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand * In other words, we can't sample from a fast-cleared image if it 2843fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand * doesn't also support color compression. 2853fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand */ 2863fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand att_state->input_aux_usage = ISL_AUX_USAGE_NONE; 2873fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand } else if (GEN_GEN == 8) { 2883fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand /* Broadwell can sample from fast-cleared images */ 2893fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand att_state->input_aux_usage = ISL_AUX_USAGE_CCS_D; 2903fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand } else { 2913fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand /* Ivy Bridge and Haswell cannot */ 2923fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand att_state->input_aux_usage = ISL_AUX_USAGE_NONE; 2933fd79558beb3ab156882a206d5a6027fa9db4af7Jason Ekstrand } 2945e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand } else { 2955e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand att_state->aux_usage = ISL_AUX_USAGE_NONE; 2965e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand att_state->input_aux_usage = ISL_AUX_USAGE_NONE; 2975e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand } 298818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand} 299818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand 3001d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrandstatic bool 3011d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrandneed_input_attachment_state(const struct anv_render_pass_attachment *att) 3021d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand{ 3031d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand if (!(att->usage & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT)) 3041d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand return false; 3051d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand 3061d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand /* We only allocate input attachment states for color and depth surfaces. 3071d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand * Stencil doesn't allow compression so we can just use the texture surface 3081d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand * state from the view 3091d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand */ 3101d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand return vk_format_is_color(att->format) || vk_format_has_depth(att->format); 3111d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand} 3121d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand 3132e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Cherystatic enum isl_aux_usage 3142e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Cherylayout_to_hiz_usage(VkImageLayout layout) 3152e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery{ 3162e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery switch (layout) { 3172e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL: 3182e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery return ISL_AUX_USAGE_HIZ; 3192e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery default: 3202e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery return ISL_AUX_USAGE_NONE; 3212e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery } 3222e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery} 3232e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery 3242e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery/* Transitions a HiZ-enabled depth buffer from one layout to another. Unless 3252e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery * the initial layout is undefined, the HiZ buffer and depth buffer will 3262e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery * represent the same data at the end of this operation. 3272e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery */ 3282e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Cherystatic void 3292e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Cherytransition_depth_buffer(struct anv_cmd_buffer *cmd_buffer, 3302e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery const struct anv_image *image, 3312e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery VkImageLayout initial_layout, 3322e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery VkImageLayout final_layout) 3332e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery{ 3342e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery assert(image); 3352e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery 3362e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery if (image->aux_usage != ISL_AUX_USAGE_HIZ) 3372e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery return; 3382e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery 3392e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery const bool hiz_enabled = layout_to_hiz_usage(initial_layout) == 3402e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery ISL_AUX_USAGE_HIZ; 3412e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery const bool enable_hiz = layout_to_hiz_usage(final_layout) == 3422e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery ISL_AUX_USAGE_HIZ; 3432e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery 3442e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery /* We've already initialized the aux HiZ buffer at BindImageMemory time, 3452e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery * so there's no need to perform a HIZ resolve or clear to avoid GPU hangs. 3462e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery * This initial layout indicates that the user doesn't care about the data 3472e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery * that's currently in the buffer, so no resolves are necessary. 3482e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery */ 3492e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery if (initial_layout == VK_IMAGE_LAYOUT_UNDEFINED) 3502e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery return; 3512e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery 3522e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery if (hiz_enabled == enable_hiz) { 3532e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery /* The same buffer will be used, no resolves are necessary */ 3542e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery } else if (hiz_enabled && !enable_hiz) { 3552e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery anv_gen8_hiz_op_resolve(cmd_buffer, image, BLORP_HIZ_OP_DEPTH_RESOLVE); 3562e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery } else { 3572e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery assert(!hiz_enabled && enable_hiz); 3582e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery anv_gen8_hiz_op_resolve(cmd_buffer, image, BLORP_HIZ_OP_HIZ_RESOLVE); 3592e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery } 3602e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery} 3612e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery 3622e2cf78a5104b3e08fea039d1b2d20a137d6a371Nanley Chery 363d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand/** 364d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand * Setup anv_cmd_state::attachments for vkCmdBeginRenderPass. 365d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand */ 366d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrandstatic void 367d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason EkstrandgenX(cmd_buffer_setup_attachments)(struct anv_cmd_buffer *cmd_buffer, 368d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_render_pass *pass, 369d1d6b788989e73edd2426999d891230500dc1a73Jason Ekstrand const VkRenderPassBeginInfo *begin) 370d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand{ 371d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand const struct isl_device *isl_dev = &cmd_buffer->device->isl_dev; 372d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_cmd_state *state = &cmd_buffer->state; 373d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 374d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand vk_free(&cmd_buffer->pool->alloc, state->attachments); 375d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 376d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (pass->attachment_count == 0) { 377d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand state->attachments = NULL; 378d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand return; 379d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 380d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 381d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand state->attachments = vk_alloc(&cmd_buffer->pool->alloc, 382d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand pass->attachment_count * 383d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand sizeof(state->attachments[0]), 384d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); 385d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (state->attachments == NULL) { 386d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand /* FIXME: Propagate VK_ERROR_OUT_OF_HOST_MEMORY to vkEndCommandBuffer */ 387d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand abort(); 388d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 389d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 390d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand bool need_null_state = false; 391633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand unsigned num_states = 0; 392d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand for (uint32_t i = 0; i < pass->attachment_count; ++i) { 393633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand if (vk_format_is_color(pass->attachments[i].format)) { 394d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand num_states++; 395633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand } else { 396633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand /* We need a null state for any depth-stencil-only subpasses. 397633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand * Importantly, this includes depth/stencil clears so we create one 398633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand * whenever we have depth or stencil 399633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand */ 400633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand need_null_state = true; 401633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand } 4021d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand 4031d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand if (need_input_attachment_state(&pass->attachments[i])) 4041d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand num_states++; 405d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 406633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand num_states += need_null_state; 407d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 408d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand const uint32_t ss_stride = align_u32(isl_dev->ss.size, isl_dev->ss.align); 409d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand state->render_pass_states = 410d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand anv_state_stream_alloc(&cmd_buffer->surface_state_stream, 411d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand num_states * ss_stride, isl_dev->ss.align); 412d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 413d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_state next_state = state->render_pass_states; 414d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand next_state.alloc_size = isl_dev->ss.size; 415d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 416d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (need_null_state) { 417d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand state->null_surface_state = next_state; 418d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand next_state.offset += ss_stride; 419d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand next_state.map += ss_stride; 420d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 421d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 422d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand for (uint32_t i = 0; i < pass->attachment_count; ++i) { 423d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (vk_format_is_color(pass->attachments[i].format)) { 424d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand state->attachments[i].color_rt_state = next_state; 425d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand next_state.offset += ss_stride; 426d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand next_state.map += ss_stride; 427d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 4281d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand 4291d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand if (need_input_attachment_state(&pass->attachments[i])) { 4301d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand state->attachments[i].input_att_state = next_state; 4311d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand next_state.offset += ss_stride; 4321d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand next_state.map += ss_stride; 4331d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand } 434d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 435d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand assert(next_state.offset == state->render_pass_states.offset + 436d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand state->render_pass_states.alloc_size); 437d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 438d1d6b788989e73edd2426999d891230500dc1a73Jason Ekstrand if (begin) { 439d1d6b788989e73edd2426999d891230500dc1a73Jason Ekstrand ANV_FROM_HANDLE(anv_framebuffer, framebuffer, begin->framebuffer); 440d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand assert(pass->attachment_count == framebuffer->attachment_count); 441d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 442d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (need_null_state) { 443d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct GENX(RENDER_SURFACE_STATE) null_ss = { 444d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .SurfaceType = SURFTYPE_NULL, 445d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .SurfaceArray = framebuffer->layers > 0, 446d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .SurfaceFormat = ISL_FORMAT_R8G8B8A8_UNORM, 447d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand#if GEN_GEN >= 8 448d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .TileMode = YMAJOR, 449d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand#else 450d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .TiledSurface = true, 451d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand#endif 452d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .Width = framebuffer->width - 1, 453d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .Height = framebuffer->height - 1, 454d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .Depth = framebuffer->layers - 1, 455d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .RenderTargetViewExtent = framebuffer->layers - 1, 456d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand }; 457d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand GENX(RENDER_SURFACE_STATE_pack)(NULL, state->null_surface_state.map, 458d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand &null_ss); 459d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 460d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 461d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand for (uint32_t i = 0; i < pass->attachment_count; ++i) { 462d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_render_pass_attachment *att = &pass->attachments[i]; 463d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand VkImageAspectFlags att_aspects = vk_format_aspects(att->format); 464d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand VkImageAspectFlags clear_aspects = 0; 465d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 466d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (att_aspects == VK_IMAGE_ASPECT_COLOR_BIT) { 467d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand /* color attachment */ 468d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (att->load_op == VK_ATTACHMENT_LOAD_OP_CLEAR) { 469d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand clear_aspects |= VK_IMAGE_ASPECT_COLOR_BIT; 470d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 471d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } else { 472d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand /* depthstencil attachment */ 473d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if ((att_aspects & VK_IMAGE_ASPECT_DEPTH_BIT) && 474d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand att->load_op == VK_ATTACHMENT_LOAD_OP_CLEAR) { 475d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand clear_aspects |= VK_IMAGE_ASPECT_DEPTH_BIT; 476d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 477d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if ((att_aspects & VK_IMAGE_ASPECT_STENCIL_BIT) && 478d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand att->stencil_load_op == VK_ATTACHMENT_LOAD_OP_CLEAR) { 479d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand clear_aspects |= VK_IMAGE_ASPECT_STENCIL_BIT; 480d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 481d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 482d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 483d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand state->attachments[i].pending_clear_aspects = clear_aspects; 484d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (clear_aspects) 485d1d6b788989e73edd2426999d891230500dc1a73Jason Ekstrand state->attachments[i].clear_value = begin->pClearValues[i]; 486d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 487d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_image_view *iview = framebuffer->attachments[i]; 488d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand assert(iview->vk_format == att->format); 489d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 4905e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand union isl_color_value clear_color = { .u32 = { 0, } }; 491d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (att_aspects == VK_IMAGE_ASPECT_COLOR_BIT) { 4925e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand color_attachment_compute_aux_usage(cmd_buffer->device, 4935e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand &state->attachments[i], 4945e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand iview, begin->renderArea, 4955e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand &clear_color); 496338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand 497d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct isl_view view = iview->isl; 498d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand view.usage |= ISL_SURF_USAGE_RENDER_TARGET_BIT; 499d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand isl_surf_fill_state(isl_dev, 500d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand state->attachments[i].color_rt_state.map, 501d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .surf = &iview->image->color_surface.isl, 502d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .view = &view, 503338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand .aux_surf = &iview->image->aux_surface.isl, 504338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand .aux_usage = state->attachments[i].aux_usage, 5055e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand .clear_color = clear_color, 506d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .mocs = cmd_buffer->device->default_mocs); 507d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 508818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand add_image_view_relocs(cmd_buffer, iview, 509338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand state->attachments[i].aux_usage, 510818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand state->attachments[i].color_rt_state); 511338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand } else { 512168985fca1b59d345471277d5c8ce4a82cdc74f4Nanley Chery state->attachments[i].aux_usage = iview->image->aux_usage; 5135e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand state->attachments[i].input_aux_usage = ISL_AUX_USAGE_NONE; 514d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 5151d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand 5161d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand if (need_input_attachment_state(&pass->attachments[i])) { 5171d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand const struct isl_surf *surf; 5181d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand if (att_aspects == VK_IMAGE_ASPECT_COLOR_BIT) { 5191d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand surf = &iview->image->color_surface.isl; 5201d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand } else { 5211d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand surf = &iview->image->depth_surface.isl; 5221d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand } 5231d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand 5241d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand struct isl_view view = iview->isl; 5251d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand view.usage |= ISL_SURF_USAGE_TEXTURE_BIT; 5261d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand isl_surf_fill_state(isl_dev, 5271d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand state->attachments[i].input_att_state.map, 5281d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand .surf = surf, 5291d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand .view = &view, 5301d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand .aux_surf = &iview->image->aux_surface.isl, 5315e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand .aux_usage = state->attachments[i].input_aux_usage, 5325e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand .clear_color = clear_color, 5331d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand .mocs = cmd_buffer->device->default_mocs); 5341d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand 5351d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand add_image_view_relocs(cmd_buffer, iview, 5365e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand state->attachments[i].input_aux_usage, 5371d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand state->attachments[i].input_att_state); 5381d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand } 539d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 540d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 541d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (!cmd_buffer->device->info.has_llc) 542d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand anv_state_clflush(state->render_pass_states); 543d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 544d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand} 545d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 5462314c9ed2e39bcf4ac6b206344acb05fec876a41Jason EkstrandVkResult 5472314c9ed2e39bcf4ac6b206344acb05fec876a41Jason EkstrandgenX(BeginCommandBuffer)( 5482314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand VkCommandBuffer commandBuffer, 5492314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand const VkCommandBufferBeginInfo* pBeginInfo) 5502314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand{ 5512314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 5522314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 5532314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand /* If this is the first vkBeginCommandBuffer, we must *initialize* the 5542314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * command buffer's state. Otherwise, we must *reset* its state. In both 5552314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * cases we reset it. 5562314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * 5572314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * From the Vulkan 1.0 spec: 5582314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * 5592314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * If a command buffer is in the executable state and the command buffer 5602314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * was allocated from a command pool with the 5612314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT flag set, then 5622314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * vkBeginCommandBuffer implicitly resets the command buffer, behaving 5632314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * as if vkResetCommandBuffer had been called with 5642314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT not set. It then puts 5652314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * the command buffer in the recording state. 5662314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand */ 5672314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand anv_cmd_buffer_reset(cmd_buffer); 5682314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 5692314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand cmd_buffer->usage_flags = pBeginInfo->flags; 5702314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 5712314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand assert(cmd_buffer->level == VK_COMMAND_BUFFER_LEVEL_SECONDARY || 5722314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand !(cmd_buffer->usage_flags & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT)); 5732314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 5742314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand genX(cmd_buffer_emit_state_base_address)(cmd_buffer); 5752314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 5762314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand if (cmd_buffer->usage_flags & 5772314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT) { 5782314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand cmd_buffer->state.pass = 5792314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand anv_render_pass_from_handle(pBeginInfo->pInheritanceInfo->renderPass); 5802314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand cmd_buffer->state.subpass = 5812314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand &cmd_buffer->state.pass->subpasses[pBeginInfo->pInheritanceInfo->subpass]; 582a380f954610319782811bb2aa44180c4e1231823Jason Ekstrand cmd_buffer->state.framebuffer = NULL; 5832314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 584d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand genX(cmd_buffer_setup_attachments)(cmd_buffer, cmd_buffer->state.pass, 585d1d6b788989e73edd2426999d891230500dc1a73Jason Ekstrand NULL); 586d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 5872314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand cmd_buffer->state.dirty |= ANV_CMD_DIRTY_RENDER_TARGETS; 5882314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand } 5892314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 5902314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand return VK_SUCCESS; 5912314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand} 5922314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 5932314c9ed2e39bcf4ac6b206344acb05fec876a41Jason EkstrandVkResult 5942314c9ed2e39bcf4ac6b206344acb05fec876a41Jason EkstrandgenX(EndCommandBuffer)( 5952314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand VkCommandBuffer commandBuffer) 5962314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand{ 5972314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 5982314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 5998d1ccd67290c1fd0213aed6a7e9a6bf85858f227Jason Ekstrand genX(cmd_buffer_apply_pipe_flushes)(cmd_buffer); 6008d1ccd67290c1fd0213aed6a7e9a6bf85858f227Jason Ekstrand 6012314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand anv_cmd_buffer_end_batch_buffer(cmd_buffer); 6022314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 6032314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand return VK_SUCCESS; 6042314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand} 6052314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 6062314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrandvoid 6072314c9ed2e39bcf4ac6b206344acb05fec876a41Jason EkstrandgenX(CmdExecuteCommands)( 6082314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand VkCommandBuffer commandBuffer, 6092314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand uint32_t commandBufferCount, 6102314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand const VkCommandBuffer* pCmdBuffers) 6112314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand{ 6122314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand ANV_FROM_HANDLE(anv_cmd_buffer, primary, commandBuffer); 6132314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 6142314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand assert(primary->level == VK_COMMAND_BUFFER_LEVEL_PRIMARY); 6152314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 6162314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand for (uint32_t i = 0; i < commandBufferCount; i++) { 6172314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand ANV_FROM_HANDLE(anv_cmd_buffer, secondary, pCmdBuffers[i]); 6182314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 6192314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand assert(secondary->level == VK_COMMAND_BUFFER_LEVEL_SECONDARY); 6202314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 621d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (secondary->usage_flags & 622d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT) { 623d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand /* If we're continuing a render pass from the primary, we need to 624d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand * copy the surface states for the current subpass into the storage 625d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand * we allocated for them in BeginCommandBuffer. 626d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand */ 627d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_bo *ss_bo = &primary->device->surface_state_block_pool.bo; 628d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_state src_state = primary->state.render_pass_states; 629d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_state dst_state = secondary->state.render_pass_states; 630d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand assert(src_state.alloc_size == dst_state.alloc_size); 631d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 632d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand genX(cmd_buffer_gpu_memcpy)(primary, ss_bo, dst_state.offset, 633d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand ss_bo, src_state.offset, 634d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand src_state.alloc_size); 635d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 636d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 6372314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand anv_cmd_buffer_add_secondary(primary, secondary); 6382314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand } 6392314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 6402314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand /* Each of the secondary command buffers will use its own state base 6412314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * address. We need to re-emit state base address for the primary after 6422314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * all of the secondaries are done. 6432314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * 6442314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * TODO: Maybe we want to make this a dirty bit to avoid extra state base 6452314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * address calls? 6462314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand */ 6472314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand genX(cmd_buffer_emit_state_base_address)(primary); 6482314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand} 6492314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 6507e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#define IVB_L3SQCREG1_SQGHPCI_DEFAULT 0x00730000 6517e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#define VLV_L3SQCREG1_SQGHPCI_DEFAULT 0x00d30000 6527e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#define HSW_L3SQCREG1_SQGHPCI_DEFAULT 0x00610000 6537e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 6547e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand/** 6557e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * Program the hardware to use the specified L3 configuration. 6567e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand */ 6577e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrandvoid 6587e891f90c701aa1c851f1846857daa75bbb65876Jason EkstrandgenX(cmd_buffer_config_l3)(struct anv_cmd_buffer *cmd_buffer, 6597e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const struct gen_l3_config *cfg) 6607e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand{ 6617e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand assert(cfg); 6627e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand if (cfg == cmd_buffer->state.current_l3_config) 6637e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand return; 6647e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 6657e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand if (unlikely(INTEL_DEBUG & DEBUG_L3)) { 6667e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand fprintf(stderr, "L3 config transition: "); 6677e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand gen_dump_l3_config(cfg, stderr); 6687e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand } 6697e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 6707e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const bool has_slm = cfg->n[GEN_L3P_SLM]; 6717e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 6727e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* According to the hardware docs, the L3 partitioning can only be changed 6737e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * while the pipeline is completely drained and the caches are flushed, 6747e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * which involves a first PIPE_CONTROL flush which stalls the pipeline... 6757e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand */ 6767e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 6777e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.DCFlushEnable = true; 6787e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.PostSyncOperation = NoWrite; 6797e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.CommandStreamerStallEnable = true; 6807e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand } 6817e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 6827e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* ...followed by a second pipelined PIPE_CONTROL that initiates 6837e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * invalidation of the relevant caches. Note that because RO invalidation 6847e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * happens at the top of the pipeline (i.e. right away as the PIPE_CONTROL 6857e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * command is processed by the CS) we cannot combine it with the previous 6867e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * stalling flush as the hardware documentation suggests, because that 6877e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * would cause the CS to stall on previous rendering *after* RO 6887e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * invalidation and wouldn't prevent the RO caches from being polluted by 6897e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * concurrent rendering before the stall completes. This intentionally 6907e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * doesn't implement the SKL+ hardware workaround suggesting to enable CS 6917e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * stall on PIPE_CONTROLs with the texture cache invalidation bit set for 6927e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * GPGPU workloads because the previous and subsequent PIPE_CONTROLs 6937e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * already guarantee that there is no concurrent GPGPU kernel execution 6947e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * (see SKL HSD 2132585). 6957e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand */ 6967e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 6977e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.TextureCacheInvalidationEnable = true; 6987e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.ConstantCacheInvalidationEnable = true; 6997e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.InstructionCacheInvalidateEnable = true; 7007e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.StateCacheInvalidationEnable = true; 7017e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.PostSyncOperation = NoWrite; 7027e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand } 7037e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7047e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* Now send a third stalling flush to make sure that invalidation is 7057e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * complete when the L3 configuration registers are modified. 7067e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand */ 7077e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 7087e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.DCFlushEnable = true; 7097e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.PostSyncOperation = NoWrite; 7107e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.CommandStreamerStallEnable = true; 7117e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand } 7127e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7137e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#if GEN_GEN >= 8 7147e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7157e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand assert(!cfg->n[GEN_L3P_IS] && !cfg->n[GEN_L3P_C] && !cfg->n[GEN_L3P_T]); 7167e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7177e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand uint32_t l3cr; 7187e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_pack_struct(&l3cr, GENX(L3CNTLREG), 7197e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .SLMEnable = has_slm, 7207e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .URBAllocation = cfg->n[GEN_L3P_URB], 7217e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ROAllocation = cfg->n[GEN_L3P_RO], 7227e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .DCAllocation = cfg->n[GEN_L3P_DC], 7237e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .AllAllocation = cfg->n[GEN_L3P_ALL]); 7247e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7257e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* Set up the L3 partitioning. */ 7267e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand emit_lri(&cmd_buffer->batch, GENX(L3CNTLREG_num), l3cr); 7277e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7287e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#else 7297e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7307e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const bool has_dc = cfg->n[GEN_L3P_DC] || cfg->n[GEN_L3P_ALL]; 7317e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const bool has_is = cfg->n[GEN_L3P_IS] || cfg->n[GEN_L3P_RO] || 7327e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand cfg->n[GEN_L3P_ALL]; 7337e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const bool has_c = cfg->n[GEN_L3P_C] || cfg->n[GEN_L3P_RO] || 7347e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand cfg->n[GEN_L3P_ALL]; 7357e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const bool has_t = cfg->n[GEN_L3P_T] || cfg->n[GEN_L3P_RO] || 7367e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand cfg->n[GEN_L3P_ALL]; 7377e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7387e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand assert(!cfg->n[GEN_L3P_ALL]); 7397e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7407e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* When enabled SLM only uses a portion of the L3 on half of the banks, 7417e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * the matching space on the remaining banks has to be allocated to a 7427e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * client (URB for all validated configurations) set to the 7437e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * lower-bandwidth 2-bank address hashing mode. 7447e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand */ 7457e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const struct gen_device_info *devinfo = &cmd_buffer->device->info; 7467e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const bool urb_low_bw = has_slm && !devinfo->is_baytrail; 7477e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand assert(!urb_low_bw || cfg->n[GEN_L3P_URB] == cfg->n[GEN_L3P_SLM]); 7487e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7497e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* Minimum number of ways that can be allocated to the URB. */ 7503a1b15c3921d25ea2e6e81f500c3f45c84b95817Grazvydas Ignotas MAYBE_UNUSED const unsigned n0_urb = devinfo->is_baytrail ? 32 : 0; 7517e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand assert(cfg->n[GEN_L3P_URB] >= n0_urb); 7527e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7537e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand uint32_t l3sqcr1, l3cr2, l3cr3; 7547e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_pack_struct(&l3sqcr1, GENX(L3SQCREG1), 7557e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ConvertDC_UC = !has_dc, 7567e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ConvertIS_UC = !has_is, 7577e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ConvertC_UC = !has_c, 7587e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ConvertT_UC = !has_t); 7597e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand l3sqcr1 |= 7607e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand GEN_IS_HASWELL ? HSW_L3SQCREG1_SQGHPCI_DEFAULT : 7617e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand devinfo->is_baytrail ? VLV_L3SQCREG1_SQGHPCI_DEFAULT : 7627e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand IVB_L3SQCREG1_SQGHPCI_DEFAULT; 7637e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7647e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_pack_struct(&l3cr2, GENX(L3CNTLREG2), 7657e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .SLMEnable = has_slm, 7667e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .URBLowBandwidth = urb_low_bw, 7677e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .URBAllocation = cfg->n[GEN_L3P_URB], 7687e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#if !GEN_IS_HASWELL 7697e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ALLAllocation = cfg->n[GEN_L3P_ALL], 7707e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#endif 7717e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ROAllocation = cfg->n[GEN_L3P_RO], 7727e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .DCAllocation = cfg->n[GEN_L3P_DC]); 7737e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7747e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_pack_struct(&l3cr3, GENX(L3CNTLREG3), 7757e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ISAllocation = cfg->n[GEN_L3P_IS], 7767e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ISLowBandwidth = 0, 7777e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .CAllocation = cfg->n[GEN_L3P_C], 7787e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .CLowBandwidth = 0, 7797e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .TAllocation = cfg->n[GEN_L3P_T], 7807e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .TLowBandwidth = 0); 7817e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7827e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* Set up the L3 partitioning. */ 7837e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand emit_lri(&cmd_buffer->batch, GENX(L3SQCREG1_num), l3sqcr1); 7847e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand emit_lri(&cmd_buffer->batch, GENX(L3CNTLREG2_num), l3cr2); 7857e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand emit_lri(&cmd_buffer->batch, GENX(L3CNTLREG3_num), l3cr3); 7867e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7877e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#if GEN_IS_HASWELL 7887e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand if (cmd_buffer->device->instance->physicalDevice.cmd_parser_version >= 4) { 7897e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* Enable L3 atomics on HSW if we have a DC partition, otherwise keep 7907e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * them disabled to avoid crashing the system hard. 7917e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand */ 7927e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand uint32_t scratch1, chicken3; 7937e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_pack_struct(&scratch1, GENX(SCRATCH1), 7947e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .L3AtomicDisable = !has_dc); 7957e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_pack_struct(&chicken3, GENX(CHICKEN3), 79689a96c8f43370cc84adf92ab32e3de302a1fa1d0Jason Ekstrand .L3AtomicDisableMask = true, 7977e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .L3AtomicDisable = !has_dc); 7987e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand emit_lri(&cmd_buffer->batch, GENX(SCRATCH1_num), scratch1); 7997e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand emit_lri(&cmd_buffer->batch, GENX(CHICKEN3_num), chicken3); 8007e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand } 8017e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#endif 8027e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 8037e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#endif 8047e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 8057e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand cmd_buffer->state.current_l3_config = cfg; 8067e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand} 8077e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 8083a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrandvoid 8093a83c176eab8c513eb723554a240af1a7308d701Jason EkstrandgenX(cmd_buffer_apply_pipe_flushes)(struct anv_cmd_buffer *cmd_buffer) 8103a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand{ 8113a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand enum anv_pipe_bits bits = cmd_buffer->state.pending_pipe_bits; 8123a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8133a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand /* Flushes are pipelined while invalidations are handled immediately. 8143a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * Therefore, if we're flushing anything then we need to schedule a stall 8153a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * before any invalidations can happen. 8163a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand */ 8173a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand if (bits & ANV_PIPE_FLUSH_BITS) 8183a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits |= ANV_PIPE_NEEDS_CS_STALL_BIT; 8193a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8203a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand /* If we're going to do an invalidate and we have a pending CS stall that 8213a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * has yet to be resolved, we do the CS stall now. 8223a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand */ 8233a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand if ((bits & ANV_PIPE_INVALIDATE_BITS) && 8243a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand (bits & ANV_PIPE_NEEDS_CS_STALL_BIT)) { 8253a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits |= ANV_PIPE_CS_STALL_BIT; 8263a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits &= ~ANV_PIPE_NEEDS_CS_STALL_BIT; 8273a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand } 8283a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8293a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand if (bits & (ANV_PIPE_FLUSH_BITS | ANV_PIPE_CS_STALL_BIT)) { 8303a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pipe) { 8313a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.DepthCacheFlushEnable = bits & ANV_PIPE_DEPTH_CACHE_FLUSH_BIT; 8323a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.DCFlushEnable = bits & ANV_PIPE_DATA_CACHE_FLUSH_BIT; 8333a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.RenderTargetCacheFlushEnable = 8343a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits & ANV_PIPE_RENDER_TARGET_CACHE_FLUSH_BIT; 8353a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8363a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.DepthStallEnable = bits & ANV_PIPE_DEPTH_STALL_BIT; 8373a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.CommandStreamerStallEnable = bits & ANV_PIPE_CS_STALL_BIT; 8383a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.StallAtPixelScoreboard = bits & ANV_PIPE_STALL_AT_SCOREBOARD_BIT; 8393a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8403a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand /* 8413a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * According to the Broadwell documentation, any PIPE_CONTROL with the 8423a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * "Command Streamer Stall" bit set must also have another bit set, 8433a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * with five different options: 8443a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * 8453a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * - Render Target Cache Flush 8463a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * - Depth Cache Flush 8473a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * - Stall at Pixel Scoreboard 8483a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * - Post-Sync Operation 8493a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * - Depth Stall 8503a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * - DC Flush Enable 8513a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * 8523a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * I chose "Stall at Pixel Scoreboard" since that's what we use in 8533a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * mesa and it seems to work fine. The choice is fairly arbitrary. 8543a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand */ 8553a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand if ((bits & ANV_PIPE_CS_STALL_BIT) && 8563a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand !(bits & (ANV_PIPE_FLUSH_BITS | ANV_PIPE_DEPTH_STALL_BIT | 8573a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand ANV_PIPE_STALL_AT_SCOREBOARD_BIT))) 8583a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.StallAtPixelScoreboard = true; 8593a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand } 8603a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8613a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits &= ~(ANV_PIPE_FLUSH_BITS | ANV_PIPE_CS_STALL_BIT); 8623a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand } 8633a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8643a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand if (bits & ANV_PIPE_INVALIDATE_BITS) { 8653a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pipe) { 8663a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.StateCacheInvalidationEnable = 8673a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits & ANV_PIPE_STATE_CACHE_INVALIDATE_BIT; 8683a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.ConstantCacheInvalidationEnable = 8693a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits & ANV_PIPE_CONSTANT_CACHE_INVALIDATE_BIT; 8703a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.VFCacheInvalidationEnable = 8713a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits & ANV_PIPE_VF_CACHE_INVALIDATE_BIT; 8723a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.TextureCacheInvalidationEnable = 8733a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits & ANV_PIPE_TEXTURE_CACHE_INVALIDATE_BIT; 8743a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.InstructionCacheInvalidateEnable = 8753a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits & ANV_PIPE_INSTRUCTION_CACHE_INVALIDATE_BIT; 8763a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand } 8773a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8783a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits &= ~ANV_PIPE_INVALIDATE_BITS; 8793a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand } 8803a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8813a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand cmd_buffer->state.pending_pipe_bits = bits; 8823a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand} 8833a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8846f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrandvoid genX(CmdPipelineBarrier)( 885a89a485e79ad40793a85979d86d45760362be21aJason Ekstrand VkCommandBuffer commandBuffer, 8866f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand VkPipelineStageFlags srcStageMask, 8876f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand VkPipelineStageFlags destStageMask, 8886f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand VkBool32 byRegion, 889c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand uint32_t memoryBarrierCount, 890c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand const VkMemoryBarrier* pMemoryBarriers, 891c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand uint32_t bufferMemoryBarrierCount, 892c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand const VkBufferMemoryBarrier* pBufferMemoryBarriers, 893c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand uint32_t imageMemoryBarrierCount, 894c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand const VkImageMemoryBarrier* pImageMemoryBarriers) 8956f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand{ 896a89a485e79ad40793a85979d86d45760362be21aJason Ekstrand ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 8973a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand uint32_t b; 8986f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 8996f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand /* XXX: Right now, we're really dumb and just flush whatever categories 9006f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * the app asks for. One of these days we may make this a bit better 9016f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * but right now that's all the hardware allows for in most areas. 9026f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand */ 903b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand VkAccessFlags src_flags = 0; 904b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand VkAccessFlags dst_flags = 0; 9056f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 906c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand for (uint32_t i = 0; i < memoryBarrierCount; i++) { 907c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand src_flags |= pMemoryBarriers[i].srcAccessMask; 908c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand dst_flags |= pMemoryBarriers[i].dstAccessMask; 909c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand } 910c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand 911c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand for (uint32_t i = 0; i < bufferMemoryBarrierCount; i++) { 912c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand src_flags |= pBufferMemoryBarriers[i].srcAccessMask; 913c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand dst_flags |= pBufferMemoryBarriers[i].dstAccessMask; 914c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand } 915c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand 916c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand for (uint32_t i = 0; i < imageMemoryBarrierCount; i++) { 917c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand src_flags |= pImageMemoryBarriers[i].srcAccessMask; 918c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand dst_flags |= pImageMemoryBarriers[i].dstAccessMask; 9196f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand } 9206f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 9213a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand enum anv_pipe_bits pipe_bits = 0; 9225e92e91c6177bfe31214b8a0ebd0d4c47969b61dKristian Høgsberg 923924fbfc9a1fc46a3698fa23649e6dccc3e3e6782Jason Ekstrand for_each_bit(b, src_flags) { 924b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand switch ((VkAccessFlagBits)(1 << b)) { 925b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_SHADER_WRITE_BIT: 9263a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_DATA_CACHE_FLUSH_BIT; 9276f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand break; 928b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT: 9293a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_RENDER_TARGET_CACHE_FLUSH_BIT; 9306f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand break; 931b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: 9323a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_DEPTH_CACHE_FLUSH_BIT; 9336f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand break; 934b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_TRANSFER_WRITE_BIT: 9353a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_RENDER_TARGET_CACHE_FLUSH_BIT; 9363a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_DEPTH_CACHE_FLUSH_BIT; 9376f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand break; 9386f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand default: 9393a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand break; /* Nothing to do */ 9406f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand } 9416f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand } 9426f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 943924fbfc9a1fc46a3698fa23649e6dccc3e3e6782Jason Ekstrand for_each_bit(b, dst_flags) { 944b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand switch ((VkAccessFlagBits)(1 << b)) { 945b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_INDIRECT_COMMAND_READ_BIT: 946b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_INDEX_READ_BIT: 947b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT: 9483a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_VF_CACHE_INVALIDATE_BIT; 9496f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand break; 950b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_UNIFORM_READ_BIT: 9513a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_CONSTANT_CACHE_INVALIDATE_BIT; 9523a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_TEXTURE_CACHE_INVALIDATE_BIT; 9536f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand break; 9543a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand case VK_ACCESS_SHADER_READ_BIT: 95557174d60421e9e63569335a269cd806703f5da5dJason Ekstrand case VK_ACCESS_INPUT_ATTACHMENT_READ_BIT: 956b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_TRANSFER_READ_BIT: 9573a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_TEXTURE_CACHE_INVALIDATE_BIT; 958b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand break; 959b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand default: 9603a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand break; /* Nothing to do */ 9616f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand } 9626f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand } 9636f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 9643a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand cmd_buffer->state.pending_pipe_bits |= pipe_bits; 9656f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand} 966bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 96754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrandstatic void 96854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrandcmd_buffer_alloc_push_constants(struct anv_cmd_buffer *cmd_buffer) 96954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand{ 97054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand VkShaderStageFlags stages = cmd_buffer->state.pipeline->active_stages; 97154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 97254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand /* In order to avoid thrash, we assume that vertex and fragment stages 97354324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * always exist. In the rare case where one is missing *and* the other 97454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * uses push concstants, this may be suboptimal. However, avoiding stalls 97554324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * seems more important. 97654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand */ 97754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand stages |= VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_VERTEX_BIT; 97854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 97954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand if (stages == cmd_buffer->state.push_constant_stages) 98054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand return; 98154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 98254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand#if GEN_GEN >= 8 98354324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand const unsigned push_constant_kb = 32; 98454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand#elif GEN_IS_HASWELL 98554324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand const unsigned push_constant_kb = cmd_buffer->device->info.gt == 3 ? 32 : 16; 98654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand#else 98754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand const unsigned push_constant_kb = 16; 98854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand#endif 98954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 99054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand const unsigned num_stages = 99154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand _mesa_bitcount(stages & VK_SHADER_STAGE_ALL_GRAPHICS); 99254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand unsigned size_per_stage = push_constant_kb / num_stages; 99354324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 99454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand /* Broadwell+ and Haswell gt3 require that the push constant sizes be in 99554324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * units of 2KB. Incidentally, these are the same platforms that have 99654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * 32KB worth of push constant space. 99754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand */ 99854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand if (push_constant_kb == 32) 99954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand size_per_stage &= ~1u; 100054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 100154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand uint32_t kb_used = 0; 100254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand for (int i = MESA_SHADER_VERTEX; i < MESA_SHADER_FRAGMENT; i++) { 100354324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand unsigned push_size = (stages & (1 << i)) ? size_per_stage : 0; 100454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, 100554324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand GENX(3DSTATE_PUSH_CONSTANT_ALLOC_VS), alloc) { 100654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand alloc._3DCommandSubOpcode = 18 + i; 100754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand alloc.ConstantBufferOffset = (push_size > 0) ? kb_used : 0; 100854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand alloc.ConstantBufferSize = push_size; 100954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand } 101054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand kb_used += push_size; 101154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand } 101254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 101354324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, 101454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand GENX(3DSTATE_PUSH_CONSTANT_ALLOC_PS), alloc) { 101554324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand alloc.ConstantBufferOffset = kb_used; 101654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand alloc.ConstantBufferSize = push_constant_kb - kb_used; 101754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand } 101854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 101954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand cmd_buffer->state.push_constant_stages = stages; 102054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 102154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand /* From the BDW PRM for 3DSTATE_PUSH_CONSTANT_ALLOC_VS: 102254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * 102354324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * "The 3DSTATE_CONSTANT_VS must be reprogrammed prior to 102454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * the next 3DPRIMITIVE command after programming the 102554324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * 3DSTATE_PUSH_CONSTANT_ALLOC_VS" 102654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * 102754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * Since 3DSTATE_PUSH_CONSTANT_ALLOC_VS is programmed as part of 102854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * pipeline setup, we need to dirty push constants. 102954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand */ 103054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand cmd_buffer->state.push_constants_dirty |= VK_SHADER_STAGE_ALL_GRAPHICS; 103154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand} 103254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 10337998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandstatic VkResult 10347998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandemit_binding_table(struct anv_cmd_buffer *cmd_buffer, 10357998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand gl_shader_stage stage, 10367998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_state *bt_state) 10377998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand{ 10387998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_subpass *subpass = cmd_buffer->state.subpass; 10397998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_pipeline *pipeline; 10407998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t bias, state_offset; 10417998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10427998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand switch (stage) { 10437998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case MESA_SHADER_COMPUTE: 10447998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand pipeline = cmd_buffer->state.compute_pipeline; 10457998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand bias = 1; 10467998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 10477998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand default: 10487998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand pipeline = cmd_buffer->state.pipeline; 10497998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand bias = 0; 10507998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 10517998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 10527998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10537998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (!anv_pipeline_has_stage(pipeline, stage)) { 10547998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *bt_state = (struct anv_state) { 0, }; 10557998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_SUCCESS; 10567998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 10577998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10587998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_pipeline_bind_map *map = &pipeline->shaders[stage]->bind_map; 10597998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (bias + map->surface_count == 0) { 10607998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *bt_state = (struct anv_state) { 0, }; 10617998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_SUCCESS; 10627998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 10637998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10647998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *bt_state = anv_cmd_buffer_alloc_binding_table(cmd_buffer, 10657998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand bias + map->surface_count, 10667998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand &state_offset); 10677998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t *bt_map = bt_state->map; 10687998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10697998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (bt_state->map == NULL) 10707998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_ERROR_OUT_OF_DEVICE_MEMORY; 10717998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10727998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (stage == MESA_SHADER_COMPUTE && 10737998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand get_cs_prog_data(cmd_buffer->state.compute_pipeline)->uses_num_work_groups) { 10747998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_bo *bo = cmd_buffer->state.num_workgroups_bo; 10757998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t bo_offset = cmd_buffer->state.num_workgroups_offset; 10767998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10777998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_state surface_state; 10787998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand surface_state = 10797998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_cmd_buffer_alloc_surface_state(cmd_buffer); 10807998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10817998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand const enum isl_format format = 10827998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_isl_format_for_descriptor_type(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER); 10837998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_fill_buffer_surface_state(cmd_buffer->device, surface_state, 10847998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand format, bo_offset, 12, 1); 10857998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10867998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand bt_map[0] = surface_state.offset + state_offset; 10879be9f5f1c71a5c8942b1f41d0512479a9899df42Jason Ekstrand add_surface_state_reloc(cmd_buffer, surface_state, bo, bo_offset); 10887998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 10897998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10907998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (map->surface_count == 0) 10917998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand goto out; 10927998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10937998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (map->image_count > 0) { 10947998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand VkResult result = 10957998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_cmd_buffer_ensure_push_constant_field(cmd_buffer, stage, images); 10967998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (result != VK_SUCCESS) 10977998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return result; 10987998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10997998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand cmd_buffer->state.push_constants_dirty |= 1 << stage; 11007998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 11017998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11027998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t image = 0; 11037998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand for (uint32_t s = 0; s < map->surface_count; s++) { 11047998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_pipeline_binding *binding = &map->surface_to_descriptor[s]; 11057998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11067998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_state surface_state; 11077998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11087998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (binding->set == ANV_DESCRIPTOR_SET_COLOR_ATTACHMENTS) { 11097998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand /* Color attachment binding */ 11107998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(stage == MESA_SHADER_FRAGMENT); 11117998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(binding->binding == 0); 11127998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (binding->index < subpass->color_count) { 1113d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand const unsigned att = subpass->color_attachments[binding->index]; 1114d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand surface_state = cmd_buffer->state.attachments[att].color_rt_state; 11157998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } else { 1116d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand surface_state = cmd_buffer->state.null_surface_state; 11177998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 11187998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11197998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand bt_map[bias + s] = surface_state.offset + state_offset; 11207998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand continue; 11217998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 11227998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11237998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_descriptor_set *set = 11247998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand cmd_buffer->state.descriptors[binding->set]; 11257998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t offset = set->layout->binding[binding->binding].descriptor_index; 11267998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_descriptor *desc = &set->descriptors[offset + binding->index]; 11277998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11287998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand switch (desc->type) { 11297998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_SAMPLER: 11307998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand /* Nothing for us to do here */ 11317998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand continue; 11327998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11337998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: 11347998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: 11357998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand surface_state = desc->image_view->sampler_surface_state; 11367998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(surface_state.alloc_size); 1137338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand add_image_view_relocs(cmd_buffer, desc->image_view, 1138edb7f67bd9c320cd47af20dc0a854e65fced7d9bJason Ekstrand desc->image_view->image->aux_usage, 1139edb7f67bd9c320cd47af20dc0a854e65fced7d9bJason Ekstrand surface_state); 11407998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 11417998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11421d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: 11431d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand assert(stage == MESA_SHADER_FRAGMENT); 11441d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand if (desc->image_view->aspect_mask == VK_IMAGE_ASPECT_STENCIL_BIT) { 11451d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand /* For stencil input attachments, we treat it like any old texture 11461d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand * that a user may have bound. 11471d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand */ 11481d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand surface_state = desc->image_view->sampler_surface_state; 11491d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand assert(surface_state.alloc_size); 11501d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand add_image_view_relocs(cmd_buffer, desc->image_view, 11511d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand desc->image_view->image->aux_usage, 11521d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand surface_state); 11531d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand } else { 11541d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand /* For depth and color input attachments, we create the surface 11551d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand * state at vkBeginRenderPass time so that we can include aux 11561d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand * and clear color information. 11571d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand */ 11581d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand assert(binding->input_attachment_index < subpass->input_count); 11591d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand const unsigned subpass_att = binding->input_attachment_index; 11601d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand const unsigned att = subpass->input_attachments[subpass_att]; 11611d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand surface_state = cmd_buffer->state.attachments[att].input_att_state; 11621d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand } 11631d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand break; 11641d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand 11657998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: { 11667998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand surface_state = desc->image_view->storage_surface_state; 11677998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(surface_state.alloc_size); 1168338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand add_image_view_relocs(cmd_buffer, desc->image_view, 1169edb7f67bd9c320cd47af20dc0a854e65fced7d9bJason Ekstrand desc->image_view->image->aux_usage, 1170edb7f67bd9c320cd47af20dc0a854e65fced7d9bJason Ekstrand surface_state); 11717998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11727998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct brw_image_param *image_param = 11737998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand &cmd_buffer->state.push_constants[stage]->images[image++]; 11747998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11757998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *image_param = desc->image_view->storage_image_param; 11767998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand image_param->surface_idx = bias + s; 11777998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 11787998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 11797998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11807998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: 11817998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: 11827998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: 11837998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: 11847998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: 11857998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand surface_state = desc->buffer_view->surface_state; 11867998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(surface_state.alloc_size); 1187818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand add_surface_state_reloc(cmd_buffer, surface_state, 1188818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand desc->buffer_view->bo, 1189818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand desc->buffer_view->offset); 11907998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 11917998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11927998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: 11937998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand surface_state = desc->buffer_view->storage_surface_state; 11947998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(surface_state.alloc_size); 1195818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand add_surface_state_reloc(cmd_buffer, surface_state, 1196818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand desc->buffer_view->bo, 1197818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand desc->buffer_view->offset); 11987998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11997998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct brw_image_param *image_param = 12007998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand &cmd_buffer->state.push_constants[stage]->images[image++]; 12017998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12027998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *image_param = desc->buffer_view->storage_image_param; 12037998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand image_param->surface_idx = bias + s; 12047998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 12057998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12067998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand default: 12077998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(!"Invalid descriptor type"); 12087998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand continue; 12097998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 12107998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12117998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand bt_map[bias + s] = surface_state.offset + state_offset; 12127998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 12137998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(image == map->image_count); 12147998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12157998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand out: 12167998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (!cmd_buffer->device->info.has_llc) 12177998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_state_clflush(*bt_state); 12187998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12197998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_SUCCESS; 12207998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand} 12217998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12227998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandstatic VkResult 12237998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandemit_samplers(struct anv_cmd_buffer *cmd_buffer, 12247998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand gl_shader_stage stage, 12257998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_state *state) 12267998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand{ 12277998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_pipeline *pipeline; 12287998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12297998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (stage == MESA_SHADER_COMPUTE) 12307998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand pipeline = cmd_buffer->state.compute_pipeline; 12317998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand else 12327998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand pipeline = cmd_buffer->state.pipeline; 12337998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12347998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (!anv_pipeline_has_stage(pipeline, stage)) { 12357998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *state = (struct anv_state) { 0, }; 12367998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_SUCCESS; 12377998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 12387998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12397998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_pipeline_bind_map *map = &pipeline->shaders[stage]->bind_map; 12407998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (map->sampler_count == 0) { 12417998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *state = (struct anv_state) { 0, }; 12427998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_SUCCESS; 12437998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 12447998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12457998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t size = map->sampler_count * 16; 12467998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *state = anv_cmd_buffer_alloc_dynamic_state(cmd_buffer, size, 32); 12477998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12487998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (state->map == NULL) 12497998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_ERROR_OUT_OF_DEVICE_MEMORY; 12507998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12517998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand for (uint32_t s = 0; s < map->sampler_count; s++) { 12527998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_pipeline_binding *binding = &map->sampler_to_descriptor[s]; 12537998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_descriptor_set *set = 12547998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand cmd_buffer->state.descriptors[binding->set]; 12557998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t offset = set->layout->binding[binding->binding].descriptor_index; 12567998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_descriptor *desc = &set->descriptors[offset + binding->index]; 12577998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12587998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (desc->type != VK_DESCRIPTOR_TYPE_SAMPLER && 12597998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand desc->type != VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) 12607998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand continue; 12617998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12627998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_sampler *sampler = desc->sampler; 12637998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12647998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand /* This can happen if we have an unfilled slot since TYPE_SAMPLER 12657998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand * happens to be zero. 12667998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand */ 12677998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (sampler == NULL) 12687998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand continue; 12697998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12707998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand memcpy(state->map + (s * 16), 12717998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand sampler->state, sizeof(sampler->state)); 12727998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 12737998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12747998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (!cmd_buffer->device->info.has_llc) 12757998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_state_clflush(*state); 12767998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12777998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_SUCCESS; 12787998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand} 12797998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12807998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandstatic uint32_t 12817998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandflush_descriptor_sets(struct anv_cmd_buffer *cmd_buffer) 12827998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand{ 12837998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand VkShaderStageFlags dirty = cmd_buffer->state.descriptors_dirty & 12847998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand cmd_buffer->state.pipeline->active_stages; 12857998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12867998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand VkResult result = VK_SUCCESS; 12877998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_foreach_stage(s, dirty) { 12887998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand result = emit_samplers(cmd_buffer, s, &cmd_buffer->state.samplers[s]); 12897998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (result != VK_SUCCESS) 12907998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 12917998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand result = emit_binding_table(cmd_buffer, s, 12927998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand &cmd_buffer->state.binding_tables[s]); 12937998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (result != VK_SUCCESS) 12947998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 12957998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 12967998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12977998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (result != VK_SUCCESS) { 12987998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(result == VK_ERROR_OUT_OF_DEVICE_MEMORY); 12997998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13007998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand result = anv_cmd_buffer_new_binding_table_block(cmd_buffer); 13017998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(result == VK_SUCCESS); 13027998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13037998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand /* Re-emit state base addresses so we get the new surface state base 13047998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand * address before we start emitting binding tables etc. 13057998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand */ 13067998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand genX(cmd_buffer_emit_state_base_address)(cmd_buffer); 13077998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13087998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand /* Re-emit all active binding tables */ 13097998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand dirty |= cmd_buffer->state.pipeline->active_stages; 13107998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_foreach_stage(s, dirty) { 13117998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand result = emit_samplers(cmd_buffer, s, &cmd_buffer->state.samplers[s]); 13127998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (result != VK_SUCCESS) 13137998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return result; 13147998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand result = emit_binding_table(cmd_buffer, s, 13157998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand &cmd_buffer->state.binding_tables[s]); 13167998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (result != VK_SUCCESS) 13177998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return result; 13187998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 13197998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 13207998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13217998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand cmd_buffer->state.descriptors_dirty &= ~dirty; 13227998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13237998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return dirty; 13247998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand} 13257998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 13267998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandstatic void 13272bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrandcmd_buffer_emit_descriptor_pointers(struct anv_cmd_buffer *cmd_buffer, 13282bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand uint32_t stages) 13292bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand{ 13302bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand static const uint32_t sampler_state_opcodes[] = { 13312bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_VERTEX] = 43, 13322bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_TESS_CTRL] = 44, /* HS */ 13332bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_TESS_EVAL] = 45, /* DS */ 13342bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_GEOMETRY] = 46, 13352bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_FRAGMENT] = 47, 13362bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_COMPUTE] = 0, 13372bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand }; 13382bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand 13392bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand static const uint32_t binding_table_opcodes[] = { 13402bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_VERTEX] = 38, 13412bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_TESS_CTRL] = 39, 13422bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_TESS_EVAL] = 40, 13432bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_GEOMETRY] = 41, 13442bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_FRAGMENT] = 42, 13452bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_COMPUTE] = 0, 13462bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand }; 13472bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand 13482bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand anv_foreach_stage(s, stages) { 13492bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand if (cmd_buffer->state.samplers[s].alloc_size > 0) { 13502bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand anv_batch_emit(&cmd_buffer->batch, 13512bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand GENX(3DSTATE_SAMPLER_STATE_POINTERS_VS), ssp) { 13522bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand ssp._3DCommandSubOpcode = sampler_state_opcodes[s]; 13532bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand ssp.PointertoVSSamplerState = cmd_buffer->state.samplers[s].offset; 13542bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand } 13552bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand } 13562bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand 13572bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand /* Always emit binding table pointers if we're asked to, since on SKL 13582bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand * this is what flushes push constants. */ 13592bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand anv_batch_emit(&cmd_buffer->batch, 13602bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand GENX(3DSTATE_BINDING_TABLE_POINTERS_VS), btp) { 13612bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand btp._3DCommandSubOpcode = binding_table_opcodes[s]; 13622bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand btp.PointertoVSBindingTable = cmd_buffer->state.binding_tables[s].offset; 13632bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand } 13642bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand } 13652bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand} 13662bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand 1367248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrandstatic uint32_t 1368248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrandcmd_buffer_flush_push_constants(struct anv_cmd_buffer *cmd_buffer) 1369248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand{ 1370248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand static const uint32_t push_constant_opcodes[] = { 1371248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand [MESA_SHADER_VERTEX] = 21, 1372248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand [MESA_SHADER_TESS_CTRL] = 25, /* HS */ 1373248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand [MESA_SHADER_TESS_EVAL] = 26, /* DS */ 1374248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand [MESA_SHADER_GEOMETRY] = 22, 1375248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand [MESA_SHADER_FRAGMENT] = 23, 1376248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand [MESA_SHADER_COMPUTE] = 0, 1377248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand }; 1378248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1379248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand VkShaderStageFlags flushed = 0; 1380248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1381248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand anv_foreach_stage(stage, cmd_buffer->state.push_constants_dirty) { 1382248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (stage == MESA_SHADER_COMPUTE) 1383248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand continue; 1384248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1385248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand struct anv_state state = anv_cmd_buffer_push_constants(cmd_buffer, stage); 1386248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1387248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (state.offset == 0) { 138850018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_CONSTANT_VS), c) 138906fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand c._3DCommandSubOpcode = push_constant_opcodes[stage]; 1390248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } else { 139150018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_CONSTANT_VS), c) { 139206fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand c._3DCommandSubOpcode = push_constant_opcodes[stage], 139306fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand c.ConstantBody = (struct GENX(3DSTATE_CONSTANT_BODY)) { 1394248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#if GEN_GEN >= 9 139506fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand .PointerToConstantBuffer2 = { &cmd_buffer->device->dynamic_state_block_pool.bo, state.offset }, 139606fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand .ConstantBuffer2ReadLength = DIV_ROUND_UP(state.alloc_size, 32), 1397248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#else 139806fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand .PointerToConstantBuffer0 = { .offset = state.offset }, 139906fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand .ConstantBuffer0ReadLength = DIV_ROUND_UP(state.alloc_size, 32), 1400248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#endif 140106fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand }; 140206fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand } 1403248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1404248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1405248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand flushed |= mesa_to_vk_shader_stage(stage); 1406248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1407248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1408248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand cmd_buffer->state.push_constants_dirty &= ~VK_SHADER_STAGE_ALL_GRAPHICS; 1409248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1410248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand return flushed; 1411248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand} 1412248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1413248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrandvoid 1414248ab61740c4082517424f5aa94b2f4e7b210d76Jason EkstrandgenX(cmd_buffer_flush_state)(struct anv_cmd_buffer *cmd_buffer) 1415248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand{ 1416248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand struct anv_pipeline *pipeline = cmd_buffer->state.pipeline; 1417248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand uint32_t *p; 1418248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1419248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand uint32_t vb_emit = cmd_buffer->state.vb_dirty & pipeline->vb_used; 1420248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1421248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand assert((pipeline->active_stages & VK_SHADER_STAGE_COMPUTE_BIT) == 0); 1422248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 14237e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand genX(cmd_buffer_config_l3)(cmd_buffer, pipeline->urb.l3_config); 1424248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1425248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand genX(flush_pipeline_select_3d)(cmd_buffer); 1426248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1427248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (vb_emit) { 1428248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand const uint32_t num_buffers = __builtin_popcount(vb_emit); 1429248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand const uint32_t num_dwords = 1 + num_buffers * 4; 1430248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1431248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand p = anv_batch_emitn(&cmd_buffer->batch, num_dwords, 1432248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand GENX(3DSTATE_VERTEX_BUFFERS)); 1433248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand uint32_t vb, i = 0; 1434248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand for_each_bit(vb, vb_emit) { 1435248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand struct anv_buffer *buffer = cmd_buffer->state.vertex_bindings[vb].buffer; 1436248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand uint32_t offset = cmd_buffer->state.vertex_bindings[vb].offset; 1437248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1438248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand struct GENX(VERTEX_BUFFER_STATE) state = { 1439248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .VertexBufferIndex = vb, 1440248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1441248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#if GEN_GEN >= 8 1442248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .MemoryObjectControlState = GENX(MOCS), 1443248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#else 1444248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .BufferAccessType = pipeline->instancing_enable[vb] ? INSTANCEDATA : VERTEXDATA, 1445248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .InstanceDataStepRate = 1, 1446248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .VertexBufferMemoryObjectControlState = GENX(MOCS), 1447248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#endif 1448248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1449248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .AddressModifyEnable = true, 1450248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .BufferPitch = pipeline->binding_stride[vb], 1451248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .BufferStartingAddress = { buffer->bo, buffer->offset + offset }, 1452248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1453248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#if GEN_GEN >= 8 1454248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .BufferSize = buffer->size - offset 1455248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#else 1456248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .EndAddress = { buffer->bo, buffer->offset + buffer->size - 1}, 1457248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#endif 1458248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand }; 1459248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1460248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand GENX(VERTEX_BUFFER_STATE_pack)(&cmd_buffer->batch, &p[1 + i * 4], &state); 1461248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand i++; 1462248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1463248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1464248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1465248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand cmd_buffer->state.vb_dirty &= ~vb_emit; 1466248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1467248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (cmd_buffer->state.dirty & ANV_CMD_DIRTY_PIPELINE) { 1468248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand anv_batch_emit_batch(&cmd_buffer->batch, &pipeline->batch); 1469248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 147035b53c8d47d3a0b53ee2549d73296d5db8e3cca0Jason Ekstrand /* The exact descriptor layout is pulled from the pipeline, so we need 147135b53c8d47d3a0b53ee2549d73296d5db8e3cca0Jason Ekstrand * to re-emit binding tables on every pipeline change. 147235b53c8d47d3a0b53ee2549d73296d5db8e3cca0Jason Ekstrand */ 147335b53c8d47d3a0b53ee2549d73296d5db8e3cca0Jason Ekstrand cmd_buffer->state.descriptors_dirty |= 147435b53c8d47d3a0b53ee2549d73296d5db8e3cca0Jason Ekstrand cmd_buffer->state.pipeline->active_stages; 147535b53c8d47d3a0b53ee2549d73296d5db8e3cca0Jason Ekstrand 147654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand /* If the pipeline changed, we may need to re-allocate push constant 147754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * space in the URB. 1478248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand */ 147954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand cmd_buffer_alloc_push_constants(cmd_buffer); 1480248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1481248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1482248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#if GEN_GEN <= 7 1483248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (cmd_buffer->state.descriptors_dirty & VK_SHADER_STAGE_VERTEX_BIT || 1484248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand cmd_buffer->state.push_constants_dirty & VK_SHADER_STAGE_VERTEX_BIT) { 1485248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand /* From the IVB PRM Vol. 2, Part 1, Section 3.2.1: 1486248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * 1487248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * "A PIPE_CONTROL with Post-Sync Operation set to 1h and a depth 1488248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * stall needs to be sent just prior to any 3DSTATE_VS, 1489248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * 3DSTATE_URB_VS, 3DSTATE_CONSTANT_VS, 1490248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * 3DSTATE_BINDING_TABLE_POINTER_VS, 1491248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * 3DSTATE_SAMPLER_STATE_POINTER_VS command. Only one 1492248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * PIPE_CONTROL needs to be sent before any combination of VS 1493248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * associated 3DSTATE." 1494248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand */ 149550018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 149656453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DepthStallEnable = true; 149756453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.PostSyncOperation = WriteImmediateData; 149856453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.Address = 149956453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand (struct anv_address) { &cmd_buffer->device->workaround_bo, 0 }; 150056453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 1501248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1502248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#endif 1503248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1504fe4e276b02615b5db8acbf4c65fcfa68982e2e0fJason Ekstrand /* Render targets live in the same binding table as fragment descriptors */ 1505fe4e276b02615b5db8acbf4c65fcfa68982e2e0fJason Ekstrand if (cmd_buffer->state.dirty & ANV_CMD_DIRTY_RENDER_TARGETS) 1506fe4e276b02615b5db8acbf4c65fcfa68982e2e0fJason Ekstrand cmd_buffer->state.descriptors_dirty |= VK_SHADER_STAGE_FRAGMENT_BIT; 1507fe4e276b02615b5db8acbf4c65fcfa68982e2e0fJason Ekstrand 1508248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand /* We emit the binding tables and sampler tables first, then emit push 1509248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * constants and then finally emit binding table and sampler table 1510248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * pointers. It has to happen in this order, since emitting the binding 1511248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * tables may change the push constants (in case of storage images). After 1512248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * emitting push constants, on SKL+ we have to emit the corresponding 1513248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * 3DSTATE_BINDING_TABLE_POINTER_* for the push constants to take effect. 1514248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand */ 1515248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand uint32_t dirty = 0; 1516248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (cmd_buffer->state.descriptors_dirty) 15177998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand dirty = flush_descriptor_sets(cmd_buffer); 1518248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1519248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (cmd_buffer->state.push_constants_dirty) { 1520248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#if GEN_GEN >= 9 1521248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand /* On Sky Lake and later, the binding table pointers commands are 1522248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * what actually flush the changes to push constant state so we need 1523248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * to dirty them so they get re-emitted below. 1524248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand */ 1525248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand dirty |= cmd_buffer_flush_push_constants(cmd_buffer); 1526248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#else 1527248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand cmd_buffer_flush_push_constants(cmd_buffer); 1528248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#endif 1529248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1530248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1531248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (dirty) 15322bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand cmd_buffer_emit_descriptor_pointers(cmd_buffer, dirty); 1533248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1534eb6764c4a73006eee32e19e3afc6eab100a2ce16Jason Ekstrand if (cmd_buffer->state.dirty & ANV_CMD_DIRTY_DYNAMIC_VIEWPORT) 1535248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand gen8_cmd_buffer_emit_viewport(cmd_buffer); 1536eb6764c4a73006eee32e19e3afc6eab100a2ce16Jason Ekstrand 1537eb6764c4a73006eee32e19e3afc6eab100a2ce16Jason Ekstrand if (cmd_buffer->state.dirty & (ANV_CMD_DIRTY_DYNAMIC_VIEWPORT | 1538eb6764c4a73006eee32e19e3afc6eab100a2ce16Jason Ekstrand ANV_CMD_DIRTY_PIPELINE)) { 1539eb6764c4a73006eee32e19e3afc6eab100a2ce16Jason Ekstrand gen8_cmd_buffer_emit_depth_viewport(cmd_buffer, 1540eb6764c4a73006eee32e19e3afc6eab100a2ce16Jason Ekstrand pipeline->depth_clamp_enable); 15418a46b505cb2c7255ad430b56c1ce0dfa9c13c559Jason Ekstrand } 1542248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1543248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (cmd_buffer->state.dirty & ANV_CMD_DIRTY_DYNAMIC_SCISSOR) 1544248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand gen7_cmd_buffer_emit_scissor(cmd_buffer); 1545248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1546248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand genX(cmd_buffer_flush_dynamic_state)(cmd_buffer); 15473a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 15483a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand genX(cmd_buffer_apply_pipe_flushes)(cmd_buffer); 1549248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand} 1550248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1551bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergstatic void 1552bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergemit_base_vertex_instance_bo(struct anv_cmd_buffer *cmd_buffer, 1553bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_bo *bo, uint32_t offset) 1554bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg{ 1555bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t *p = anv_batch_emitn(&cmd_buffer->batch, 5, 1556bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg GENX(3DSTATE_VERTEX_BUFFERS)); 1557bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1558bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg GENX(VERTEX_BUFFER_STATE_pack)(&cmd_buffer->batch, p + 1, 1559bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg &(struct GENX(VERTEX_BUFFER_STATE)) { 1560bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .VertexBufferIndex = 32, /* Reserved for this */ 1561bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .AddressModifyEnable = true, 1562bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .BufferPitch = 0, 1563371b4a5b33a13f35fa7783510d2d90685a9a2e8aJason Ekstrand#if (GEN_GEN >= 8) 1564bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .MemoryObjectControlState = GENX(MOCS), 1565bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .BufferStartingAddress = { bo, offset }, 1566bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .BufferSize = 8 1567bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#else 1568bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .VertexBufferMemoryObjectControlState = GENX(MOCS), 1569bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .BufferStartingAddress = { bo, offset }, 1570bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .EndAddress = { bo, offset + 8 }, 1571bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#endif 1572bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg }); 1573bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg} 1574bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1575bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergstatic void 1576bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergemit_base_vertex_instance(struct anv_cmd_buffer *cmd_buffer, 1577bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t base_vertex, uint32_t base_instance) 1578bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg{ 1579bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_state id_state = 1580bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg anv_cmd_buffer_alloc_dynamic_state(cmd_buffer, 8, 4); 1581bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1582bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ((uint32_t *)id_state.map)[0] = base_vertex; 1583bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ((uint32_t *)id_state.map)[1] = base_instance; 1584bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1585bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg if (!cmd_buffer->device->info.has_llc) 1586bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg anv_state_clflush(id_state); 1587bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1588bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_base_vertex_instance_bo(cmd_buffer, 1589bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg &cmd_buffer->device->dynamic_state_block_pool.bo, id_state.offset); 1590bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg} 1591bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1592bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergvoid genX(CmdDraw)( 1593bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkCommandBuffer commandBuffer, 1594bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t vertexCount, 1595bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t instanceCount, 1596bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t firstVertex, 1597bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t firstInstance) 1598bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg{ 1599bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 1600bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_pipeline *pipeline = cmd_buffer->state.pipeline; 16012b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg const struct brw_vs_prog_data *vs_prog_data = get_vs_prog_data(pipeline); 1602bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1603bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg genX(cmd_buffer_flush_state)(cmd_buffer); 1604bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 16052b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg if (vs_prog_data->uses_basevertex || vs_prog_data->uses_baseinstance) 1606bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_base_vertex_instance(cmd_buffer, firstVertex, firstInstance); 1607bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 160850018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DPRIMITIVE), prim) { 16091d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.VertexAccessType = SEQUENTIAL; 16101d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.PrimitiveTopologyType = pipeline->topology; 16111d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.VertexCountPerInstance = vertexCount; 16121d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.StartVertexLocation = firstVertex; 16131d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.InstanceCount = instanceCount; 16141d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.StartInstanceLocation = firstInstance; 16151d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.BaseVertexLocation = 0; 16161d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand } 1617bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg} 1618bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1619bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergvoid genX(CmdDrawIndexed)( 1620bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkCommandBuffer commandBuffer, 1621bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t indexCount, 1622bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t instanceCount, 1623bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t firstIndex, 1624bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg int32_t vertexOffset, 1625bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t firstInstance) 1626bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg{ 1627bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 1628bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_pipeline *pipeline = cmd_buffer->state.pipeline; 16292b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg const struct brw_vs_prog_data *vs_prog_data = get_vs_prog_data(pipeline); 1630bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1631bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg genX(cmd_buffer_flush_state)(cmd_buffer); 1632bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 16332b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg if (vs_prog_data->uses_basevertex || vs_prog_data->uses_baseinstance) 1634bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_base_vertex_instance(cmd_buffer, vertexOffset, firstInstance); 1635bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 163650018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DPRIMITIVE), prim) { 16371d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.VertexAccessType = RANDOM; 16381d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.PrimitiveTopologyType = pipeline->topology; 16391d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.VertexCountPerInstance = indexCount; 16401d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.StartVertexLocation = firstIndex; 16411d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.InstanceCount = instanceCount; 16421d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.StartInstanceLocation = firstInstance; 16431d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.BaseVertexLocation = vertexOffset; 16441d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand } 1645bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg} 1646bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1647bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg/* Auto-Draw / Indirect Registers */ 1648bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#define GEN7_3DPRIM_END_OFFSET 0x2420 1649bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#define GEN7_3DPRIM_START_VERTEX 0x2430 1650bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#define GEN7_3DPRIM_VERTEX_COUNT 0x2434 1651bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#define GEN7_3DPRIM_INSTANCE_COUNT 0x2438 1652bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#define GEN7_3DPRIM_START_INSTANCE 0x243C 1653bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#define GEN7_3DPRIM_BASE_VERTEX 0x2440 1654bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1655bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergvoid genX(CmdDrawIndirect)( 1656bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkCommandBuffer commandBuffer, 1657bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkBuffer _buffer, 1658bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkDeviceSize offset, 1659bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t drawCount, 1660bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t stride) 1661bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg{ 1662bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 1663bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ANV_FROM_HANDLE(anv_buffer, buffer, _buffer); 1664bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_pipeline *pipeline = cmd_buffer->state.pipeline; 16652b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg const struct brw_vs_prog_data *vs_prog_data = get_vs_prog_data(pipeline); 1666bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_bo *bo = buffer->bo; 1667bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t bo_offset = buffer->offset + offset; 1668bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1669bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg genX(cmd_buffer_flush_state)(cmd_buffer); 1670bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 16712b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg if (vs_prog_data->uses_basevertex || vs_prog_data->uses_baseinstance) 1672bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_base_vertex_instance_bo(cmd_buffer, bo, bo_offset + 8); 1673bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1674bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_VERTEX_COUNT, bo, bo_offset); 1675bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_INSTANCE_COUNT, bo, bo_offset + 4); 1676bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_START_VERTEX, bo, bo_offset + 8); 1677bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_START_INSTANCE, bo, bo_offset + 12); 1678bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lri(&cmd_buffer->batch, GEN7_3DPRIM_BASE_VERTEX, 0); 1679bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 168050018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DPRIMITIVE), prim) { 16811d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.IndirectParameterEnable = true; 16821d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.VertexAccessType = SEQUENTIAL; 16831d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.PrimitiveTopologyType = pipeline->topology; 16841d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand } 1685bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg} 1686bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1687bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergvoid genX(CmdDrawIndexedIndirect)( 1688bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkCommandBuffer commandBuffer, 1689bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkBuffer _buffer, 1690bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkDeviceSize offset, 1691bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t drawCount, 1692bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t stride) 1693bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg{ 1694bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 1695bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ANV_FROM_HANDLE(anv_buffer, buffer, _buffer); 1696bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_pipeline *pipeline = cmd_buffer->state.pipeline; 16972b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg const struct brw_vs_prog_data *vs_prog_data = get_vs_prog_data(pipeline); 1698bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_bo *bo = buffer->bo; 1699bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t bo_offset = buffer->offset + offset; 1700bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1701bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg genX(cmd_buffer_flush_state)(cmd_buffer); 1702bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1703bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg /* TODO: We need to stomp base vertex to 0 somehow */ 17042b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg if (vs_prog_data->uses_basevertex || vs_prog_data->uses_baseinstance) 1705bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_base_vertex_instance_bo(cmd_buffer, bo, bo_offset + 12); 1706bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1707bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_VERTEX_COUNT, bo, bo_offset); 1708bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_INSTANCE_COUNT, bo, bo_offset + 4); 1709bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_START_VERTEX, bo, bo_offset + 8); 1710bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_BASE_VERTEX, bo, bo_offset + 12); 1711bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_START_INSTANCE, bo, bo_offset + 16); 1712bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 171350018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DPRIMITIVE), prim) { 17141d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.IndirectParameterEnable = true; 17151d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.VertexAccessType = RANDOM; 17161d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.PrimitiveTopologyType = pipeline->topology; 17171d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand } 1718bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg} 17196c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 17201f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrandstatic VkResult 17211f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrandflush_compute_descriptor_set(struct anv_cmd_buffer *cmd_buffer) 17221f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand{ 17231f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand struct anv_pipeline *pipeline = cmd_buffer->state.compute_pipeline; 17241f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand struct anv_state surfaces = { 0, }, samplers = { 0, }; 17251f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand VkResult result; 17261f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 17277998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand result = emit_binding_table(cmd_buffer, MESA_SHADER_COMPUTE, &surfaces); 1728722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand if (result != VK_SUCCESS) { 17293ef8dff865fd7365ba36b49c43b5c858d26587edJason Ekstrand assert(result == VK_ERROR_OUT_OF_DEVICE_MEMORY); 1730722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand result = anv_cmd_buffer_new_binding_table_block(cmd_buffer); 1731722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand assert(result == VK_SUCCESS); 1732722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand 1733722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand /* Re-emit state base addresses so we get the new surface state base 1734722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand * address before we start emitting binding tables etc. 1735722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand */ 1736722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand genX(cmd_buffer_emit_state_base_address)(cmd_buffer); 1737722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand 1738722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand result = emit_binding_table(cmd_buffer, MESA_SHADER_COMPUTE, &surfaces); 1739722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand assert(result == VK_SUCCESS); 1740722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand } 1741054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand 1742722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand result = emit_samplers(cmd_buffer, MESA_SHADER_COMPUTE, &samplers); 1743722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand assert(result == VK_SUCCESS); 1744722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand 1745d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand uint32_t iface_desc_data_dw[GENX(INTERFACE_DESCRIPTOR_DATA_length)]; 1746d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand struct GENX(INTERFACE_DESCRIPTOR_DATA) desc = { 1747d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand .BindingTablePointer = surfaces.offset, 1748d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand .SamplerStatePointer = samplers.offset, 1749d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand }; 1750d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand GENX(INTERFACE_DESCRIPTOR_DATA_pack)(NULL, iface_desc_data_dw, &desc); 17511f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 17521f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand struct anv_state state = 1753d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand anv_cmd_buffer_merge_dynamic(cmd_buffer, iface_desc_data_dw, 1754d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand pipeline->interface_descriptor_data, 1755d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand GENX(INTERFACE_DESCRIPTOR_DATA_length), 1756d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand 64); 17571f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 17581f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand uint32_t size = GENX(INTERFACE_DESCRIPTOR_DATA_length) * sizeof(uint32_t); 17591f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, 17601f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand GENX(MEDIA_INTERFACE_DESCRIPTOR_LOAD), mid) { 17611f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand mid.InterfaceDescriptorTotalLength = size; 17621f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand mid.InterfaceDescriptorDataStartAddress = state.offset; 17631f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand } 17641f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 17651f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand return VK_SUCCESS; 17661f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand} 17671f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 17681f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrandvoid 17691f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason EkstrandgenX(cmd_buffer_flush_compute_state)(struct anv_cmd_buffer *cmd_buffer) 17701f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand{ 17711f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand struct anv_pipeline *pipeline = cmd_buffer->state.compute_pipeline; 17721f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand MAYBE_UNUSED VkResult result; 17731f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 17741f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand assert(pipeline->active_stages == VK_SHADER_STAGE_COMPUTE_BIT); 17751f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 17761f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand genX(cmd_buffer_config_l3)(cmd_buffer, pipeline->urb.l3_config); 17771f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 17781f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand genX(flush_pipeline_select_gpgpu)(cmd_buffer); 17791f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 1780f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand if (cmd_buffer->state.compute_dirty & ANV_CMD_DIRTY_PIPELINE) { 1781f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand /* From the Sky Lake PRM Vol 2a, MEDIA_VFE_STATE: 1782f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand * 1783f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand * "A stalling PIPE_CONTROL is required before MEDIA_VFE_STATE unless 1784f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand * the only bits that are changed are scoreboard related: Scoreboard 1785f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand * Enable, Scoreboard Type, Scoreboard Mask, Scoreboard * Delta. For 1786f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand * these scoreboard related states, a MEDIA_STATE_FLUSH is 1787f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand * sufficient." 1788f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand */ 1789f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand cmd_buffer->state.pending_pipe_bits |= ANV_PIPE_CS_STALL_BIT; 1790f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand genX(cmd_buffer_apply_pipe_flushes)(cmd_buffer); 1791f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand 17921f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand anv_batch_emit_batch(&cmd_buffer->batch, &pipeline->batch); 1793f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand } 17941f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 17957a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand if ((cmd_buffer->state.descriptors_dirty & VK_SHADER_STAGE_COMPUTE_BIT) || 17967a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand (cmd_buffer->state.compute_dirty & ANV_CMD_DIRTY_PIPELINE)) { 17977a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand /* FIXME: figure out descriptors for gen7 */ 17987a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand result = flush_compute_descriptor_set(cmd_buffer); 17997a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand assert(result == VK_SUCCESS); 18007a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand cmd_buffer->state.descriptors_dirty &= ~VK_SHADER_STAGE_COMPUTE_BIT; 18017a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand } 18027a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand 1803054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand if (cmd_buffer->state.push_constants_dirty & VK_SHADER_STAGE_COMPUTE_BIT) { 1804054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand struct anv_state push_state = 1805054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand anv_cmd_buffer_cs_push_constants(cmd_buffer); 1806054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand 1807054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand if (push_state.alloc_size) { 1808054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(MEDIA_CURBE_LOAD), curbe) { 1809054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand curbe.CURBETotalDataLength = push_state.alloc_size; 1810054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand curbe.CURBEDataStartAddress = push_state.offset; 1811054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand } 1812054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand } 1813054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand } 1814054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand 18151f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand cmd_buffer->state.compute_dirty = 0; 18161f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 18171f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand genX(cmd_buffer_apply_pipe_flushes)(cmd_buffer); 18181f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand} 18191f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 18208dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen#if GEN_GEN == 7 18218dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen 18228dbfa265a439904628c2d875885e80bc45a90a05Jordan Justenstatic bool 18238dbfa265a439904628c2d875885e80bc45a90a05Jordan Justenverify_cmd_parser(const struct anv_device *device, 18248dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen int required_version, 18258dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen const char *function) 18268dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen{ 18278dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen if (device->instance->physicalDevice.cmd_parser_version < required_version) { 18288dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen vk_errorf(VK_ERROR_FEATURE_NOT_PRESENT, 18298dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen "cmd parser version %d is required for %s", 18308dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen required_version, function); 18318dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen return false; 18328dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen } else { 18338dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen return true; 18348dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen } 18358dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen} 18368dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen 18378dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen#endif 18386c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 18396c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsbergvoid genX(CmdDispatch)( 18406c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg VkCommandBuffer commandBuffer, 18416c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg uint32_t x, 18426c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg uint32_t y, 18436c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg uint32_t z) 18446c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg{ 18456c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 18466c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg struct anv_pipeline *pipeline = cmd_buffer->state.compute_pipeline; 18472b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg const struct brw_cs_prog_data *prog_data = get_cs_prog_data(pipeline); 18486c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 18496c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg if (prog_data->uses_num_work_groups) { 18506c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg struct anv_state state = 18516c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg anv_cmd_buffer_alloc_dynamic_state(cmd_buffer, 12, 4); 18526c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg uint32_t *sizes = state.map; 18536c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg sizes[0] = x; 18546c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg sizes[1] = y; 18556c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg sizes[2] = z; 18566c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg if (!cmd_buffer->device->info.has_llc) 18576c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg anv_state_clflush(state); 18586c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg cmd_buffer->state.num_workgroups_offset = state.offset; 18596c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg cmd_buffer->state.num_workgroups_bo = 18606c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg &cmd_buffer->device->dynamic_state_block_pool.bo; 18616c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg } 18626c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 18636c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg genX(cmd_buffer_flush_compute_state)(cmd_buffer); 18646c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 186550018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(GPGPU_WALKER), ggw) { 1866deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.SIMDSize = prog_data->simd_size / 16; 1867deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadDepthCounterMaximum = 0; 1868deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadHeightCounterMaximum = 0; 18691b79e7ebbd77a7e714fafadd91459059aacf2407Jordan Justen ggw.ThreadWidthCounterMaximum = prog_data->threads - 1; 1870deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadGroupIDXDimension = x; 1871deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadGroupIDYDimension = y; 1872deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadGroupIDZDimension = z; 1873deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.RightExecutionMask = pipeline->cs_right_mask; 1874deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.BottomExecutionMask = 0xffffffff; 1875deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 1876deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand 187750018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(MEDIA_STATE_FLUSH), msf); 18786c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg} 18796c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 18806c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg#define GPGPU_DISPATCHDIMX 0x2500 18816c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg#define GPGPU_DISPATCHDIMY 0x2504 18826c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg#define GPGPU_DISPATCHDIMZ 0x2508 18836c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 188498cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen#define MI_PREDICATE_SRC0 0x2400 188598cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen#define MI_PREDICATE_SRC1 0x2408 188698cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 18876c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsbergvoid genX(CmdDispatchIndirect)( 18886c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg VkCommandBuffer commandBuffer, 18896c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg VkBuffer _buffer, 18906c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg VkDeviceSize offset) 18916c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg{ 18926c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 18936c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg ANV_FROM_HANDLE(anv_buffer, buffer, _buffer); 18946c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg struct anv_pipeline *pipeline = cmd_buffer->state.compute_pipeline; 18952b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg const struct brw_cs_prog_data *prog_data = get_cs_prog_data(pipeline); 18966c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg struct anv_bo *bo = buffer->bo; 18976c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg uint32_t bo_offset = buffer->offset + offset; 1898da4745104cc02fc0052a2e05e37c69a4dce76eefJordan Justen struct anv_batch *batch = &cmd_buffer->batch; 18996c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 19008dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen#if GEN_GEN == 7 19018dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen /* Linux 4.4 added command parser version 5 which allows the GPGPU 19028dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen * indirect dispatch registers to be written. 19038dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen */ 1904f56f538ce4753a6fdd969b610f35433fd657e4eeJordan Justen if (!verify_cmd_parser(cmd_buffer->device, 5, "vkCmdDispatchIndirect")) 19058dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen return; 19068dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen#endif 19078dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen 19086c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg if (prog_data->uses_num_work_groups) { 19096c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg cmd_buffer->state.num_workgroups_offset = bo_offset; 19106c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg cmd_buffer->state.num_workgroups_bo = bo; 19116c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg } 19126c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 19136c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg genX(cmd_buffer_flush_compute_state)(cmd_buffer); 19146c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 1915da4745104cc02fc0052a2e05e37c69a4dce76eefJordan Justen emit_lrm(batch, GPGPU_DISPATCHDIMX, bo, bo_offset); 1916da4745104cc02fc0052a2e05e37c69a4dce76eefJordan Justen emit_lrm(batch, GPGPU_DISPATCHDIMY, bo, bo_offset + 4); 1917da4745104cc02fc0052a2e05e37c69a4dce76eefJordan Justen emit_lrm(batch, GPGPU_DISPATCHDIMZ, bo, bo_offset + 8); 19186c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 191998cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen#if GEN_GEN <= 7 192098cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* Clear upper 32-bits of SRC0 and all 64-bits of SRC1 */ 192198cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen emit_lri(batch, MI_PREDICATE_SRC0 + 4, 0); 192298cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen emit_lri(batch, MI_PREDICATE_SRC1 + 0, 0); 192398cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen emit_lri(batch, MI_PREDICATE_SRC1 + 4, 0); 192498cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 192598cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* Load compute_dispatch_indirect_x_size into SRC0 */ 192698cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen emit_lrm(batch, MI_PREDICATE_SRC0, bo, bo_offset + 0); 192798cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 192898cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* predicate = (compute_dispatch_indirect_x_size == 0); */ 192950018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_PREDICATE), mip) { 1930deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.LoadOperation = LOAD_LOAD; 1931deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CombineOperation = COMBINE_SET; 1932deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CompareOperation = COMPARE_SRCS_EQUAL; 1933deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 193498cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 193598cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* Load compute_dispatch_indirect_y_size into SRC0 */ 193698cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen emit_lrm(batch, MI_PREDICATE_SRC0, bo, bo_offset + 4); 193798cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 193898cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* predicate |= (compute_dispatch_indirect_y_size == 0); */ 193950018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_PREDICATE), mip) { 1940deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.LoadOperation = LOAD_LOAD; 1941deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CombineOperation = COMBINE_OR; 1942deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CompareOperation = COMPARE_SRCS_EQUAL; 1943deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 194498cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 194598cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* Load compute_dispatch_indirect_z_size into SRC0 */ 194698cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen emit_lrm(batch, MI_PREDICATE_SRC0, bo, bo_offset + 8); 194798cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 194898cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* predicate |= (compute_dispatch_indirect_z_size == 0); */ 194950018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_PREDICATE), mip) { 1950deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.LoadOperation = LOAD_LOAD; 1951deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CombineOperation = COMBINE_OR; 1952deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CompareOperation = COMPARE_SRCS_EQUAL; 1953deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 195498cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 195598cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* predicate = !predicate; */ 195698cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen#define COMPARE_FALSE 1 195750018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_PREDICATE), mip) { 1958deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.LoadOperation = LOAD_LOADINV; 1959deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CombineOperation = COMBINE_OR; 1960deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CompareOperation = COMPARE_FALSE; 1961deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 196298cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen#endif 196398cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 196450018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(GPGPU_WALKER), ggw) { 1965deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.IndirectParameterEnable = true; 1966deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.PredicateEnable = GEN_GEN <= 7; 1967deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.SIMDSize = prog_data->simd_size / 16; 1968deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadDepthCounterMaximum = 0; 1969deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadHeightCounterMaximum = 0; 19701b79e7ebbd77a7e714fafadd91459059aacf2407Jordan Justen ggw.ThreadWidthCounterMaximum = prog_data->threads - 1; 1971deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.RightExecutionMask = pipeline->cs_right_mask; 1972deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.BottomExecutionMask = 0xffffffff; 1973deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 1974deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand 197550018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MEDIA_STATE_FLUSH), msf); 19766c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg} 1977832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg 1978c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justenstatic void 1979c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justenflush_pipeline_before_pipeline_select(struct anv_cmd_buffer *cmd_buffer, 1980c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen uint32_t pipeline) 1981c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen{ 1982c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen#if GEN_GEN >= 8 && GEN_GEN < 10 1983c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen /* From the Broadwell PRM, Volume 2a: Instructions, PIPELINE_SELECT: 1984c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * 1985c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * Software must clear the COLOR_CALC_STATE Valid field in 1986c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * 3DSTATE_CC_STATE_POINTERS command prior to send a PIPELINE_SELECT 1987c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * with Pipeline Select set to GPGPU. 1988c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * 1989c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * The internal hardware docs recommend the same workaround for Gen9 1990c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * hardware too. 1991c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen */ 1992c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen if (pipeline == GPGPU) 199350018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_CC_STATE_POINTERS), t); 1994b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen#elif GEN_GEN <= 7 1995b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen /* From "BXML » GT » MI » vol1a GPU Overview » [Instruction] 1996b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen * PIPELINE_SELECT [DevBWR+]": 1997b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen * 1998b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen * Project: DEVSNB+ 1999b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen * 2000b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen * Software must ensure all the write caches are flushed through a 2001b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen * stalling PIPE_CONTROL command followed by another PIPE_CONTROL 2002b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen * command to invalidate read only caches prior to programming 2003b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen * MI_PIPELINE_SELECT command to change the Pipeline Select Mode. 2004b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen */ 200550018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 200656453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.RenderTargetCacheFlushEnable = true; 200756453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DepthCacheFlushEnable = true; 200856453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DCFlushEnable = true; 200956453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.PostSyncOperation = NoWrite; 201056453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.CommandStreamerStallEnable = true; 201156453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 2012b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen 201350018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 201456453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.TextureCacheInvalidationEnable = true; 201556453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.ConstantCacheInvalidationEnable = true; 201656453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.StateCacheInvalidationEnable = true; 201756453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.InstructionCacheInvalidateEnable = true; 201856453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.PostSyncOperation = NoWrite; 201956453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 2020c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen#endif 2021c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen} 2022c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen 2023832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsbergvoid 2024832f73f512e9e6c21d495d7b07e229482371ef2fKristian HøgsberggenX(flush_pipeline_select_3d)(struct anv_cmd_buffer *cmd_buffer) 2025832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg{ 2026832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg if (cmd_buffer->state.current_pipeline != _3D) { 2027c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen flush_pipeline_before_pipeline_select(cmd_buffer, _3D); 2028c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen 202950018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPELINE_SELECT), ps) { 2030371b4a5b33a13f35fa7783510d2d90685a9a2e8aJason Ekstrand#if GEN_GEN >= 9 2031deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ps.MaskBits = 3; 2032832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg#endif 2033deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ps.PipelineSelection = _3D; 2034deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 2035deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand 2036832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg cmd_buffer->state.current_pipeline = _3D; 2037832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg } 2038832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg} 203985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 20401b126305ded36f6b416ada08e29ff84faeafef99Jordan Justenvoid 20411b126305ded36f6b416ada08e29ff84faeafef99Jordan JustengenX(flush_pipeline_select_gpgpu)(struct anv_cmd_buffer *cmd_buffer) 20421b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen{ 20431b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen if (cmd_buffer->state.current_pipeline != GPGPU) { 2044c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen flush_pipeline_before_pipeline_select(cmd_buffer, GPGPU); 20451b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen 204650018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPELINE_SELECT), ps) { 20471b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen#if GEN_GEN >= 9 2048deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ps.MaskBits = 3; 20491b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen#endif 2050deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ps.PipelineSelection = GPGPU; 2051deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 2052deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand 20531b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen cmd_buffer->state.current_pipeline = GPGPU; 20541b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen } 20551b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen} 20561b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen 2057a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrandvoid 2058a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason EkstrandgenX(cmd_buffer_emit_gen7_depth_flush)(struct anv_cmd_buffer *cmd_buffer) 2059a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand{ 2060a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand if (GEN_GEN >= 8) 2061a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand return; 2062a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand 2063a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand /* From the Haswell PRM, documentation for 3DSTATE_DEPTH_BUFFER: 2064a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * 2065a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * "Restriction: Prior to changing Depth/Stencil Buffer state (i.e., any 2066a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * combination of 3DSTATE_DEPTH_BUFFER, 3DSTATE_CLEAR_PARAMS, 2067a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * 3DSTATE_STENCIL_BUFFER, 3DSTATE_HIER_DEPTH_BUFFER) SW must first 2068a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * issue a pipelined depth stall (PIPE_CONTROL with Depth Stall bit 2069a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * set), followed by a pipelined depth cache flush (PIPE_CONTROL with 2070a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * Depth Flush Bit set, followed by another pipelined depth stall 2071a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * (PIPE_CONTROL with Depth Stall Bit set), unless SW can otherwise 2072a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * guarantee that the pipeline from WM onwards is already flushed (e.g., 2073a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * via a preceding MI_FLUSH)." 2074a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand */ 2075a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pipe) { 2076a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand pipe.DepthStallEnable = true; 2077a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand } 2078a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pipe) { 2079a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand pipe.DepthCacheFlushEnable = true; 2080a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand } 2081a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pipe) { 2082a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand pipe.DepthStallEnable = true; 2083a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand } 2084a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand} 2085a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand 2086d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrandstatic uint32_t 2087d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstranddepth_stencil_surface_type(enum isl_surf_dim dim) 2088d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand{ 2089d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand switch (dim) { 2090d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand case ISL_SURF_DIM_1D: 2091d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand if (GEN_GEN >= 9) { 2092d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand /* From the Sky Lake PRM, 3DSTATAE_DEPTH_BUFFER::SurfaceType 2093d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * 2094d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * Programming Notes: 2095d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * The Surface Type of the depth buffer must be the same as the 2096d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * Surface Type of the render target(s) (defined in 2097d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * SURFACE_STATE), unless either the depth buffer or render 2098d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * targets are SURFTYPE_NULL (see exception below for SKL). 1D 2099d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * surface type not allowed for depth surface and stencil surface. 2100d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * 2101d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * Workaround: 2102d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * If depth/stencil is enabled with 1D render target, 2103d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * depth/stencil surface type needs to be set to 2D surface type 2104d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * and height set to 1. Depth will use (legacy) TileY and stencil 2105d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * will use TileW. For this case only, the Surface Type of the 2106d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * depth buffer can be 2D while the Surface Type of the render 2107d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * target(s) are 1D, representing an exception to a programming 2108d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * note above. 2109d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand */ 2110d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand return SURFTYPE_2D; 2111d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } else { 2112d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand return SURFTYPE_1D; 2113d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } 2114d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand case ISL_SURF_DIM_2D: 2115d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand return SURFTYPE_2D; 2116d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand case ISL_SURF_DIM_3D: 2117d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand if (GEN_GEN >= 9) { 2118d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand /* The Sky Lake docs list the value for 3D as "Reserved". However, 2119d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * they have the exact same layout as 2D arrays on gen9+, so we can 2120d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * just use 2D here. 2121d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand */ 2122d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand return SURFTYPE_2D; 2123d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } else { 2124d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand return SURFTYPE_3D; 2125d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } 2126d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand default: 2127d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand unreachable("Invalid surface dimension"); 2128d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } 2129d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand} 2130d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand 213185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsbergstatic void 213285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsbergcmd_buffer_emit_depth_stencil(struct anv_cmd_buffer *cmd_buffer) 213385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg{ 213485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg struct anv_device *device = cmd_buffer->device; 213585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg const struct anv_framebuffer *fb = cmd_buffer->state.framebuffer; 213685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg const struct anv_image_view *iview = 213785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg anv_cmd_buffer_get_depth_stencil_view(cmd_buffer); 213885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg const struct anv_image *image = iview ? iview->image : NULL; 2139234ecf26c65a8909e91313a8b35e2a8a8bbfc0efJason Ekstrand const bool has_depth = image && (image->aspects & VK_IMAGE_ASPECT_DEPTH_BIT); 2140168985fca1b59d345471277d5c8ce4a82cdc74f4Nanley Chery const uint32_t ds = cmd_buffer->state.subpass->depth_stencil_attachment; 2141168985fca1b59d345471277d5c8ce4a82cdc74f4Nanley Chery const bool has_hiz = image != NULL && 2142168985fca1b59d345471277d5c8ce4a82cdc74f4Nanley Chery cmd_buffer->state.attachments[ds].aux_usage == ISL_AUX_USAGE_HIZ; 2143234ecf26c65a8909e91313a8b35e2a8a8bbfc0efJason Ekstrand const bool has_stencil = 2144234ecf26c65a8909e91313a8b35e2a8a8bbfc0efJason Ekstrand image && (image->aspects & VK_IMAGE_ASPECT_STENCIL_BIT); 214585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 214685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg /* FIXME: Implement the PMA stall W/A */ 214785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg /* FIXME: Width and Height are wrong */ 214885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2149a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand genX(cmd_buffer_emit_gen7_depth_flush)(cmd_buffer); 2150a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand 215185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg /* Emit 3DSTATE_DEPTH_BUFFER */ 215285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg if (has_depth) { 215350018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_DEPTH_BUFFER), db) { 2154d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand db.SurfaceType = 2155d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand depth_stencil_surface_type(image->depth_surface.isl.dim); 2156a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.DepthWriteEnable = true; 2157a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.StencilWriteEnable = has_stencil; 215864fb5b0d51751f452b7bf4c5fff06b5549eed4a8Nanley Chery db.HierarchicalDepthBufferEnable = has_hiz; 2159a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand 2160a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.SurfaceFormat = isl_surf_get_depth_format(&device->isl_dev, 2161a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand &image->depth_surface.isl); 2162a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand 2163a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.SurfaceBaseAddress = (struct anv_address) { 216485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg .bo = image->bo, 216522d8666d74f6fa6de53366f76a56277976eced21Kristian Høgsberg .offset = image->offset + image->depth_surface.offset, 2166a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand }; 2167696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin db.DepthBufferObjectControlState = GENX(MOCS); 2168a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand 2169a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.SurfacePitch = image->depth_surface.isl.row_pitch - 1; 217020e95a746df34923eb4aac5e7f1ab6d722432d89Jason Ekstrand db.Height = image->extent.height - 1; 217120e95a746df34923eb4aac5e7f1ab6d722432d89Jason Ekstrand db.Width = image->extent.width - 1; 217229e289fa655938f7814bdbb3de7996a8a0f04b60Jason Ekstrand db.LOD = iview->isl.base_level; 217329e289fa655938f7814bdbb3de7996a8a0f04b60Jason Ekstrand db.MinimumArrayElement = iview->isl.base_array_layer; 2174a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand 217561992e0afe5f717aad7321d9748588b2cd27f8eeNanley Chery assert(image->depth_surface.isl.dim != ISL_SURF_DIM_3D); 217661992e0afe5f717aad7321d9748588b2cd27f8eeNanley Chery db.Depth = 217761992e0afe5f717aad7321d9748588b2cd27f8eeNanley Chery db.RenderTargetViewExtent = 217861992e0afe5f717aad7321d9748588b2cd27f8eeNanley Chery iview->isl.array_len - iview->isl.base_array_layer - 1; 217961992e0afe5f717aad7321d9748588b2cd27f8eeNanley Chery 2180371b4a5b33a13f35fa7783510d2d90685a9a2e8aJason Ekstrand#if GEN_GEN >= 8 2181a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.SurfaceQPitch = 2182696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin isl_surf_get_array_pitch_el_rows(&image->depth_surface.isl) >> 2; 218385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg#endif 2184a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand } 218585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg } else { 218685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg /* Even when no depth buffer is present, the hardware requires that 218785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH_BUFFER be programmed correctly. The Broadwell PRM says: 218885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 218985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * If a null depth buffer is bound, the driver must instead bind depth as: 219085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH.SurfaceType = SURFTYPE_2D 219185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH.Width = 1 219285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH.Height = 1 219385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH.SuraceFormat = D16_UNORM 219485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH.SurfaceBaseAddress = 0 219585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH.HierarchicalDepthBufferEnable = 0 219685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_WM_DEPTH_STENCIL.DepthTestEnable = 0 219785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_WM_DEPTH_STENCIL.DepthBufferWriteEnable = 0 219885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 219985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * The PRM is wrong, though. The width and height must be programmed to 220085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * actual framebuffer's width and height, even when neither depth buffer 22017c1660aa14094e40fba9f39ce194cb6238311b65Jason Ekstrand * nor stencil buffer is present. Also, D16_UNORM is not allowed to 22027c1660aa14094e40fba9f39ce194cb6238311b65Jason Ekstrand * be combined with a stencil buffer so we use D32_FLOAT instead. 220385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg */ 220450018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_DEPTH_BUFFER), db) { 2205d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand if (has_stencil) { 220627433b26b197b8b69d4ca8c9aed567f04950648eJason Ekstrand db.SurfaceType = 2207d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand depth_stencil_surface_type(image->stencil_surface.isl.dim); 2208d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } else { 2209d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand db.SurfaceType = SURFTYPE_2D; 2210d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } 2211a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.SurfaceFormat = D32_FLOAT; 2212dcca706b4e2d2086b90d77cced0cff6ce4eac953Kenneth Graunke db.Width = MAX2(fb->width, 1) - 1; 2213dcca706b4e2d2086b90d77cced0cff6ce4eac953Kenneth Graunke db.Height = MAX2(fb->height, 1) - 1; 2214a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.StencilWriteEnable = has_stencil; 2215a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand } 221685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg } 221785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 221878d074b87a75d599e65ef34f5b866da577b80de3Chad Versace if (has_hiz) { 221978d074b87a75d599e65ef34f5b866da577b80de3Chad Versace anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_HIER_DEPTH_BUFFER), hdb) { 222078d074b87a75d599e65ef34f5b866da577b80de3Chad Versace hdb.HierarchicalDepthBufferObjectControlState = GENX(MOCS); 2221c3eb58664e5e537b21a75172916b42bd4b5504b3Jason Ekstrand hdb.SurfacePitch = image->aux_surface.isl.row_pitch - 1; 222278d074b87a75d599e65ef34f5b866da577b80de3Chad Versace hdb.SurfaceBaseAddress = (struct anv_address) { 222378d074b87a75d599e65ef34f5b866da577b80de3Chad Versace .bo = image->bo, 2224c3eb58664e5e537b21a75172916b42bd4b5504b3Jason Ekstrand .offset = image->offset + image->aux_surface.offset, 222578d074b87a75d599e65ef34f5b866da577b80de3Chad Versace }; 222678d074b87a75d599e65ef34f5b866da577b80de3Chad Versace#if GEN_GEN >= 8 222778d074b87a75d599e65ef34f5b866da577b80de3Chad Versace /* From the SKL PRM Vol2a: 222878d074b87a75d599e65ef34f5b866da577b80de3Chad Versace * 222978d074b87a75d599e65ef34f5b866da577b80de3Chad Versace * The interpretation of this field is dependent on Surface Type 223078d074b87a75d599e65ef34f5b866da577b80de3Chad Versace * as follows: 223178d074b87a75d599e65ef34f5b866da577b80de3Chad Versace * - SURFTYPE_1D: distance in pixels between array slices 223278d074b87a75d599e65ef34f5b866da577b80de3Chad Versace * - SURFTYPE_2D/CUBE: distance in rows between array slices 223378d074b87a75d599e65ef34f5b866da577b80de3Chad Versace * - SURFTYPE_3D: distance in rows between R - slices 2234f469235a6e0c239166ba803e121994063b47ddd3Jason Ekstrand * 2235f469235a6e0c239166ba803e121994063b47ddd3Jason Ekstrand * Unfortunately, the docs aren't 100% accurate here. They fail to 2236f469235a6e0c239166ba803e121994063b47ddd3Jason Ekstrand * mention that the 1-D rule only applies to linear 1-D images. 2237f469235a6e0c239166ba803e121994063b47ddd3Jason Ekstrand * Since depth and HiZ buffers are always tiled, they are treated as 2238f469235a6e0c239166ba803e121994063b47ddd3Jason Ekstrand * 2-D images. Prior to Sky Lake, this field is always in rows. 223978d074b87a75d599e65ef34f5b866da577b80de3Chad Versace */ 224078d074b87a75d599e65ef34f5b866da577b80de3Chad Versace hdb.SurfaceQPitch = 22419f1d3a0c971e95c9e04cf6bfcd60f8b0d8c6742bNanley Chery isl_surf_get_array_pitch_sa_rows(&image->aux_surface.isl) >> 2; 224278d074b87a75d599e65ef34f5b866da577b80de3Chad Versace#endif 224378d074b87a75d599e65ef34f5b866da577b80de3Chad Versace } 224478d074b87a75d599e65ef34f5b866da577b80de3Chad Versace } else { 224578d074b87a75d599e65ef34f5b866da577b80de3Chad Versace anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_HIER_DEPTH_BUFFER), hdb); 224678d074b87a75d599e65ef34f5b866da577b80de3Chad Versace } 224778d074b87a75d599e65ef34f5b866da577b80de3Chad Versace 224885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg /* Emit 3DSTATE_STENCIL_BUFFER */ 224985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg if (has_stencil) { 225050018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_STENCIL_BUFFER), sb) { 2251371b4a5b33a13f35fa7783510d2d90685a9a2e8aJason Ekstrand#if GEN_GEN >= 8 || GEN_IS_HASWELL 2252696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin sb.StencilBufferEnable = true; 225385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg#endif 2254696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin sb.StencilBufferObjectControlState = GENX(MOCS); 225585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2256696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin sb.SurfacePitch = image->stencil_surface.isl.row_pitch - 1; 225785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2258371b4a5b33a13f35fa7783510d2d90685a9a2e8aJason Ekstrand#if GEN_GEN >= 8 2259696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin sb.SurfaceQPitch = isl_surf_get_array_pitch_el_rows(&image->stencil_surface.isl) >> 2; 226085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg#endif 2261a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand sb.SurfaceBaseAddress = (struct anv_address) { 226285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg .bo = image->bo, 226385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg .offset = image->offset + image->stencil_surface.offset, 2264a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand }; 2265a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand } 226685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg } else { 226750018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_STENCIL_BUFFER), sb); 226885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg } 226985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2270d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery /* From the IVB PRM Vol2P1, 11.5.5.4 3DSTATE_CLEAR_PARAMS: 2271d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * 2272d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * 3DSTATE_CLEAR_PARAMS must always be programmed in the along with 2273d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * the other Depth/Stencil state commands(i.e. 3DSTATE_DEPTH_BUFFER, 2274d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * 3DSTATE_STENCIL_BUFFER, or 3DSTATE_HIER_DEPTH_BUFFER) 2275d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * 2276d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * Testing also shows that some variant of this restriction may exist HSW+. 2277d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * On BDW+, it is not possible to emit 2 of these packets consecutively when 2278d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * both have DepthClearValueValid set. An analysis of such state programming 2279d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * on SKL showed that the GPU doesn't register the latter packet's clear 2280d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * value. 2281d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery */ 2282d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_CLEAR_PARAMS), cp) { 2283d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery if (has_hiz) { 2284d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery cp.DepthClearValueValid = true; 2285d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery const uint32_t ds = 2286d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery cmd_buffer->state.subpass->depth_stencil_attachment; 2287d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery cp.DepthClearValue = 2288d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery cmd_buffer->state.attachments[ds].clear_value.depthStencil.depth; 2289d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery } 2290d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery } 229185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg} 229285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2293b548fdbed5c16f5c0dfc26f65b0037a85c567735Jason Ekstrandstatic void 229485f67cf16e9823c858215e8a7359d18762c2653cKristian HøgsberggenX(cmd_buffer_set_subpass)(struct anv_cmd_buffer *cmd_buffer, 229585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg struct anv_subpass *subpass) 229685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg{ 229785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg cmd_buffer->state.subpass = subpass; 229885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2299fe4e276b02615b5db8acbf4c65fcfa68982e2e0fJason Ekstrand cmd_buffer->state.dirty |= ANV_CMD_DIRTY_RENDER_TARGETS; 230085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2301462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery const struct anv_image_view *iview = 2302462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery anv_cmd_buffer_get_depth_stencil_view(cmd_buffer); 2303462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery 2304462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery if (iview) { 2305462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery anv_gen8_hiz_op_resolve(cmd_buffer, iview->image, 2306462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery BLORP_HIZ_OP_HIZ_RESOLVE); 2307462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery } 2308462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery 230985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg cmd_buffer_emit_depth_stencil(cmd_buffer); 2310c81ec84c1ec24f11f86b2fb725956437c721fe18Jason Ekstrand 2311c81ec84c1ec24f11f86b2fb725956437c721fe18Jason Ekstrand anv_cmd_buffer_clear_subpass(cmd_buffer); 231285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg} 231385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 231485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsbergvoid genX(CmdBeginRenderPass)( 231585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg VkCommandBuffer commandBuffer, 231685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg const VkRenderPassBeginInfo* pRenderPassBegin, 231785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg VkSubpassContents contents) 231885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg{ 231985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 232085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg ANV_FROM_HANDLE(anv_render_pass, pass, pRenderPassBegin->renderPass); 232185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg ANV_FROM_HANDLE(anv_framebuffer, framebuffer, pRenderPassBegin->framebuffer); 232285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 232385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg cmd_buffer->state.framebuffer = framebuffer; 232485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg cmd_buffer->state.pass = pass; 2325b26bd6790dd1b09e377bd926e9145ec20ce6ac3fJason Ekstrand cmd_buffer->state.render_area = pRenderPassBegin->renderArea; 2326d1d6b788989e73edd2426999d891230500dc1a73Jason Ekstrand genX(cmd_buffer_setup_attachments)(cmd_buffer, pass, pRenderPassBegin); 232785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 232885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg genX(flush_pipeline_select_3d)(cmd_buffer); 232985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 233085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg genX(cmd_buffer_set_subpass)(cmd_buffer, pass->subpasses); 233185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg} 233285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 233385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsbergvoid genX(CmdNextSubpass)( 233485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg VkCommandBuffer commandBuffer, 233585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg VkSubpassContents contents) 233685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg{ 233785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 233885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 233985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg assert(cmd_buffer->level == VK_COMMAND_BUFFER_LEVEL_PRIMARY); 234085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2341462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery const struct anv_image_view *iview = 2342462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery anv_cmd_buffer_get_depth_stencil_view(cmd_buffer); 2343462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery 2344462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery if (iview) { 2345462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery anv_gen8_hiz_op_resolve(cmd_buffer, iview->image, 2346462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery BLORP_HIZ_OP_DEPTH_RESOLVE); 2347462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery } 2348462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery 234985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg anv_cmd_buffer_resolve_subpass(cmd_buffer); 235085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg genX(cmd_buffer_set_subpass)(cmd_buffer, cmd_buffer->state.subpass + 1); 235185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg} 235285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 235385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsbergvoid genX(CmdEndRenderPass)( 235485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg VkCommandBuffer commandBuffer) 235585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg{ 235685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 235785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2358462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery const struct anv_image_view *iview = 2359462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery anv_cmd_buffer_get_depth_stencil_view(cmd_buffer); 2360462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery 2361462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery if (iview) { 2362462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery anv_gen8_hiz_op_resolve(cmd_buffer, iview->image, 2363462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery BLORP_HIZ_OP_DEPTH_RESOLVE); 2364462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery } 2365462a4c96487b3bf36119bdfaee2bdacb835e4100Nanley Chery 236685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg anv_cmd_buffer_resolve_subpass(cmd_buffer); 2367ac7eeebce4ae9107863623321b74b1c08389f180Jason Ekstrand 2368ac7eeebce4ae9107863623321b74b1c08389f180Jason Ekstrand#ifndef NDEBUG 2369ac7eeebce4ae9107863623321b74b1c08389f180Jason Ekstrand anv_dump_add_framebuffer(cmd_buffer, cmd_buffer->state.framebuffer); 2370ac7eeebce4ae9107863623321b74b1c08389f180Jason Ekstrand#endif 237185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg} 237281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 237381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenstatic void 23741e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrandemit_ps_depth_count(struct anv_cmd_buffer *cmd_buffer, 237581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen struct anv_bo *bo, uint32_t offset) 237681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 23771e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 237856453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DestinationAddressType = DAT_PPGTT; 237956453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.PostSyncOperation = WritePSDepthCount; 238056453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DepthStallEnable = true; 238156453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.Address = (struct anv_address) { bo, offset }; 2382a6c3d0f92b754e11e74cea9d6bd5ac329c73a8baJason Ekstrand 2383a6c3d0f92b754e11e74cea9d6bd5ac329c73a8baJason Ekstrand if (GEN_GEN == 9 && cmd_buffer->device->info.gt == 4) 2384a6c3d0f92b754e11e74cea9d6bd5ac329c73a8baJason Ekstrand pc.CommandStreamerStallEnable = true; 238556453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 238681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 238781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 238881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenstatic void 23891e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrandemit_query_availability(struct anv_cmd_buffer *cmd_buffer, 239081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen struct anv_bo *bo, uint32_t offset) 239181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 23921e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 239356453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DestinationAddressType = DAT_PPGTT; 239456453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.PostSyncOperation = WriteImmediateData; 239556453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.Address = (struct anv_address) { bo, offset }; 239656453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.ImmediateData = 1; 239756453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 239881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 239981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 240081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenvoid genX(CmdBeginQuery)( 240181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkCommandBuffer commandBuffer, 240281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkQueryPool queryPool, 240381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t query, 240481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkQueryControlFlags flags) 240581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 240681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 240781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_query_pool, pool, queryPool); 240881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 240981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen /* Workaround: When meta uses the pipeline with the VS disabled, it seems 241081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen * that the pipelining of the depth write breaks. What we see is that 241181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen * samples from the render pass clear leaks into the first query 241281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen * immediately after the clear. Doing a pipecontrol with a post-sync 241381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen * operation and DepthStallEnable seems to work around the issue. 241481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen */ 241581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen if (cmd_buffer->state.need_query_wa) { 241681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen cmd_buffer->state.need_query_wa = false; 241750018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 241856453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DepthCacheFlushEnable = true; 241956453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DepthStallEnable = true; 242056453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 242181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 242281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 242381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen switch (pool->type) { 242481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_QUERY_TYPE_OCCLUSION: 24251e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrand emit_ps_depth_count(cmd_buffer, &pool->bo, 242681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen query * sizeof(struct anv_query_pool_slot)); 242781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen break; 242881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 242981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_QUERY_TYPE_PIPELINE_STATISTICS: 243081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen default: 243181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen unreachable(""); 243281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 243381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 243481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 243581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenvoid genX(CmdEndQuery)( 243681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkCommandBuffer commandBuffer, 243781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkQueryPool queryPool, 243881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t query) 243981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 244081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 244181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_query_pool, pool, queryPool); 244281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 244381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen switch (pool->type) { 244481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_QUERY_TYPE_OCCLUSION: 24451e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrand emit_ps_depth_count(cmd_buffer, &pool->bo, 244681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen query * sizeof(struct anv_query_pool_slot) + 8); 244781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 24481e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrand emit_query_availability(cmd_buffer, &pool->bo, 244981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen query * sizeof(struct anv_query_pool_slot) + 16); 245081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen break; 245181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 245281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_QUERY_TYPE_PIPELINE_STATISTICS: 245381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen default: 245481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen unreachable(""); 245581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 245681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 245781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 245881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define TIMESTAMP 0x2358 245981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 246081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenvoid genX(CmdWriteTimestamp)( 246181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkCommandBuffer commandBuffer, 246281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkPipelineStageFlagBits pipelineStage, 246381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkQueryPool queryPool, 246481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t query) 246581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 246681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 246781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_query_pool, pool, queryPool); 246881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t offset = query * sizeof(struct anv_query_pool_slot); 246981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 247081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen assert(pool->type == VK_QUERY_TYPE_TIMESTAMP); 247181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 247281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen switch (pipelineStage) { 247381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT: 247450018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(MI_STORE_REGISTER_MEM), srm) { 24758a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.RegisterAddress = TIMESTAMP; 24768a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.MemoryAddress = (struct anv_address) { &pool->bo, offset }; 24778a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 247850018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(MI_STORE_REGISTER_MEM), srm) { 24798a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.RegisterAddress = TIMESTAMP + 4; 24808a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.MemoryAddress = (struct anv_address) { &pool->bo, offset + 4 }; 24818a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 248281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen break; 248381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 248481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen default: 248581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen /* Everything else is bottom-of-pipe */ 248650018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 2487696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin pc.DestinationAddressType = DAT_PPGTT; 2488696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin pc.PostSyncOperation = WriteTimestamp; 24898a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand pc.Address = (struct anv_address) { &pool->bo, offset }; 2490a6c3d0f92b754e11e74cea9d6bd5ac329c73a8baJason Ekstrand 2491a6c3d0f92b754e11e74cea9d6bd5ac329c73a8baJason Ekstrand if (GEN_GEN == 9 && cmd_buffer->device->info.gt == 4) 2492a6c3d0f92b754e11e74cea9d6bd5ac329c73a8baJason Ekstrand pc.CommandStreamerStallEnable = true; 24938a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 249481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen break; 249581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 249681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 24971e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrand emit_query_availability(cmd_buffer, &pool->bo, query + 16); 249881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 249981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 250081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#if GEN_GEN > 7 || GEN_IS_HASWELL 250181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 250281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define alu_opcode(v) __gen_uint((v), 20, 31) 250381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define alu_operand1(v) __gen_uint((v), 10, 19) 250481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define alu_operand2(v) __gen_uint((v), 0, 9) 250581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define alu(opcode, operand1, operand2) \ 250681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen alu_opcode(opcode) | alu_operand1(operand1) | alu_operand2(operand2) 250781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 250881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_NOOP 0x000 250981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_LOAD 0x080 251081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_LOADINV 0x480 251181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_LOAD0 0x081 251281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_LOAD1 0x481 251381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_ADD 0x100 251481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_SUB 0x101 251581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_AND 0x102 251681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_OR 0x103 251781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_XOR 0x104 251881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_STORE 0x180 251981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_STOREINV 0x580 252081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 252181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_R0 0x00 252281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_R1 0x01 252381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_R2 0x02 252481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_R3 0x03 252581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_R4 0x04 252681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_SRCA 0x20 252781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_SRCB 0x21 252881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_ACCU 0x31 252981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_ZF 0x32 253081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_CF 0x33 253181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 253281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define CS_GPR(n) (0x2600 + (n) * 8) 253381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 253481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenstatic void 253581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenemit_load_alu_reg_u64(struct anv_batch *batch, uint32_t reg, 253681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen struct anv_bo *bo, uint32_t offset) 253781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 253850018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_LOAD_REGISTER_MEM), lrm) { 25398a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand lrm.RegisterAddress = reg, 25408a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand lrm.MemoryAddress = (struct anv_address) { bo, offset }; 25418a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 254250018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_LOAD_REGISTER_MEM), lrm) { 25438a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand lrm.RegisterAddress = reg + 4; 25448a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand lrm.MemoryAddress = (struct anv_address) { bo, offset + 4 }; 25458a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 254681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 254781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 254881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenstatic void 254981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenstore_query_result(struct anv_batch *batch, uint32_t reg, 255081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen struct anv_bo *bo, uint32_t offset, VkQueryResultFlags flags) 255181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 255250018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_STORE_REGISTER_MEM), srm) { 25538a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.RegisterAddress = reg; 25548a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.MemoryAddress = (struct anv_address) { bo, offset }; 25558a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 25568a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand 25578a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand if (flags & VK_QUERY_RESULT_64_BIT) { 255850018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_STORE_REGISTER_MEM), srm) { 25598a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.RegisterAddress = reg + 4; 25608a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.MemoryAddress = (struct anv_address) { bo, offset + 4 }; 25618a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 25628a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 256381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 256481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 256581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenvoid genX(CmdCopyQueryPoolResults)( 256681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkCommandBuffer commandBuffer, 256781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkQueryPool queryPool, 256881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t firstQuery, 256981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t queryCount, 257081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkBuffer destBuffer, 257181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkDeviceSize destOffset, 257281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkDeviceSize destStride, 257381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkQueryResultFlags flags) 257481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 257581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 257681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_query_pool, pool, queryPool); 257781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_buffer, buffer, destBuffer); 257881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t slot_offset, dst_offset; 257981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 258056453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand if (flags & VK_QUERY_RESULT_WAIT_BIT) { 258150018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 258256453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.CommandStreamerStallEnable = true; 258356453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.StallAtPixelScoreboard = true; 258456453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 258556453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 258681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 258781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen dst_offset = buffer->offset + destOffset; 258881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen for (uint32_t i = 0; i < queryCount; i++) { 258981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 259081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen slot_offset = (firstQuery + i) * sizeof(struct anv_query_pool_slot); 259181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen switch (pool->type) { 259281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_QUERY_TYPE_OCCLUSION: 259381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen emit_load_alu_reg_u64(&cmd_buffer->batch, 259481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen CS_GPR(0), &pool->bo, slot_offset); 259581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen emit_load_alu_reg_u64(&cmd_buffer->batch, 259681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen CS_GPR(1), &pool->bo, slot_offset + 8); 259781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 259881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen /* FIXME: We need to clamp the result for 32 bit. */ 259981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 260081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t *dw = anv_batch_emitn(&cmd_buffer->batch, 5, GENX(MI_MATH)); 260181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen dw[1] = alu(OPCODE_LOAD, OPERAND_SRCA, OPERAND_R1); 260281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen dw[2] = alu(OPCODE_LOAD, OPERAND_SRCB, OPERAND_R0); 260381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen dw[3] = alu(OPCODE_SUB, 0, 0); 260481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen dw[4] = alu(OPCODE_STORE, OPERAND_R2, OPERAND_ACCU); 260581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen break; 260681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 260781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_QUERY_TYPE_TIMESTAMP: 260881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen emit_load_alu_reg_u64(&cmd_buffer->batch, 260981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen CS_GPR(2), &pool->bo, slot_offset); 261081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen break; 261181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 261281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen default: 261381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen unreachable("unhandled query type"); 261481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 261581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 261681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen store_query_result(&cmd_buffer->batch, 261781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen CS_GPR(2), buffer->bo, dst_offset, flags); 261881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 261981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen if (flags & VK_QUERY_RESULT_WITH_AVAILABILITY_BIT) { 262081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen emit_load_alu_reg_u64(&cmd_buffer->batch, CS_GPR(0), 262181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen &pool->bo, slot_offset + 16); 262281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen if (flags & VK_QUERY_RESULT_64_BIT) 262381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen store_query_result(&cmd_buffer->batch, 262481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen CS_GPR(0), buffer->bo, dst_offset + 8, flags); 262581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen else 262681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen store_query_result(&cmd_buffer->batch, 262781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen CS_GPR(0), buffer->bo, dst_offset + 4, flags); 262881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 262981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 263081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen dst_offset += destStride; 263181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 263281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 263381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 2634b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand#else 2635b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrandvoid genX(CmdCopyQueryPoolResults)( 2636b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand VkCommandBuffer commandBuffer, 2637b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand VkQueryPool queryPool, 2638b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand uint32_t firstQuery, 2639b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand uint32_t queryCount, 2640b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand VkBuffer destBuffer, 2641b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand VkDeviceSize destOffset, 2642b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand VkDeviceSize destStride, 2643b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand VkQueryResultFlags flags) 2644b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand{ 2645b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand anv_finishme("Queries not yet supported on Ivy Bridge"); 2646b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand} 264781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#endif 2648