genX_cmd_buffer.c revision dcca706b4e2d2086b90d77cced0cff6ce4eac953
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 313d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand/** 314d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand * Setup anv_cmd_state::attachments for vkCmdBeginRenderPass. 315d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand */ 316d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrandstatic void 317d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason EkstrandgenX(cmd_buffer_setup_attachments)(struct anv_cmd_buffer *cmd_buffer, 318d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_render_pass *pass, 319d1d6b788989e73edd2426999d891230500dc1a73Jason Ekstrand const VkRenderPassBeginInfo *begin) 320d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand{ 321d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand const struct isl_device *isl_dev = &cmd_buffer->device->isl_dev; 322d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_cmd_state *state = &cmd_buffer->state; 323d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 324d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand vk_free(&cmd_buffer->pool->alloc, state->attachments); 325d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 326d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (pass->attachment_count == 0) { 327d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand state->attachments = NULL; 328d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand return; 329d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 330d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 331d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand state->attachments = vk_alloc(&cmd_buffer->pool->alloc, 332d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand pass->attachment_count * 333d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand sizeof(state->attachments[0]), 334d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); 335d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (state->attachments == NULL) { 336d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand /* FIXME: Propagate VK_ERROR_OUT_OF_HOST_MEMORY to vkEndCommandBuffer */ 337d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand abort(); 338d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 339d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 340d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand bool need_null_state = false; 341633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand unsigned num_states = 0; 342d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand for (uint32_t i = 0; i < pass->attachment_count; ++i) { 343633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand if (vk_format_is_color(pass->attachments[i].format)) { 344d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand num_states++; 345633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand } else { 346633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand /* We need a null state for any depth-stencil-only subpasses. 347633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand * Importantly, this includes depth/stencil clears so we create one 348633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand * whenever we have depth or stencil 349633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand */ 350633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand need_null_state = true; 351633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand } 3521d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand 3531d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand if (need_input_attachment_state(&pass->attachments[i])) 3541d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand num_states++; 355d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 356633677194f1d33f0dfbdfdfb7ac5b4f1b4dffdcbJason Ekstrand num_states += need_null_state; 357d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 358d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand const uint32_t ss_stride = align_u32(isl_dev->ss.size, isl_dev->ss.align); 359d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand state->render_pass_states = 360d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand anv_state_stream_alloc(&cmd_buffer->surface_state_stream, 361d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand num_states * ss_stride, isl_dev->ss.align); 362d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 363d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_state next_state = state->render_pass_states; 364d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand next_state.alloc_size = isl_dev->ss.size; 365d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 366d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (need_null_state) { 367d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand state->null_surface_state = next_state; 368d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand next_state.offset += ss_stride; 369d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand next_state.map += ss_stride; 370d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 371d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 372d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand for (uint32_t i = 0; i < pass->attachment_count; ++i) { 373d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (vk_format_is_color(pass->attachments[i].format)) { 374d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand state->attachments[i].color_rt_state = next_state; 375d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand next_state.offset += ss_stride; 376d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand next_state.map += ss_stride; 377d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 3781d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand 3791d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand if (need_input_attachment_state(&pass->attachments[i])) { 3801d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand state->attachments[i].input_att_state = next_state; 3811d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand next_state.offset += ss_stride; 3821d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand next_state.map += ss_stride; 3831d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand } 384d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 385d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand assert(next_state.offset == state->render_pass_states.offset + 386d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand state->render_pass_states.alloc_size); 387d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 388d1d6b788989e73edd2426999d891230500dc1a73Jason Ekstrand if (begin) { 389d1d6b788989e73edd2426999d891230500dc1a73Jason Ekstrand ANV_FROM_HANDLE(anv_framebuffer, framebuffer, begin->framebuffer); 390d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand assert(pass->attachment_count == framebuffer->attachment_count); 391d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 392d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (need_null_state) { 393d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct GENX(RENDER_SURFACE_STATE) null_ss = { 394d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .SurfaceType = SURFTYPE_NULL, 395d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .SurfaceArray = framebuffer->layers > 0, 396d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .SurfaceFormat = ISL_FORMAT_R8G8B8A8_UNORM, 397d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand#if GEN_GEN >= 8 398d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .TileMode = YMAJOR, 399d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand#else 400d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .TiledSurface = true, 401d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand#endif 402d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .Width = framebuffer->width - 1, 403d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .Height = framebuffer->height - 1, 404d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .Depth = framebuffer->layers - 1, 405d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .RenderTargetViewExtent = framebuffer->layers - 1, 406d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand }; 407d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand GENX(RENDER_SURFACE_STATE_pack)(NULL, state->null_surface_state.map, 408d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand &null_ss); 409d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 410d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 411d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand for (uint32_t i = 0; i < pass->attachment_count; ++i) { 412d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_render_pass_attachment *att = &pass->attachments[i]; 413d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand VkImageAspectFlags att_aspects = vk_format_aspects(att->format); 414d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand VkImageAspectFlags clear_aspects = 0; 415d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 416d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (att_aspects == VK_IMAGE_ASPECT_COLOR_BIT) { 417d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand /* color attachment */ 418d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (att->load_op == VK_ATTACHMENT_LOAD_OP_CLEAR) { 419d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand clear_aspects |= VK_IMAGE_ASPECT_COLOR_BIT; 420d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 421d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } else { 422d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand /* depthstencil attachment */ 423d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if ((att_aspects & VK_IMAGE_ASPECT_DEPTH_BIT) && 424d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand att->load_op == VK_ATTACHMENT_LOAD_OP_CLEAR) { 425d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand clear_aspects |= VK_IMAGE_ASPECT_DEPTH_BIT; 426d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 427d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if ((att_aspects & VK_IMAGE_ASPECT_STENCIL_BIT) && 428d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand att->stencil_load_op == VK_ATTACHMENT_LOAD_OP_CLEAR) { 429d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand clear_aspects |= VK_IMAGE_ASPECT_STENCIL_BIT; 430d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 431d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 432d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 433d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand state->attachments[i].pending_clear_aspects = clear_aspects; 434d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (clear_aspects) 435d1d6b788989e73edd2426999d891230500dc1a73Jason Ekstrand state->attachments[i].clear_value = begin->pClearValues[i]; 436d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 437d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_image_view *iview = framebuffer->attachments[i]; 438d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand assert(iview->vk_format == att->format); 439d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 4405e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand union isl_color_value clear_color = { .u32 = { 0, } }; 441d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (att_aspects == VK_IMAGE_ASPECT_COLOR_BIT) { 4425e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand color_attachment_compute_aux_usage(cmd_buffer->device, 4435e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand &state->attachments[i], 4445e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand iview, begin->renderArea, 4455e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand &clear_color); 446338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand 447d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct isl_view view = iview->isl; 448d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand view.usage |= ISL_SURF_USAGE_RENDER_TARGET_BIT; 449d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand isl_surf_fill_state(isl_dev, 450d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand state->attachments[i].color_rt_state.map, 451d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .surf = &iview->image->color_surface.isl, 452d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .view = &view, 453338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand .aux_surf = &iview->image->aux_surface.isl, 454338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand .aux_usage = state->attachments[i].aux_usage, 4555e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand .clear_color = clear_color, 456d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand .mocs = cmd_buffer->device->default_mocs); 457d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 458818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand add_image_view_relocs(cmd_buffer, iview, 459338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand state->attachments[i].aux_usage, 460818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand state->attachments[i].color_rt_state); 461338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand } else { 462338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand state->attachments[i].aux_usage = ISL_AUX_USAGE_NONE; 4635e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand state->attachments[i].input_aux_usage = ISL_AUX_USAGE_NONE; 464d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 4651d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand 4661d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand if (need_input_attachment_state(&pass->attachments[i])) { 4671d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand const struct isl_surf *surf; 4681d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand if (att_aspects == VK_IMAGE_ASPECT_COLOR_BIT) { 4691d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand surf = &iview->image->color_surface.isl; 4701d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand } else { 4711d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand surf = &iview->image->depth_surface.isl; 4721d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand } 4731d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand 4741d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand struct isl_view view = iview->isl; 4751d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand view.usage |= ISL_SURF_USAGE_TEXTURE_BIT; 4761d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand isl_surf_fill_state(isl_dev, 4771d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand state->attachments[i].input_att_state.map, 4781d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand .surf = surf, 4791d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand .view = &view, 4801d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand .aux_surf = &iview->image->aux_surface.isl, 4815e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand .aux_usage = state->attachments[i].input_aux_usage, 4825e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand .clear_color = clear_color, 4831d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand .mocs = cmd_buffer->device->default_mocs); 4841d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand 4851d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand add_image_view_relocs(cmd_buffer, iview, 4865e8069a5726ec62ce21d1d708cb6e82ae628de14Jason Ekstrand state->attachments[i].input_aux_usage, 4871d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand state->attachments[i].input_att_state); 4881d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand } 489d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 490d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 491d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (!cmd_buffer->device->info.has_llc) 492d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand anv_state_clflush(state->render_pass_states); 493d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 494d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand} 495d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 4962314c9ed2e39bcf4ac6b206344acb05fec876a41Jason EkstrandVkResult 4972314c9ed2e39bcf4ac6b206344acb05fec876a41Jason EkstrandgenX(BeginCommandBuffer)( 4982314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand VkCommandBuffer commandBuffer, 4992314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand const VkCommandBufferBeginInfo* pBeginInfo) 5002314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand{ 5012314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 5022314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 5032314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand /* If this is the first vkBeginCommandBuffer, we must *initialize* the 5042314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * command buffer's state. Otherwise, we must *reset* its state. In both 5052314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * cases we reset it. 5062314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * 5072314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * From the Vulkan 1.0 spec: 5082314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * 5092314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * If a command buffer is in the executable state and the command buffer 5102314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * was allocated from a command pool with the 5112314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT flag set, then 5122314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * vkBeginCommandBuffer implicitly resets the command buffer, behaving 5132314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * as if vkResetCommandBuffer had been called with 5142314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT not set. It then puts 5152314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * the command buffer in the recording state. 5162314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand */ 5172314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand anv_cmd_buffer_reset(cmd_buffer); 5182314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 5192314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand cmd_buffer->usage_flags = pBeginInfo->flags; 5202314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 5212314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand assert(cmd_buffer->level == VK_COMMAND_BUFFER_LEVEL_SECONDARY || 5222314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand !(cmd_buffer->usage_flags & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT)); 5232314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 5242314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand genX(cmd_buffer_emit_state_base_address)(cmd_buffer); 5252314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 5262314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand if (cmd_buffer->usage_flags & 5272314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT) { 5282314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand cmd_buffer->state.pass = 5292314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand anv_render_pass_from_handle(pBeginInfo->pInheritanceInfo->renderPass); 5302314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand cmd_buffer->state.subpass = 5312314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand &cmd_buffer->state.pass->subpasses[pBeginInfo->pInheritanceInfo->subpass]; 532a380f954610319782811bb2aa44180c4e1231823Jason Ekstrand cmd_buffer->state.framebuffer = NULL; 5332314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 534d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand genX(cmd_buffer_setup_attachments)(cmd_buffer, cmd_buffer->state.pass, 535d1d6b788989e73edd2426999d891230500dc1a73Jason Ekstrand NULL); 536d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 5372314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand cmd_buffer->state.dirty |= ANV_CMD_DIRTY_RENDER_TARGETS; 5382314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand } 5392314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 5402314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand return VK_SUCCESS; 5412314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand} 5422314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 5432314c9ed2e39bcf4ac6b206344acb05fec876a41Jason EkstrandVkResult 5442314c9ed2e39bcf4ac6b206344acb05fec876a41Jason EkstrandgenX(EndCommandBuffer)( 5452314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand VkCommandBuffer commandBuffer) 5462314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand{ 5472314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 5482314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 5498d1ccd67290c1fd0213aed6a7e9a6bf85858f227Jason Ekstrand genX(cmd_buffer_apply_pipe_flushes)(cmd_buffer); 5508d1ccd67290c1fd0213aed6a7e9a6bf85858f227Jason Ekstrand 5512314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand anv_cmd_buffer_end_batch_buffer(cmd_buffer); 5522314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 5532314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand return VK_SUCCESS; 5542314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand} 5552314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 5562314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrandvoid 5572314c9ed2e39bcf4ac6b206344acb05fec876a41Jason EkstrandgenX(CmdExecuteCommands)( 5582314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand VkCommandBuffer commandBuffer, 5592314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand uint32_t commandBufferCount, 5602314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand const VkCommandBuffer* pCmdBuffers) 5612314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand{ 5622314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand ANV_FROM_HANDLE(anv_cmd_buffer, primary, commandBuffer); 5632314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 5642314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand assert(primary->level == VK_COMMAND_BUFFER_LEVEL_PRIMARY); 5652314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 5662314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand for (uint32_t i = 0; i < commandBufferCount; i++) { 5672314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand ANV_FROM_HANDLE(anv_cmd_buffer, secondary, pCmdBuffers[i]); 5682314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 5692314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand assert(secondary->level == VK_COMMAND_BUFFER_LEVEL_SECONDARY); 5702314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 571d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand if (secondary->usage_flags & 572d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT) { 573d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand /* If we're continuing a render pass from the primary, we need to 574d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand * copy the surface states for the current subpass into the storage 575d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand * we allocated for them in BeginCommandBuffer. 576d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand */ 577d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_bo *ss_bo = &primary->device->surface_state_block_pool.bo; 578d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_state src_state = primary->state.render_pass_states; 579d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand struct anv_state dst_state = secondary->state.render_pass_states; 580d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand assert(src_state.alloc_size == dst_state.alloc_size); 581d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 582d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand genX(cmd_buffer_gpu_memcpy)(primary, ss_bo, dst_state.offset, 583d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand ss_bo, src_state.offset, 584d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand src_state.alloc_size); 585d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand } 586d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand 5872314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand anv_cmd_buffer_add_secondary(primary, secondary); 5882314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand } 5892314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 5902314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand /* Each of the secondary command buffers will use its own state base 5912314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * address. We need to re-emit state base address for the primary after 5922314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * all of the secondaries are done. 5932314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * 5942314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * TODO: Maybe we want to make this a dirty bit to avoid extra state base 5952314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand * address calls? 5962314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand */ 5972314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand genX(cmd_buffer_emit_state_base_address)(primary); 5982314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand} 5992314c9ed2e39bcf4ac6b206344acb05fec876a41Jason Ekstrand 6007e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#define IVB_L3SQCREG1_SQGHPCI_DEFAULT 0x00730000 6017e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#define VLV_L3SQCREG1_SQGHPCI_DEFAULT 0x00d30000 6027e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#define HSW_L3SQCREG1_SQGHPCI_DEFAULT 0x00610000 6037e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 6047e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand/** 6057e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * Program the hardware to use the specified L3 configuration. 6067e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand */ 6077e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrandvoid 6087e891f90c701aa1c851f1846857daa75bbb65876Jason EkstrandgenX(cmd_buffer_config_l3)(struct anv_cmd_buffer *cmd_buffer, 6097e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const struct gen_l3_config *cfg) 6107e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand{ 6117e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand assert(cfg); 6127e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand if (cfg == cmd_buffer->state.current_l3_config) 6137e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand return; 6147e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 6157e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand if (unlikely(INTEL_DEBUG & DEBUG_L3)) { 6167e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand fprintf(stderr, "L3 config transition: "); 6177e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand gen_dump_l3_config(cfg, stderr); 6187e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand } 6197e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 6207e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const bool has_slm = cfg->n[GEN_L3P_SLM]; 6217e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 6227e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* According to the hardware docs, the L3 partitioning can only be changed 6237e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * while the pipeline is completely drained and the caches are flushed, 6247e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * which involves a first PIPE_CONTROL flush which stalls the pipeline... 6257e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand */ 6267e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 6277e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.DCFlushEnable = true; 6287e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.PostSyncOperation = NoWrite; 6297e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.CommandStreamerStallEnable = true; 6307e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand } 6317e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 6327e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* ...followed by a second pipelined PIPE_CONTROL that initiates 6337e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * invalidation of the relevant caches. Note that because RO invalidation 6347e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * happens at the top of the pipeline (i.e. right away as the PIPE_CONTROL 6357e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * command is processed by the CS) we cannot combine it with the previous 6367e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * stalling flush as the hardware documentation suggests, because that 6377e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * would cause the CS to stall on previous rendering *after* RO 6387e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * invalidation and wouldn't prevent the RO caches from being polluted by 6397e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * concurrent rendering before the stall completes. This intentionally 6407e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * doesn't implement the SKL+ hardware workaround suggesting to enable CS 6417e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * stall on PIPE_CONTROLs with the texture cache invalidation bit set for 6427e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * GPGPU workloads because the previous and subsequent PIPE_CONTROLs 6437e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * already guarantee that there is no concurrent GPGPU kernel execution 6447e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * (see SKL HSD 2132585). 6457e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand */ 6467e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 6477e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.TextureCacheInvalidationEnable = true; 6487e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.ConstantCacheInvalidationEnable = true; 6497e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.InstructionCacheInvalidateEnable = true; 6507e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.StateCacheInvalidationEnable = true; 6517e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.PostSyncOperation = NoWrite; 6527e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand } 6537e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 6547e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* Now send a third stalling flush to make sure that invalidation is 6557e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * complete when the L3 configuration registers are modified. 6567e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand */ 6577e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 6587e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.DCFlushEnable = true; 6597e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.PostSyncOperation = NoWrite; 6607e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand pc.CommandStreamerStallEnable = true; 6617e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand } 6627e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 6637e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#if GEN_GEN >= 8 6647e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 6657e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand assert(!cfg->n[GEN_L3P_IS] && !cfg->n[GEN_L3P_C] && !cfg->n[GEN_L3P_T]); 6667e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 6677e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand uint32_t l3cr; 6687e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_pack_struct(&l3cr, GENX(L3CNTLREG), 6697e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .SLMEnable = has_slm, 6707e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .URBAllocation = cfg->n[GEN_L3P_URB], 6717e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ROAllocation = cfg->n[GEN_L3P_RO], 6727e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .DCAllocation = cfg->n[GEN_L3P_DC], 6737e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .AllAllocation = cfg->n[GEN_L3P_ALL]); 6747e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 6757e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* Set up the L3 partitioning. */ 6767e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand emit_lri(&cmd_buffer->batch, GENX(L3CNTLREG_num), l3cr); 6777e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 6787e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#else 6797e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 6807e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const bool has_dc = cfg->n[GEN_L3P_DC] || cfg->n[GEN_L3P_ALL]; 6817e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const bool has_is = cfg->n[GEN_L3P_IS] || cfg->n[GEN_L3P_RO] || 6827e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand cfg->n[GEN_L3P_ALL]; 6837e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const bool has_c = cfg->n[GEN_L3P_C] || cfg->n[GEN_L3P_RO] || 6847e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand cfg->n[GEN_L3P_ALL]; 6857e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const bool has_t = cfg->n[GEN_L3P_T] || cfg->n[GEN_L3P_RO] || 6867e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand cfg->n[GEN_L3P_ALL]; 6877e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 6887e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand assert(!cfg->n[GEN_L3P_ALL]); 6897e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 6907e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* When enabled SLM only uses a portion of the L3 on half of the banks, 6917e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * the matching space on the remaining banks has to be allocated to a 6927e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * client (URB for all validated configurations) set to the 6937e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * lower-bandwidth 2-bank address hashing mode. 6947e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand */ 6957e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const struct gen_device_info *devinfo = &cmd_buffer->device->info; 6967e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand const bool urb_low_bw = has_slm && !devinfo->is_baytrail; 6977e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand assert(!urb_low_bw || cfg->n[GEN_L3P_URB] == cfg->n[GEN_L3P_SLM]); 6987e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 6997e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* Minimum number of ways that can be allocated to the URB. */ 7003a1b15c3921d25ea2e6e81f500c3f45c84b95817Grazvydas Ignotas MAYBE_UNUSED const unsigned n0_urb = devinfo->is_baytrail ? 32 : 0; 7017e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand assert(cfg->n[GEN_L3P_URB] >= n0_urb); 7027e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7037e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand uint32_t l3sqcr1, l3cr2, l3cr3; 7047e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_pack_struct(&l3sqcr1, GENX(L3SQCREG1), 7057e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ConvertDC_UC = !has_dc, 7067e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ConvertIS_UC = !has_is, 7077e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ConvertC_UC = !has_c, 7087e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ConvertT_UC = !has_t); 7097e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand l3sqcr1 |= 7107e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand GEN_IS_HASWELL ? HSW_L3SQCREG1_SQGHPCI_DEFAULT : 7117e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand devinfo->is_baytrail ? VLV_L3SQCREG1_SQGHPCI_DEFAULT : 7127e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand IVB_L3SQCREG1_SQGHPCI_DEFAULT; 7137e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7147e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_pack_struct(&l3cr2, GENX(L3CNTLREG2), 7157e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .SLMEnable = has_slm, 7167e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .URBLowBandwidth = urb_low_bw, 7177e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .URBAllocation = cfg->n[GEN_L3P_URB], 7187e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#if !GEN_IS_HASWELL 7197e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ALLAllocation = cfg->n[GEN_L3P_ALL], 7207e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#endif 7217e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ROAllocation = cfg->n[GEN_L3P_RO], 7227e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .DCAllocation = cfg->n[GEN_L3P_DC]); 7237e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7247e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_pack_struct(&l3cr3, GENX(L3CNTLREG3), 7257e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ISAllocation = cfg->n[GEN_L3P_IS], 7267e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .ISLowBandwidth = 0, 7277e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .CAllocation = cfg->n[GEN_L3P_C], 7287e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .CLowBandwidth = 0, 7297e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .TAllocation = cfg->n[GEN_L3P_T], 7307e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .TLowBandwidth = 0); 7317e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7327e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* Set up the L3 partitioning. */ 7337e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand emit_lri(&cmd_buffer->batch, GENX(L3SQCREG1_num), l3sqcr1); 7347e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand emit_lri(&cmd_buffer->batch, GENX(L3CNTLREG2_num), l3cr2); 7357e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand emit_lri(&cmd_buffer->batch, GENX(L3CNTLREG3_num), l3cr3); 7367e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7377e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#if GEN_IS_HASWELL 7387e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand if (cmd_buffer->device->instance->physicalDevice.cmd_parser_version >= 4) { 7397e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand /* Enable L3 atomics on HSW if we have a DC partition, otherwise keep 7407e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand * them disabled to avoid crashing the system hard. 7417e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand */ 7427e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand uint32_t scratch1, chicken3; 7437e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_pack_struct(&scratch1, GENX(SCRATCH1), 7447e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .L3AtomicDisable = !has_dc); 7457e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand anv_pack_struct(&chicken3, GENX(CHICKEN3), 74689a96c8f43370cc84adf92ab32e3de302a1fa1d0Jason Ekstrand .L3AtomicDisableMask = true, 7477e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand .L3AtomicDisable = !has_dc); 7487e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand emit_lri(&cmd_buffer->batch, GENX(SCRATCH1_num), scratch1); 7497e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand emit_lri(&cmd_buffer->batch, GENX(CHICKEN3_num), chicken3); 7507e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand } 7517e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#endif 7527e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7537e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand#endif 7547e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7557e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand cmd_buffer->state.current_l3_config = cfg; 7567e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand} 7577e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand 7583a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrandvoid 7593a83c176eab8c513eb723554a240af1a7308d701Jason EkstrandgenX(cmd_buffer_apply_pipe_flushes)(struct anv_cmd_buffer *cmd_buffer) 7603a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand{ 7613a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand enum anv_pipe_bits bits = cmd_buffer->state.pending_pipe_bits; 7623a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 7633a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand /* Flushes are pipelined while invalidations are handled immediately. 7643a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * Therefore, if we're flushing anything then we need to schedule a stall 7653a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * before any invalidations can happen. 7663a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand */ 7673a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand if (bits & ANV_PIPE_FLUSH_BITS) 7683a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits |= ANV_PIPE_NEEDS_CS_STALL_BIT; 7693a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 7703a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand /* If we're going to do an invalidate and we have a pending CS stall that 7713a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * has yet to be resolved, we do the CS stall now. 7723a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand */ 7733a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand if ((bits & ANV_PIPE_INVALIDATE_BITS) && 7743a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand (bits & ANV_PIPE_NEEDS_CS_STALL_BIT)) { 7753a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits |= ANV_PIPE_CS_STALL_BIT; 7763a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits &= ~ANV_PIPE_NEEDS_CS_STALL_BIT; 7773a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand } 7783a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 7793a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand if (bits & (ANV_PIPE_FLUSH_BITS | ANV_PIPE_CS_STALL_BIT)) { 7803a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pipe) { 7813a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.DepthCacheFlushEnable = bits & ANV_PIPE_DEPTH_CACHE_FLUSH_BIT; 7823a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.DCFlushEnable = bits & ANV_PIPE_DATA_CACHE_FLUSH_BIT; 7833a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.RenderTargetCacheFlushEnable = 7843a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits & ANV_PIPE_RENDER_TARGET_CACHE_FLUSH_BIT; 7853a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 7863a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.DepthStallEnable = bits & ANV_PIPE_DEPTH_STALL_BIT; 7873a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.CommandStreamerStallEnable = bits & ANV_PIPE_CS_STALL_BIT; 7883a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.StallAtPixelScoreboard = bits & ANV_PIPE_STALL_AT_SCOREBOARD_BIT; 7893a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 7903a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand /* 7913a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * According to the Broadwell documentation, any PIPE_CONTROL with the 7923a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * "Command Streamer Stall" bit set must also have another bit set, 7933a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * with five different options: 7943a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * 7953a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * - Render Target Cache Flush 7963a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * - Depth Cache Flush 7973a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * - Stall at Pixel Scoreboard 7983a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * - Post-Sync Operation 7993a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * - Depth Stall 8003a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * - DC Flush Enable 8013a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * 8023a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * I chose "Stall at Pixel Scoreboard" since that's what we use in 8033a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand * mesa and it seems to work fine. The choice is fairly arbitrary. 8043a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand */ 8053a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand if ((bits & ANV_PIPE_CS_STALL_BIT) && 8063a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand !(bits & (ANV_PIPE_FLUSH_BITS | ANV_PIPE_DEPTH_STALL_BIT | 8073a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand ANV_PIPE_STALL_AT_SCOREBOARD_BIT))) 8083a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.StallAtPixelScoreboard = true; 8093a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand } 8103a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8113a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits &= ~(ANV_PIPE_FLUSH_BITS | ANV_PIPE_CS_STALL_BIT); 8123a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand } 8133a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8143a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand if (bits & ANV_PIPE_INVALIDATE_BITS) { 8153a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pipe) { 8163a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.StateCacheInvalidationEnable = 8173a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits & ANV_PIPE_STATE_CACHE_INVALIDATE_BIT; 8183a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.ConstantCacheInvalidationEnable = 8193a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits & ANV_PIPE_CONSTANT_CACHE_INVALIDATE_BIT; 8203a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.VFCacheInvalidationEnable = 8213a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits & ANV_PIPE_VF_CACHE_INVALIDATE_BIT; 8223a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.TextureCacheInvalidationEnable = 8233a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits & ANV_PIPE_TEXTURE_CACHE_INVALIDATE_BIT; 8243a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe.InstructionCacheInvalidateEnable = 8253a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits & ANV_PIPE_INSTRUCTION_CACHE_INVALIDATE_BIT; 8263a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand } 8273a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8283a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand bits &= ~ANV_PIPE_INVALIDATE_BITS; 8293a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand } 8303a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8313a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand cmd_buffer->state.pending_pipe_bits = bits; 8323a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand} 8333a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 8346f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrandvoid genX(CmdPipelineBarrier)( 835a89a485e79ad40793a85979d86d45760362be21aJason Ekstrand VkCommandBuffer commandBuffer, 8366f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand VkPipelineStageFlags srcStageMask, 8376f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand VkPipelineStageFlags destStageMask, 8386f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand VkBool32 byRegion, 839c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand uint32_t memoryBarrierCount, 840c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand const VkMemoryBarrier* pMemoryBarriers, 841c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand uint32_t bufferMemoryBarrierCount, 842c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand const VkBufferMemoryBarrier* pBufferMemoryBarriers, 843c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand uint32_t imageMemoryBarrierCount, 844c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand const VkImageMemoryBarrier* pImageMemoryBarriers) 8456f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand{ 846a89a485e79ad40793a85979d86d45760362be21aJason Ekstrand ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 8473a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand uint32_t b; 8486f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 8496f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand /* XXX: Right now, we're really dumb and just flush whatever categories 8506f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * the app asks for. One of these days we may make this a bit better 8516f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand * but right now that's all the hardware allows for in most areas. 8526f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand */ 853b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand VkAccessFlags src_flags = 0; 854b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand VkAccessFlags dst_flags = 0; 8556f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 856c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand for (uint32_t i = 0; i < memoryBarrierCount; i++) { 857c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand src_flags |= pMemoryBarriers[i].srcAccessMask; 858c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand dst_flags |= pMemoryBarriers[i].dstAccessMask; 859c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand } 860c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand 861c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand for (uint32_t i = 0; i < bufferMemoryBarrierCount; i++) { 862c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand src_flags |= pBufferMemoryBarriers[i].srcAccessMask; 863c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand dst_flags |= pBufferMemoryBarriers[i].dstAccessMask; 864c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand } 865c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand 866c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand for (uint32_t i = 0; i < imageMemoryBarrierCount; i++) { 867c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand src_flags |= pImageMemoryBarriers[i].srcAccessMask; 868c310fb032d406984e72895b6c94e2f96bff8e70dJason Ekstrand dst_flags |= pImageMemoryBarriers[i].dstAccessMask; 8696f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand } 8706f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 8713a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand enum anv_pipe_bits pipe_bits = 0; 8725e92e91c6177bfe31214b8a0ebd0d4c47969b61dKristian Høgsberg 873924fbfc9a1fc46a3698fa23649e6dccc3e3e6782Jason Ekstrand for_each_bit(b, src_flags) { 874b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand switch ((VkAccessFlagBits)(1 << b)) { 875b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_SHADER_WRITE_BIT: 8763a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_DATA_CACHE_FLUSH_BIT; 8776f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand break; 878b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT: 8793a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_RENDER_TARGET_CACHE_FLUSH_BIT; 8806f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand break; 881b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: 8823a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_DEPTH_CACHE_FLUSH_BIT; 8836f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand break; 884b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_TRANSFER_WRITE_BIT: 8853a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_RENDER_TARGET_CACHE_FLUSH_BIT; 8863a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_DEPTH_CACHE_FLUSH_BIT; 8876f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand break; 8886f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand default: 8893a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand break; /* Nothing to do */ 8906f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand } 8916f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand } 8926f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 893924fbfc9a1fc46a3698fa23649e6dccc3e3e6782Jason Ekstrand for_each_bit(b, dst_flags) { 894b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand switch ((VkAccessFlagBits)(1 << b)) { 895b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_INDIRECT_COMMAND_READ_BIT: 896b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_INDEX_READ_BIT: 897b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT: 8983a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_VF_CACHE_INVALIDATE_BIT; 8996f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand break; 900b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_UNIFORM_READ_BIT: 9013a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_CONSTANT_CACHE_INVALIDATE_BIT; 9023a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_TEXTURE_CACHE_INVALIDATE_BIT; 9036f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand break; 9043a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand case VK_ACCESS_SHADER_READ_BIT: 90557174d60421e9e63569335a269cd806703f5da5dJason Ekstrand case VK_ACCESS_INPUT_ATTACHMENT_READ_BIT: 906b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand case VK_ACCESS_TRANSFER_READ_BIT: 9073a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand pipe_bits |= ANV_PIPE_TEXTURE_CACHE_INVALIDATE_BIT; 908b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand break; 909b1cd025b88e3651fac8dd2f7861516f653422ee4Jason Ekstrand default: 9103a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand break; /* Nothing to do */ 9116f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand } 9126f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand } 9136f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand 9143a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand cmd_buffer->state.pending_pipe_bits |= pipe_bits; 9156f613abc2bf8fc3cf70c51a1d569bc4eb9dd18afJason Ekstrand} 916bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 91754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrandstatic void 91854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrandcmd_buffer_alloc_push_constants(struct anv_cmd_buffer *cmd_buffer) 91954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand{ 92054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand VkShaderStageFlags stages = cmd_buffer->state.pipeline->active_stages; 92154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 92254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand /* In order to avoid thrash, we assume that vertex and fragment stages 92354324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * always exist. In the rare case where one is missing *and* the other 92454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * uses push concstants, this may be suboptimal. However, avoiding stalls 92554324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * seems more important. 92654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand */ 92754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand stages |= VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_VERTEX_BIT; 92854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 92954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand if (stages == cmd_buffer->state.push_constant_stages) 93054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand return; 93154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 93254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand#if GEN_GEN >= 8 93354324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand const unsigned push_constant_kb = 32; 93454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand#elif GEN_IS_HASWELL 93554324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand const unsigned push_constant_kb = cmd_buffer->device->info.gt == 3 ? 32 : 16; 93654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand#else 93754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand const unsigned push_constant_kb = 16; 93854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand#endif 93954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 94054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand const unsigned num_stages = 94154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand _mesa_bitcount(stages & VK_SHADER_STAGE_ALL_GRAPHICS); 94254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand unsigned size_per_stage = push_constant_kb / num_stages; 94354324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 94454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand /* Broadwell+ and Haswell gt3 require that the push constant sizes be in 94554324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * units of 2KB. Incidentally, these are the same platforms that have 94654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * 32KB worth of push constant space. 94754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand */ 94854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand if (push_constant_kb == 32) 94954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand size_per_stage &= ~1u; 95054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 95154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand uint32_t kb_used = 0; 95254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand for (int i = MESA_SHADER_VERTEX; i < MESA_SHADER_FRAGMENT; i++) { 95354324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand unsigned push_size = (stages & (1 << i)) ? size_per_stage : 0; 95454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, 95554324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand GENX(3DSTATE_PUSH_CONSTANT_ALLOC_VS), alloc) { 95654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand alloc._3DCommandSubOpcode = 18 + i; 95754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand alloc.ConstantBufferOffset = (push_size > 0) ? kb_used : 0; 95854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand alloc.ConstantBufferSize = push_size; 95954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand } 96054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand kb_used += push_size; 96154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand } 96254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 96354324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, 96454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand GENX(3DSTATE_PUSH_CONSTANT_ALLOC_PS), alloc) { 96554324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand alloc.ConstantBufferOffset = kb_used; 96654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand alloc.ConstantBufferSize = push_constant_kb - kb_used; 96754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand } 96854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 96954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand cmd_buffer->state.push_constant_stages = stages; 97054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 97154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand /* From the BDW PRM for 3DSTATE_PUSH_CONSTANT_ALLOC_VS: 97254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * 97354324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * "The 3DSTATE_CONSTANT_VS must be reprogrammed prior to 97454324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * the next 3DPRIMITIVE command after programming the 97554324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * 3DSTATE_PUSH_CONSTANT_ALLOC_VS" 97654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * 97754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * Since 3DSTATE_PUSH_CONSTANT_ALLOC_VS is programmed as part of 97854324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * pipeline setup, we need to dirty push constants. 97954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand */ 98054324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand cmd_buffer->state.push_constants_dirty |= VK_SHADER_STAGE_ALL_GRAPHICS; 98154324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand} 98254324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand 9837998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandstatic VkResult 9847998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandemit_binding_table(struct anv_cmd_buffer *cmd_buffer, 9857998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand gl_shader_stage stage, 9867998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_state *bt_state) 9877998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand{ 9887998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_subpass *subpass = cmd_buffer->state.subpass; 9897998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_pipeline *pipeline; 9907998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t bias, state_offset; 9917998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 9927998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand switch (stage) { 9937998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case MESA_SHADER_COMPUTE: 9947998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand pipeline = cmd_buffer->state.compute_pipeline; 9957998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand bias = 1; 9967998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 9977998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand default: 9987998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand pipeline = cmd_buffer->state.pipeline; 9997998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand bias = 0; 10007998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 10017998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 10027998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10037998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (!anv_pipeline_has_stage(pipeline, stage)) { 10047998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *bt_state = (struct anv_state) { 0, }; 10057998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_SUCCESS; 10067998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 10077998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10087998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_pipeline_bind_map *map = &pipeline->shaders[stage]->bind_map; 10097998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (bias + map->surface_count == 0) { 10107998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *bt_state = (struct anv_state) { 0, }; 10117998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_SUCCESS; 10127998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 10137998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10147998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *bt_state = anv_cmd_buffer_alloc_binding_table(cmd_buffer, 10157998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand bias + map->surface_count, 10167998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand &state_offset); 10177998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t *bt_map = bt_state->map; 10187998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10197998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (bt_state->map == NULL) 10207998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_ERROR_OUT_OF_DEVICE_MEMORY; 10217998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10227998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (stage == MESA_SHADER_COMPUTE && 10237998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand get_cs_prog_data(cmd_buffer->state.compute_pipeline)->uses_num_work_groups) { 10247998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_bo *bo = cmd_buffer->state.num_workgroups_bo; 10257998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t bo_offset = cmd_buffer->state.num_workgroups_offset; 10267998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10277998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_state surface_state; 10287998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand surface_state = 10297998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_cmd_buffer_alloc_surface_state(cmd_buffer); 10307998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10317998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand const enum isl_format format = 10327998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_isl_format_for_descriptor_type(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER); 10337998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_fill_buffer_surface_state(cmd_buffer->device, surface_state, 10347998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand format, bo_offset, 12, 1); 10357998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10367998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand bt_map[0] = surface_state.offset + state_offset; 10379be9f5f1c71a5c8942b1f41d0512479a9899df42Jason Ekstrand add_surface_state_reloc(cmd_buffer, surface_state, bo, bo_offset); 10387998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 10397998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10407998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (map->surface_count == 0) 10417998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand goto out; 10427998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10437998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (map->image_count > 0) { 10447998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand VkResult result = 10457998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_cmd_buffer_ensure_push_constant_field(cmd_buffer, stage, images); 10467998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (result != VK_SUCCESS) 10477998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return result; 10487998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10497998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand cmd_buffer->state.push_constants_dirty |= 1 << stage; 10507998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 10517998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10527998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t image = 0; 10537998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand for (uint32_t s = 0; s < map->surface_count; s++) { 10547998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_pipeline_binding *binding = &map->surface_to_descriptor[s]; 10557998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10567998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_state surface_state; 10577998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10587998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (binding->set == ANV_DESCRIPTOR_SET_COLOR_ATTACHMENTS) { 10597998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand /* Color attachment binding */ 10607998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(stage == MESA_SHADER_FRAGMENT); 10617998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(binding->binding == 0); 10627998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (binding->index < subpass->color_count) { 1063d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand const unsigned att = subpass->color_attachments[binding->index]; 1064d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand surface_state = cmd_buffer->state.attachments[att].color_rt_state; 10657998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } else { 1066d2b4a9da038a200db3c5c61a11d5ea451cc6cc98Jason Ekstrand surface_state = cmd_buffer->state.null_surface_state; 10677998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 10687998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10697998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand bt_map[bias + s] = surface_state.offset + state_offset; 10707998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand continue; 10717998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 10727998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10737998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_descriptor_set *set = 10747998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand cmd_buffer->state.descriptors[binding->set]; 10757998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t offset = set->layout->binding[binding->binding].descriptor_index; 10767998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_descriptor *desc = &set->descriptors[offset + binding->index]; 10777998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10787998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand switch (desc->type) { 10797998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_SAMPLER: 10807998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand /* Nothing for us to do here */ 10817998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand continue; 10827998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10837998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: 10847998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: 10857998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand surface_state = desc->image_view->sampler_surface_state; 10867998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(surface_state.alloc_size); 1087338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand add_image_view_relocs(cmd_buffer, desc->image_view, 1088edb7f67bd9c320cd47af20dc0a854e65fced7d9bJason Ekstrand desc->image_view->image->aux_usage, 1089edb7f67bd9c320cd47af20dc0a854e65fced7d9bJason Ekstrand surface_state); 10907998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 10917998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 10921d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: 10931d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand assert(stage == MESA_SHADER_FRAGMENT); 10941d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand if (desc->image_view->aspect_mask == VK_IMAGE_ASPECT_STENCIL_BIT) { 10951d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand /* For stencil input attachments, we treat it like any old texture 10961d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand * that a user may have bound. 10971d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand */ 10981d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand surface_state = desc->image_view->sampler_surface_state; 10991d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand assert(surface_state.alloc_size); 11001d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand add_image_view_relocs(cmd_buffer, desc->image_view, 11011d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand desc->image_view->image->aux_usage, 11021d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand surface_state); 11031d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand } else { 11041d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand /* For depth and color input attachments, we create the surface 11051d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand * state at vkBeginRenderPass time so that we can include aux 11061d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand * and clear color information. 11071d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand */ 11081d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand assert(binding->input_attachment_index < subpass->input_count); 11091d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand const unsigned subpass_att = binding->input_attachment_index; 11101d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand const unsigned att = subpass->input_attachments[subpass_att]; 11111d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand surface_state = cmd_buffer->state.attachments[att].input_att_state; 11121d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand } 11131d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand break; 11141d5ac0a462ac8c7f41e1e1adb1fc5a7db6038d17Jason Ekstrand 11157998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: { 11167998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand surface_state = desc->image_view->storage_surface_state; 11177998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(surface_state.alloc_size); 1118338cdc172a28266b062794084efb7745f07b02a7Jason Ekstrand add_image_view_relocs(cmd_buffer, desc->image_view, 1119edb7f67bd9c320cd47af20dc0a854e65fced7d9bJason Ekstrand desc->image_view->image->aux_usage, 1120edb7f67bd9c320cd47af20dc0a854e65fced7d9bJason Ekstrand surface_state); 11217998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11227998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct brw_image_param *image_param = 11237998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand &cmd_buffer->state.push_constants[stage]->images[image++]; 11247998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11257998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *image_param = desc->image_view->storage_image_param; 11267998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand image_param->surface_idx = bias + s; 11277998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 11287998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 11297998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11307998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: 11317998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: 11327998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: 11337998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: 11347998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: 11357998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand surface_state = desc->buffer_view->surface_state; 11367998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(surface_state.alloc_size); 1137818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand add_surface_state_reloc(cmd_buffer, surface_state, 1138818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand desc->buffer_view->bo, 1139818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand desc->buffer_view->offset); 11407998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 11417998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11427998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: 11437998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand surface_state = desc->buffer_view->storage_surface_state; 11447998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(surface_state.alloc_size); 1145818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand add_surface_state_reloc(cmd_buffer, surface_state, 1146818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand desc->buffer_view->bo, 1147818c7bfb313014eb2c37bf40753524149ae1230dJason Ekstrand desc->buffer_view->offset); 11487998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11497998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct brw_image_param *image_param = 11507998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand &cmd_buffer->state.push_constants[stage]->images[image++]; 11517998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11527998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *image_param = desc->buffer_view->storage_image_param; 11537998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand image_param->surface_idx = bias + s; 11547998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 11557998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11567998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand default: 11577998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(!"Invalid descriptor type"); 11587998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand continue; 11597998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 11607998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11617998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand bt_map[bias + s] = surface_state.offset + state_offset; 11627998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 11637998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(image == map->image_count); 11647998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11657998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand out: 11667998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (!cmd_buffer->device->info.has_llc) 11677998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_state_clflush(*bt_state); 11687998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11697998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_SUCCESS; 11707998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand} 11717998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11727998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandstatic VkResult 11737998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandemit_samplers(struct anv_cmd_buffer *cmd_buffer, 11747998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand gl_shader_stage stage, 11757998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_state *state) 11767998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand{ 11777998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_pipeline *pipeline; 11787998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11797998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (stage == MESA_SHADER_COMPUTE) 11807998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand pipeline = cmd_buffer->state.compute_pipeline; 11817998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand else 11827998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand pipeline = cmd_buffer->state.pipeline; 11837998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11847998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (!anv_pipeline_has_stage(pipeline, stage)) { 11857998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *state = (struct anv_state) { 0, }; 11867998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_SUCCESS; 11877998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 11887998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11897998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_pipeline_bind_map *map = &pipeline->shaders[stage]->bind_map; 11907998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (map->sampler_count == 0) { 11917998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *state = (struct anv_state) { 0, }; 11927998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_SUCCESS; 11937998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 11947998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11957998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t size = map->sampler_count * 16; 11967998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand *state = anv_cmd_buffer_alloc_dynamic_state(cmd_buffer, size, 32); 11977998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 11987998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (state->map == NULL) 11997998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_ERROR_OUT_OF_DEVICE_MEMORY; 12007998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12017998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand for (uint32_t s = 0; s < map->sampler_count; s++) { 12027998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_pipeline_binding *binding = &map->sampler_to_descriptor[s]; 12037998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_descriptor_set *set = 12047998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand cmd_buffer->state.descriptors[binding->set]; 12057998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand uint32_t offset = set->layout->binding[binding->binding].descriptor_index; 12067998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_descriptor *desc = &set->descriptors[offset + binding->index]; 12077998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12087998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (desc->type != VK_DESCRIPTOR_TYPE_SAMPLER && 12097998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand desc->type != VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) 12107998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand continue; 12117998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12127998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand struct anv_sampler *sampler = desc->sampler; 12137998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12147998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand /* This can happen if we have an unfilled slot since TYPE_SAMPLER 12157998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand * happens to be zero. 12167998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand */ 12177998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (sampler == NULL) 12187998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand continue; 12197998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12207998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand memcpy(state->map + (s * 16), 12217998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand sampler->state, sizeof(sampler->state)); 12227998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 12237998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12247998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (!cmd_buffer->device->info.has_llc) 12257998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_state_clflush(*state); 12267998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12277998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return VK_SUCCESS; 12287998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand} 12297998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12307998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandstatic uint32_t 12317998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandflush_descriptor_sets(struct anv_cmd_buffer *cmd_buffer) 12327998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand{ 12337998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand VkShaderStageFlags dirty = cmd_buffer->state.descriptors_dirty & 12347998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand cmd_buffer->state.pipeline->active_stages; 12357998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12367998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand VkResult result = VK_SUCCESS; 12377998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_foreach_stage(s, dirty) { 12387998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand result = emit_samplers(cmd_buffer, s, &cmd_buffer->state.samplers[s]); 12397998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (result != VK_SUCCESS) 12407998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 12417998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand result = emit_binding_table(cmd_buffer, s, 12427998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand &cmd_buffer->state.binding_tables[s]); 12437998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (result != VK_SUCCESS) 12447998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand break; 12457998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 12467998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12477998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (result != VK_SUCCESS) { 12487998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(result == VK_ERROR_OUT_OF_DEVICE_MEMORY); 12497998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12507998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand result = anv_cmd_buffer_new_binding_table_block(cmd_buffer); 12517998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand assert(result == VK_SUCCESS); 12527998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12537998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand /* Re-emit state base addresses so we get the new surface state base 12547998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand * address before we start emitting binding tables etc. 12557998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand */ 12567998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand genX(cmd_buffer_emit_state_base_address)(cmd_buffer); 12577998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12587998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand /* Re-emit all active binding tables */ 12597998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand dirty |= cmd_buffer->state.pipeline->active_stages; 12607998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand anv_foreach_stage(s, dirty) { 12617998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand result = emit_samplers(cmd_buffer, s, &cmd_buffer->state.samplers[s]); 12627998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (result != VK_SUCCESS) 12637998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return result; 12647998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand result = emit_binding_table(cmd_buffer, s, 12657998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand &cmd_buffer->state.binding_tables[s]); 12667998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand if (result != VK_SUCCESS) 12677998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return result; 12687998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 12697998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand } 12707998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12717998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand cmd_buffer->state.descriptors_dirty &= ~dirty; 12727998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12737998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand return dirty; 12747998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand} 12757998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand 12767998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrandstatic void 12772bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrandcmd_buffer_emit_descriptor_pointers(struct anv_cmd_buffer *cmd_buffer, 12782bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand uint32_t stages) 12792bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand{ 12802bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand static const uint32_t sampler_state_opcodes[] = { 12812bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_VERTEX] = 43, 12822bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_TESS_CTRL] = 44, /* HS */ 12832bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_TESS_EVAL] = 45, /* DS */ 12842bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_GEOMETRY] = 46, 12852bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_FRAGMENT] = 47, 12862bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_COMPUTE] = 0, 12872bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand }; 12882bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand 12892bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand static const uint32_t binding_table_opcodes[] = { 12902bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_VERTEX] = 38, 12912bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_TESS_CTRL] = 39, 12922bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_TESS_EVAL] = 40, 12932bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_GEOMETRY] = 41, 12942bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_FRAGMENT] = 42, 12952bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand [MESA_SHADER_COMPUTE] = 0, 12962bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand }; 12972bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand 12982bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand anv_foreach_stage(s, stages) { 12992bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand if (cmd_buffer->state.samplers[s].alloc_size > 0) { 13002bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand anv_batch_emit(&cmd_buffer->batch, 13012bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand GENX(3DSTATE_SAMPLER_STATE_POINTERS_VS), ssp) { 13022bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand ssp._3DCommandSubOpcode = sampler_state_opcodes[s]; 13032bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand ssp.PointertoVSSamplerState = cmd_buffer->state.samplers[s].offset; 13042bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand } 13052bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand } 13062bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand 13072bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand /* Always emit binding table pointers if we're asked to, since on SKL 13082bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand * this is what flushes push constants. */ 13092bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand anv_batch_emit(&cmd_buffer->batch, 13102bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand GENX(3DSTATE_BINDING_TABLE_POINTERS_VS), btp) { 13112bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand btp._3DCommandSubOpcode = binding_table_opcodes[s]; 13122bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand btp.PointertoVSBindingTable = cmd_buffer->state.binding_tables[s].offset; 13132bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand } 13142bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand } 13152bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand} 13162bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand 1317248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrandstatic uint32_t 1318248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrandcmd_buffer_flush_push_constants(struct anv_cmd_buffer *cmd_buffer) 1319248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand{ 1320248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand static const uint32_t push_constant_opcodes[] = { 1321248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand [MESA_SHADER_VERTEX] = 21, 1322248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand [MESA_SHADER_TESS_CTRL] = 25, /* HS */ 1323248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand [MESA_SHADER_TESS_EVAL] = 26, /* DS */ 1324248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand [MESA_SHADER_GEOMETRY] = 22, 1325248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand [MESA_SHADER_FRAGMENT] = 23, 1326248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand [MESA_SHADER_COMPUTE] = 0, 1327248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand }; 1328248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1329248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand VkShaderStageFlags flushed = 0; 1330248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1331248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand anv_foreach_stage(stage, cmd_buffer->state.push_constants_dirty) { 1332248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (stage == MESA_SHADER_COMPUTE) 1333248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand continue; 1334248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1335248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand struct anv_state state = anv_cmd_buffer_push_constants(cmd_buffer, stage); 1336248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1337248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (state.offset == 0) { 133850018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_CONSTANT_VS), c) 133906fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand c._3DCommandSubOpcode = push_constant_opcodes[stage]; 1340248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } else { 134150018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_CONSTANT_VS), c) { 134206fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand c._3DCommandSubOpcode = push_constant_opcodes[stage], 134306fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand c.ConstantBody = (struct GENX(3DSTATE_CONSTANT_BODY)) { 1344248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#if GEN_GEN >= 9 134506fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand .PointerToConstantBuffer2 = { &cmd_buffer->device->dynamic_state_block_pool.bo, state.offset }, 134606fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand .ConstantBuffer2ReadLength = DIV_ROUND_UP(state.alloc_size, 32), 1347248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#else 134806fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand .PointerToConstantBuffer0 = { .offset = state.offset }, 134906fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand .ConstantBuffer0ReadLength = DIV_ROUND_UP(state.alloc_size, 32), 1350248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#endif 135106fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand }; 135206fc7fa6842a5b36ed2a16d5a7ca72e516d5b245Jason Ekstrand } 1353248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1354248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1355248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand flushed |= mesa_to_vk_shader_stage(stage); 1356248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1357248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1358248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand cmd_buffer->state.push_constants_dirty &= ~VK_SHADER_STAGE_ALL_GRAPHICS; 1359248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1360248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand return flushed; 1361248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand} 1362248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1363248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrandvoid 1364248ab61740c4082517424f5aa94b2f4e7b210d76Jason EkstrandgenX(cmd_buffer_flush_state)(struct anv_cmd_buffer *cmd_buffer) 1365248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand{ 1366248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand struct anv_pipeline *pipeline = cmd_buffer->state.pipeline; 1367248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand uint32_t *p; 1368248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1369248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand uint32_t vb_emit = cmd_buffer->state.vb_dirty & pipeline->vb_used; 1370248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1371248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand assert((pipeline->active_stages & VK_SHADER_STAGE_COMPUTE_BIT) == 0); 1372248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 13737e891f90c701aa1c851f1846857daa75bbb65876Jason Ekstrand genX(cmd_buffer_config_l3)(cmd_buffer, pipeline->urb.l3_config); 1374248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1375248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand genX(flush_pipeline_select_3d)(cmd_buffer); 1376248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1377248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (vb_emit) { 1378248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand const uint32_t num_buffers = __builtin_popcount(vb_emit); 1379248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand const uint32_t num_dwords = 1 + num_buffers * 4; 1380248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1381248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand p = anv_batch_emitn(&cmd_buffer->batch, num_dwords, 1382248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand GENX(3DSTATE_VERTEX_BUFFERS)); 1383248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand uint32_t vb, i = 0; 1384248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand for_each_bit(vb, vb_emit) { 1385248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand struct anv_buffer *buffer = cmd_buffer->state.vertex_bindings[vb].buffer; 1386248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand uint32_t offset = cmd_buffer->state.vertex_bindings[vb].offset; 1387248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1388248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand struct GENX(VERTEX_BUFFER_STATE) state = { 1389248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .VertexBufferIndex = vb, 1390248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1391248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#if GEN_GEN >= 8 1392248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .MemoryObjectControlState = GENX(MOCS), 1393248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#else 1394248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .BufferAccessType = pipeline->instancing_enable[vb] ? INSTANCEDATA : VERTEXDATA, 1395248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .InstanceDataStepRate = 1, 1396248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .VertexBufferMemoryObjectControlState = GENX(MOCS), 1397248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#endif 1398248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1399248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .AddressModifyEnable = true, 1400248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .BufferPitch = pipeline->binding_stride[vb], 1401248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .BufferStartingAddress = { buffer->bo, buffer->offset + offset }, 1402248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1403248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#if GEN_GEN >= 8 1404248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .BufferSize = buffer->size - offset 1405248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#else 1406248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand .EndAddress = { buffer->bo, buffer->offset + buffer->size - 1}, 1407248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#endif 1408248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand }; 1409248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1410248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand GENX(VERTEX_BUFFER_STATE_pack)(&cmd_buffer->batch, &p[1 + i * 4], &state); 1411248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand i++; 1412248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1413248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1414248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1415248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand cmd_buffer->state.vb_dirty &= ~vb_emit; 1416248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1417248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (cmd_buffer->state.dirty & ANV_CMD_DIRTY_PIPELINE) { 1418248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand anv_batch_emit_batch(&cmd_buffer->batch, &pipeline->batch); 1419248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 142035b53c8d47d3a0b53ee2549d73296d5db8e3cca0Jason Ekstrand /* The exact descriptor layout is pulled from the pipeline, so we need 142135b53c8d47d3a0b53ee2549d73296d5db8e3cca0Jason Ekstrand * to re-emit binding tables on every pipeline change. 142235b53c8d47d3a0b53ee2549d73296d5db8e3cca0Jason Ekstrand */ 142335b53c8d47d3a0b53ee2549d73296d5db8e3cca0Jason Ekstrand cmd_buffer->state.descriptors_dirty |= 142435b53c8d47d3a0b53ee2549d73296d5db8e3cca0Jason Ekstrand cmd_buffer->state.pipeline->active_stages; 142535b53c8d47d3a0b53ee2549d73296d5db8e3cca0Jason Ekstrand 142654324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand /* If the pipeline changed, we may need to re-allocate push constant 142754324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand * space in the URB. 1428248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand */ 142954324877926caa28b8ebd89d95b4e7c2447d17b8Jason Ekstrand cmd_buffer_alloc_push_constants(cmd_buffer); 1430248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1431248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1432248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#if GEN_GEN <= 7 1433248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (cmd_buffer->state.descriptors_dirty & VK_SHADER_STAGE_VERTEX_BIT || 1434248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand cmd_buffer->state.push_constants_dirty & VK_SHADER_STAGE_VERTEX_BIT) { 1435248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand /* From the IVB PRM Vol. 2, Part 1, Section 3.2.1: 1436248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * 1437248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * "A PIPE_CONTROL with Post-Sync Operation set to 1h and a depth 1438248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * stall needs to be sent just prior to any 3DSTATE_VS, 1439248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * 3DSTATE_URB_VS, 3DSTATE_CONSTANT_VS, 1440248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * 3DSTATE_BINDING_TABLE_POINTER_VS, 1441248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * 3DSTATE_SAMPLER_STATE_POINTER_VS command. Only one 1442248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * PIPE_CONTROL needs to be sent before any combination of VS 1443248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * associated 3DSTATE." 1444248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand */ 144550018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 144656453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DepthStallEnable = true; 144756453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.PostSyncOperation = WriteImmediateData; 144856453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.Address = 144956453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand (struct anv_address) { &cmd_buffer->device->workaround_bo, 0 }; 145056453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 1451248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1452248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#endif 1453248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1454fe4e276b02615b5db8acbf4c65fcfa68982e2e0fJason Ekstrand /* Render targets live in the same binding table as fragment descriptors */ 1455fe4e276b02615b5db8acbf4c65fcfa68982e2e0fJason Ekstrand if (cmd_buffer->state.dirty & ANV_CMD_DIRTY_RENDER_TARGETS) 1456fe4e276b02615b5db8acbf4c65fcfa68982e2e0fJason Ekstrand cmd_buffer->state.descriptors_dirty |= VK_SHADER_STAGE_FRAGMENT_BIT; 1457fe4e276b02615b5db8acbf4c65fcfa68982e2e0fJason Ekstrand 1458248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand /* We emit the binding tables and sampler tables first, then emit push 1459248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * constants and then finally emit binding table and sampler table 1460248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * pointers. It has to happen in this order, since emitting the binding 1461248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * tables may change the push constants (in case of storage images). After 1462248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * emitting push constants, on SKL+ we have to emit the corresponding 1463248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * 3DSTATE_BINDING_TABLE_POINTER_* for the push constants to take effect. 1464248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand */ 1465248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand uint32_t dirty = 0; 1466248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (cmd_buffer->state.descriptors_dirty) 14677998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand dirty = flush_descriptor_sets(cmd_buffer); 1468248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1469248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (cmd_buffer->state.push_constants_dirty) { 1470248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#if GEN_GEN >= 9 1471248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand /* On Sky Lake and later, the binding table pointers commands are 1472248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * what actually flush the changes to push constant state so we need 1473248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand * to dirty them so they get re-emitted below. 1474248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand */ 1475248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand dirty |= cmd_buffer_flush_push_constants(cmd_buffer); 1476248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#else 1477248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand cmd_buffer_flush_push_constants(cmd_buffer); 1478248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand#endif 1479248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand } 1480248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1481248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (dirty) 14822bfe0c33748b9fd96d48cb93656b6dc643bf024eJason Ekstrand cmd_buffer_emit_descriptor_pointers(cmd_buffer, dirty); 1483248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1484eb6764c4a73006eee32e19e3afc6eab100a2ce16Jason Ekstrand if (cmd_buffer->state.dirty & ANV_CMD_DIRTY_DYNAMIC_VIEWPORT) 1485248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand gen8_cmd_buffer_emit_viewport(cmd_buffer); 1486eb6764c4a73006eee32e19e3afc6eab100a2ce16Jason Ekstrand 1487eb6764c4a73006eee32e19e3afc6eab100a2ce16Jason Ekstrand if (cmd_buffer->state.dirty & (ANV_CMD_DIRTY_DYNAMIC_VIEWPORT | 1488eb6764c4a73006eee32e19e3afc6eab100a2ce16Jason Ekstrand ANV_CMD_DIRTY_PIPELINE)) { 1489eb6764c4a73006eee32e19e3afc6eab100a2ce16Jason Ekstrand gen8_cmd_buffer_emit_depth_viewport(cmd_buffer, 1490eb6764c4a73006eee32e19e3afc6eab100a2ce16Jason Ekstrand pipeline->depth_clamp_enable); 14918a46b505cb2c7255ad430b56c1ce0dfa9c13c559Jason Ekstrand } 1492248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1493248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand if (cmd_buffer->state.dirty & ANV_CMD_DIRTY_DYNAMIC_SCISSOR) 1494248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand gen7_cmd_buffer_emit_scissor(cmd_buffer); 1495248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1496248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand genX(cmd_buffer_flush_dynamic_state)(cmd_buffer); 14973a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand 14983a83c176eab8c513eb723554a240af1a7308d701Jason Ekstrand genX(cmd_buffer_apply_pipe_flushes)(cmd_buffer); 1499248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand} 1500248ab61740c4082517424f5aa94b2f4e7b210d76Jason Ekstrand 1501bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergstatic void 1502bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergemit_base_vertex_instance_bo(struct anv_cmd_buffer *cmd_buffer, 1503bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_bo *bo, uint32_t offset) 1504bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg{ 1505bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t *p = anv_batch_emitn(&cmd_buffer->batch, 5, 1506bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg GENX(3DSTATE_VERTEX_BUFFERS)); 1507bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1508bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg GENX(VERTEX_BUFFER_STATE_pack)(&cmd_buffer->batch, p + 1, 1509bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg &(struct GENX(VERTEX_BUFFER_STATE)) { 1510bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .VertexBufferIndex = 32, /* Reserved for this */ 1511bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .AddressModifyEnable = true, 1512bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .BufferPitch = 0, 1513371b4a5b33a13f35fa7783510d2d90685a9a2e8aJason Ekstrand#if (GEN_GEN >= 8) 1514bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .MemoryObjectControlState = GENX(MOCS), 1515bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .BufferStartingAddress = { bo, offset }, 1516bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .BufferSize = 8 1517bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#else 1518bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .VertexBufferMemoryObjectControlState = GENX(MOCS), 1519bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .BufferStartingAddress = { bo, offset }, 1520bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg .EndAddress = { bo, offset + 8 }, 1521bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#endif 1522bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg }); 1523bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg} 1524bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1525bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergstatic void 1526bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergemit_base_vertex_instance(struct anv_cmd_buffer *cmd_buffer, 1527bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t base_vertex, uint32_t base_instance) 1528bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg{ 1529bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_state id_state = 1530bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg anv_cmd_buffer_alloc_dynamic_state(cmd_buffer, 8, 4); 1531bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1532bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ((uint32_t *)id_state.map)[0] = base_vertex; 1533bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ((uint32_t *)id_state.map)[1] = base_instance; 1534bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1535bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg if (!cmd_buffer->device->info.has_llc) 1536bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg anv_state_clflush(id_state); 1537bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1538bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_base_vertex_instance_bo(cmd_buffer, 1539bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg &cmd_buffer->device->dynamic_state_block_pool.bo, id_state.offset); 1540bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg} 1541bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1542bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergvoid genX(CmdDraw)( 1543bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkCommandBuffer commandBuffer, 1544bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t vertexCount, 1545bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t instanceCount, 1546bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t firstVertex, 1547bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t firstInstance) 1548bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg{ 1549bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 1550bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_pipeline *pipeline = cmd_buffer->state.pipeline; 15512b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg const struct brw_vs_prog_data *vs_prog_data = get_vs_prog_data(pipeline); 1552bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1553bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg genX(cmd_buffer_flush_state)(cmd_buffer); 1554bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 15552b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg if (vs_prog_data->uses_basevertex || vs_prog_data->uses_baseinstance) 1556bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_base_vertex_instance(cmd_buffer, firstVertex, firstInstance); 1557bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 155850018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DPRIMITIVE), prim) { 15591d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.VertexAccessType = SEQUENTIAL; 15601d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.PrimitiveTopologyType = pipeline->topology; 15611d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.VertexCountPerInstance = vertexCount; 15621d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.StartVertexLocation = firstVertex; 15631d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.InstanceCount = instanceCount; 15641d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.StartInstanceLocation = firstInstance; 15651d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.BaseVertexLocation = 0; 15661d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand } 1567bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg} 1568bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1569bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergvoid genX(CmdDrawIndexed)( 1570bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkCommandBuffer commandBuffer, 1571bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t indexCount, 1572bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t instanceCount, 1573bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t firstIndex, 1574bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg int32_t vertexOffset, 1575bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t firstInstance) 1576bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg{ 1577bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 1578bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_pipeline *pipeline = cmd_buffer->state.pipeline; 15792b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg const struct brw_vs_prog_data *vs_prog_data = get_vs_prog_data(pipeline); 1580bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1581bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg genX(cmd_buffer_flush_state)(cmd_buffer); 1582bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 15832b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg if (vs_prog_data->uses_basevertex || vs_prog_data->uses_baseinstance) 1584bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_base_vertex_instance(cmd_buffer, vertexOffset, firstInstance); 1585bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 158650018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DPRIMITIVE), prim) { 15871d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.VertexAccessType = RANDOM; 15881d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.PrimitiveTopologyType = pipeline->topology; 15891d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.VertexCountPerInstance = indexCount; 15901d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.StartVertexLocation = firstIndex; 15911d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.InstanceCount = instanceCount; 15921d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.StartInstanceLocation = firstInstance; 15931d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.BaseVertexLocation = vertexOffset; 15941d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand } 1595bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg} 1596bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1597bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg/* Auto-Draw / Indirect Registers */ 1598bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#define GEN7_3DPRIM_END_OFFSET 0x2420 1599bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#define GEN7_3DPRIM_START_VERTEX 0x2430 1600bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#define GEN7_3DPRIM_VERTEX_COUNT 0x2434 1601bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#define GEN7_3DPRIM_INSTANCE_COUNT 0x2438 1602bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#define GEN7_3DPRIM_START_INSTANCE 0x243C 1603bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg#define GEN7_3DPRIM_BASE_VERTEX 0x2440 1604bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1605bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergvoid genX(CmdDrawIndirect)( 1606bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkCommandBuffer commandBuffer, 1607bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkBuffer _buffer, 1608bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkDeviceSize offset, 1609bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t drawCount, 1610bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t stride) 1611bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg{ 1612bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 1613bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ANV_FROM_HANDLE(anv_buffer, buffer, _buffer); 1614bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_pipeline *pipeline = cmd_buffer->state.pipeline; 16152b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg const struct brw_vs_prog_data *vs_prog_data = get_vs_prog_data(pipeline); 1616bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_bo *bo = buffer->bo; 1617bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t bo_offset = buffer->offset + offset; 1618bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1619bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg genX(cmd_buffer_flush_state)(cmd_buffer); 1620bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 16212b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg if (vs_prog_data->uses_basevertex || vs_prog_data->uses_baseinstance) 1622bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_base_vertex_instance_bo(cmd_buffer, bo, bo_offset + 8); 1623bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1624bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_VERTEX_COUNT, bo, bo_offset); 1625bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_INSTANCE_COUNT, bo, bo_offset + 4); 1626bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_START_VERTEX, bo, bo_offset + 8); 1627bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_START_INSTANCE, bo, bo_offset + 12); 1628bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lri(&cmd_buffer->batch, GEN7_3DPRIM_BASE_VERTEX, 0); 1629bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 163050018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DPRIMITIVE), prim) { 16311d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.IndirectParameterEnable = true; 16321d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.VertexAccessType = SEQUENTIAL; 16331d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.PrimitiveTopologyType = pipeline->topology; 16341d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand } 1635bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg} 1636bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1637bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsbergvoid genX(CmdDrawIndexedIndirect)( 1638bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkCommandBuffer commandBuffer, 1639bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkBuffer _buffer, 1640bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg VkDeviceSize offset, 1641bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t drawCount, 1642bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t stride) 1643bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg{ 1644bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 1645bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg ANV_FROM_HANDLE(anv_buffer, buffer, _buffer); 1646bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_pipeline *pipeline = cmd_buffer->state.pipeline; 16472b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg const struct brw_vs_prog_data *vs_prog_data = get_vs_prog_data(pipeline); 1648bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg struct anv_bo *bo = buffer->bo; 1649bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg uint32_t bo_offset = buffer->offset + offset; 1650bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1651bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg genX(cmd_buffer_flush_state)(cmd_buffer); 1652bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1653bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg /* TODO: We need to stomp base vertex to 0 somehow */ 16542b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg if (vs_prog_data->uses_basevertex || vs_prog_data->uses_baseinstance) 1655bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_base_vertex_instance_bo(cmd_buffer, bo, bo_offset + 12); 1656bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 1657bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_VERTEX_COUNT, bo, bo_offset); 1658bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_INSTANCE_COUNT, bo, bo_offset + 4); 1659bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_START_VERTEX, bo, bo_offset + 8); 1660bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_BASE_VERTEX, bo, bo_offset + 12); 1661bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg emit_lrm(&cmd_buffer->batch, GEN7_3DPRIM_START_INSTANCE, bo, bo_offset + 16); 1662bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg 166350018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DPRIMITIVE), prim) { 16641d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.IndirectParameterEnable = true; 16651d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.VertexAccessType = RANDOM; 16661d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand prim.PrimitiveTopologyType = pipeline->topology; 16671d4d6852b469c5e726137953ce47d2ee6ed60bdaJason Ekstrand } 1668bdefaae2b92c15af4f2bff41b0e689325e762dc7Kristian Høgsberg} 16696c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 16701f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrandstatic VkResult 16711f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrandflush_compute_descriptor_set(struct anv_cmd_buffer *cmd_buffer) 16721f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand{ 16731f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand struct anv_pipeline *pipeline = cmd_buffer->state.compute_pipeline; 16741f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand struct anv_state surfaces = { 0, }, samplers = { 0, }; 16751f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand VkResult result; 16761f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 16777998e37774c9589b456d9a951d47db98c16d6202Jason Ekstrand result = emit_binding_table(cmd_buffer, MESA_SHADER_COMPUTE, &surfaces); 1678722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand if (result != VK_SUCCESS) { 16793ef8dff865fd7365ba36b49c43b5c858d26587edJason Ekstrand assert(result == VK_ERROR_OUT_OF_DEVICE_MEMORY); 1680722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand result = anv_cmd_buffer_new_binding_table_block(cmd_buffer); 1681722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand assert(result == VK_SUCCESS); 1682722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand 1683722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand /* Re-emit state base addresses so we get the new surface state base 1684722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand * address before we start emitting binding tables etc. 1685722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand */ 1686722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand genX(cmd_buffer_emit_state_base_address)(cmd_buffer); 1687722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand 1688722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand result = emit_binding_table(cmd_buffer, MESA_SHADER_COMPUTE, &surfaces); 1689722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand assert(result == VK_SUCCESS); 1690722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand } 1691054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand 1692722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand result = emit_samplers(cmd_buffer, MESA_SHADER_COMPUTE, &samplers); 1693722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand assert(result == VK_SUCCESS); 1694722ab3de9f0e30e1dfbbd2b5217330b85f53bcecJason Ekstrand 1695d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand uint32_t iface_desc_data_dw[GENX(INTERFACE_DESCRIPTOR_DATA_length)]; 1696d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand struct GENX(INTERFACE_DESCRIPTOR_DATA) desc = { 1697d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand .BindingTablePointer = surfaces.offset, 1698d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand .SamplerStatePointer = samplers.offset, 1699d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand }; 1700d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand GENX(INTERFACE_DESCRIPTOR_DATA_pack)(NULL, iface_desc_data_dw, &desc); 17011f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 17021f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand struct anv_state state = 1703d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand anv_cmd_buffer_merge_dynamic(cmd_buffer, iface_desc_data_dw, 1704d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand pipeline->interface_descriptor_data, 1705d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand GENX(INTERFACE_DESCRIPTOR_DATA_length), 1706d33e2ad67c3621a01648292ece2148aa8b7d2fdbJason Ekstrand 64); 17071f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 17081f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand uint32_t size = GENX(INTERFACE_DESCRIPTOR_DATA_length) * sizeof(uint32_t); 17091f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, 17101f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand GENX(MEDIA_INTERFACE_DESCRIPTOR_LOAD), mid) { 17111f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand mid.InterfaceDescriptorTotalLength = size; 17121f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand mid.InterfaceDescriptorDataStartAddress = state.offset; 17131f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand } 17141f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 17151f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand return VK_SUCCESS; 17161f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand} 17171f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 17181f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrandvoid 17191f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason EkstrandgenX(cmd_buffer_flush_compute_state)(struct anv_cmd_buffer *cmd_buffer) 17201f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand{ 17211f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand struct anv_pipeline *pipeline = cmd_buffer->state.compute_pipeline; 17221f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand MAYBE_UNUSED VkResult result; 17231f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 17241f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand assert(pipeline->active_stages == VK_SHADER_STAGE_COMPUTE_BIT); 17251f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 17261f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand genX(cmd_buffer_config_l3)(cmd_buffer, pipeline->urb.l3_config); 17271f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 17281f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand genX(flush_pipeline_select_gpgpu)(cmd_buffer); 17291f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 1730f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand if (cmd_buffer->state.compute_dirty & ANV_CMD_DIRTY_PIPELINE) { 1731f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand /* From the Sky Lake PRM Vol 2a, MEDIA_VFE_STATE: 1732f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand * 1733f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand * "A stalling PIPE_CONTROL is required before MEDIA_VFE_STATE unless 1734f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand * the only bits that are changed are scoreboard related: Scoreboard 1735f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand * Enable, Scoreboard Type, Scoreboard Mask, Scoreboard * Delta. For 1736f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand * these scoreboard related states, a MEDIA_STATE_FLUSH is 1737f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand * sufficient." 1738f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand */ 1739f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand cmd_buffer->state.pending_pipe_bits |= ANV_PIPE_CS_STALL_BIT; 1740f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand genX(cmd_buffer_apply_pipe_flushes)(cmd_buffer); 1741f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand 17421f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand anv_batch_emit_batch(&cmd_buffer->batch, &pipeline->batch); 1743f680a01ad4ed360b44cd1b9d3c447a95cedbccd5Jason Ekstrand } 17441f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 17457a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand if ((cmd_buffer->state.descriptors_dirty & VK_SHADER_STAGE_COMPUTE_BIT) || 17467a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand (cmd_buffer->state.compute_dirty & ANV_CMD_DIRTY_PIPELINE)) { 17477a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand /* FIXME: figure out descriptors for gen7 */ 17487a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand result = flush_compute_descriptor_set(cmd_buffer); 17497a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand assert(result == VK_SUCCESS); 17507a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand cmd_buffer->state.descriptors_dirty &= ~VK_SHADER_STAGE_COMPUTE_BIT; 17517a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand } 17527a2cfd4adb891fb93e84fd8aedfbe387a8a2c781Jason Ekstrand 1753054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand if (cmd_buffer->state.push_constants_dirty & VK_SHADER_STAGE_COMPUTE_BIT) { 1754054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand struct anv_state push_state = 1755054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand anv_cmd_buffer_cs_push_constants(cmd_buffer); 1756054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand 1757054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand if (push_state.alloc_size) { 1758054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(MEDIA_CURBE_LOAD), curbe) { 1759054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand curbe.CURBETotalDataLength = push_state.alloc_size; 1760054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand curbe.CURBEDataStartAddress = push_state.offset; 1761054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand } 1762054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand } 1763054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand } 1764054e48ee0ead7e5a81d28220e3890c7dfc410188Jason Ekstrand 17651f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand cmd_buffer->state.compute_dirty = 0; 17661f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 17671f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand genX(cmd_buffer_apply_pipe_flushes)(cmd_buffer); 17681f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand} 17691f3e6468d2a3efd9f2da99fa337dfe4b804bcda6Jason Ekstrand 17708dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen#if GEN_GEN == 7 17718dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen 17728dbfa265a439904628c2d875885e80bc45a90a05Jordan Justenstatic bool 17738dbfa265a439904628c2d875885e80bc45a90a05Jordan Justenverify_cmd_parser(const struct anv_device *device, 17748dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen int required_version, 17758dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen const char *function) 17768dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen{ 17778dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen if (device->instance->physicalDevice.cmd_parser_version < required_version) { 17788dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen vk_errorf(VK_ERROR_FEATURE_NOT_PRESENT, 17798dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen "cmd parser version %d is required for %s", 17808dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen required_version, function); 17818dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen return false; 17828dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen } else { 17838dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen return true; 17848dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen } 17858dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen} 17868dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen 17878dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen#endif 17886c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 17896c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsbergvoid genX(CmdDispatch)( 17906c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg VkCommandBuffer commandBuffer, 17916c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg uint32_t x, 17926c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg uint32_t y, 17936c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg uint32_t z) 17946c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg{ 17956c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 17966c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg struct anv_pipeline *pipeline = cmd_buffer->state.compute_pipeline; 17972b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg const struct brw_cs_prog_data *prog_data = get_cs_prog_data(pipeline); 17986c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 17996c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg if (prog_data->uses_num_work_groups) { 18006c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg struct anv_state state = 18016c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg anv_cmd_buffer_alloc_dynamic_state(cmd_buffer, 12, 4); 18026c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg uint32_t *sizes = state.map; 18036c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg sizes[0] = x; 18046c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg sizes[1] = y; 18056c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg sizes[2] = z; 18066c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg if (!cmd_buffer->device->info.has_llc) 18076c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg anv_state_clflush(state); 18086c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg cmd_buffer->state.num_workgroups_offset = state.offset; 18096c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg cmd_buffer->state.num_workgroups_bo = 18106c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg &cmd_buffer->device->dynamic_state_block_pool.bo; 18116c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg } 18126c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 18136c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg genX(cmd_buffer_flush_compute_state)(cmd_buffer); 18146c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 181550018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(GPGPU_WALKER), ggw) { 1816deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.SIMDSize = prog_data->simd_size / 16; 1817deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadDepthCounterMaximum = 0; 1818deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadHeightCounterMaximum = 0; 18191b79e7ebbd77a7e714fafadd91459059aacf2407Jordan Justen ggw.ThreadWidthCounterMaximum = prog_data->threads - 1; 1820deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadGroupIDXDimension = x; 1821deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadGroupIDYDimension = y; 1822deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadGroupIDZDimension = z; 1823deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.RightExecutionMask = pipeline->cs_right_mask; 1824deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.BottomExecutionMask = 0xffffffff; 1825deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 1826deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand 182750018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(MEDIA_STATE_FLUSH), msf); 18286c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg} 18296c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 18306c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg#define GPGPU_DISPATCHDIMX 0x2500 18316c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg#define GPGPU_DISPATCHDIMY 0x2504 18326c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg#define GPGPU_DISPATCHDIMZ 0x2508 18336c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 183498cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen#define MI_PREDICATE_SRC0 0x2400 183598cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen#define MI_PREDICATE_SRC1 0x2408 183698cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 18376c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsbergvoid genX(CmdDispatchIndirect)( 18386c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg VkCommandBuffer commandBuffer, 18396c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg VkBuffer _buffer, 18406c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg VkDeviceSize offset) 18416c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg{ 18426c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 18436c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg ANV_FROM_HANDLE(anv_buffer, buffer, _buffer); 18446c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg struct anv_pipeline *pipeline = cmd_buffer->state.compute_pipeline; 18452b29342fae14d8626ca58f8a7ec358b70886ced3Kristian Høgsberg const struct brw_cs_prog_data *prog_data = get_cs_prog_data(pipeline); 18466c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg struct anv_bo *bo = buffer->bo; 18476c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg uint32_t bo_offset = buffer->offset + offset; 1848da4745104cc02fc0052a2e05e37c69a4dce76eefJordan Justen struct anv_batch *batch = &cmd_buffer->batch; 18496c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 18508dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen#if GEN_GEN == 7 18518dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen /* Linux 4.4 added command parser version 5 which allows the GPGPU 18528dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen * indirect dispatch registers to be written. 18538dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen */ 1854f56f538ce4753a6fdd969b610f35433fd657e4eeJordan Justen if (!verify_cmd_parser(cmd_buffer->device, 5, "vkCmdDispatchIndirect")) 18558dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen return; 18568dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen#endif 18578dbfa265a439904628c2d875885e80bc45a90a05Jordan Justen 18586c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg if (prog_data->uses_num_work_groups) { 18596c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg cmd_buffer->state.num_workgroups_offset = bo_offset; 18606c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg cmd_buffer->state.num_workgroups_bo = bo; 18616c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg } 18626c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 18636c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg genX(cmd_buffer_flush_compute_state)(cmd_buffer); 18646c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 1865da4745104cc02fc0052a2e05e37c69a4dce76eefJordan Justen emit_lrm(batch, GPGPU_DISPATCHDIMX, bo, bo_offset); 1866da4745104cc02fc0052a2e05e37c69a4dce76eefJordan Justen emit_lrm(batch, GPGPU_DISPATCHDIMY, bo, bo_offset + 4); 1867da4745104cc02fc0052a2e05e37c69a4dce76eefJordan Justen emit_lrm(batch, GPGPU_DISPATCHDIMZ, bo, bo_offset + 8); 18686c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg 186998cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen#if GEN_GEN <= 7 187098cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* Clear upper 32-bits of SRC0 and all 64-bits of SRC1 */ 187198cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen emit_lri(batch, MI_PREDICATE_SRC0 + 4, 0); 187298cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen emit_lri(batch, MI_PREDICATE_SRC1 + 0, 0); 187398cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen emit_lri(batch, MI_PREDICATE_SRC1 + 4, 0); 187498cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 187598cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* Load compute_dispatch_indirect_x_size into SRC0 */ 187698cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen emit_lrm(batch, MI_PREDICATE_SRC0, bo, bo_offset + 0); 187798cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 187898cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* predicate = (compute_dispatch_indirect_x_size == 0); */ 187950018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_PREDICATE), mip) { 1880deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.LoadOperation = LOAD_LOAD; 1881deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CombineOperation = COMBINE_SET; 1882deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CompareOperation = COMPARE_SRCS_EQUAL; 1883deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 188498cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 188598cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* Load compute_dispatch_indirect_y_size into SRC0 */ 188698cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen emit_lrm(batch, MI_PREDICATE_SRC0, bo, bo_offset + 4); 188798cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 188898cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* predicate |= (compute_dispatch_indirect_y_size == 0); */ 188950018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_PREDICATE), mip) { 1890deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.LoadOperation = LOAD_LOAD; 1891deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CombineOperation = COMBINE_OR; 1892deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CompareOperation = COMPARE_SRCS_EQUAL; 1893deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 189498cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 189598cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* Load compute_dispatch_indirect_z_size into SRC0 */ 189698cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen emit_lrm(batch, MI_PREDICATE_SRC0, bo, bo_offset + 8); 189798cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 189898cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* predicate |= (compute_dispatch_indirect_z_size == 0); */ 189950018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_PREDICATE), mip) { 1900deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.LoadOperation = LOAD_LOAD; 1901deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CombineOperation = COMBINE_OR; 1902deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CompareOperation = COMPARE_SRCS_EQUAL; 1903deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 190498cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 190598cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen /* predicate = !predicate; */ 190698cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen#define COMPARE_FALSE 1 190750018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_PREDICATE), mip) { 1908deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.LoadOperation = LOAD_LOADINV; 1909deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CombineOperation = COMBINE_OR; 1910deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand mip.CompareOperation = COMPARE_FALSE; 1911deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 191298cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen#endif 191398cdce1ce4737cf09c5d9613a85bb118f0f1757bJordan Justen 191450018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(GPGPU_WALKER), ggw) { 1915deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.IndirectParameterEnable = true; 1916deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.PredicateEnable = GEN_GEN <= 7; 1917deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.SIMDSize = prog_data->simd_size / 16; 1918deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadDepthCounterMaximum = 0; 1919deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.ThreadHeightCounterMaximum = 0; 19201b79e7ebbd77a7e714fafadd91459059aacf2407Jordan Justen ggw.ThreadWidthCounterMaximum = prog_data->threads - 1; 1921deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.RightExecutionMask = pipeline->cs_right_mask; 1922deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ggw.BottomExecutionMask = 0xffffffff; 1923deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 1924deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand 192550018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MEDIA_STATE_FLUSH), msf); 19266c4c04690f30af655ad675b590836d3a84440c3aKristian Høgsberg} 1927832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg 1928c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justenstatic void 1929c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justenflush_pipeline_before_pipeline_select(struct anv_cmd_buffer *cmd_buffer, 1930c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen uint32_t pipeline) 1931c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen{ 1932c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen#if GEN_GEN >= 8 && GEN_GEN < 10 1933c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen /* From the Broadwell PRM, Volume 2a: Instructions, PIPELINE_SELECT: 1934c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * 1935c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * Software must clear the COLOR_CALC_STATE Valid field in 1936c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * 3DSTATE_CC_STATE_POINTERS command prior to send a PIPELINE_SELECT 1937c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * with Pipeline Select set to GPGPU. 1938c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * 1939c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * The internal hardware docs recommend the same workaround for Gen9 1940c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen * hardware too. 1941c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen */ 1942c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen if (pipeline == GPGPU) 194350018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_CC_STATE_POINTERS), t); 1944b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen#elif GEN_GEN <= 7 1945b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen /* From "BXML » GT » MI » vol1a GPU Overview » [Instruction] 1946b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen * PIPELINE_SELECT [DevBWR+]": 1947b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen * 1948b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen * Project: DEVSNB+ 1949b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen * 1950b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen * Software must ensure all the write caches are flushed through a 1951b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen * stalling PIPE_CONTROL command followed by another PIPE_CONTROL 1952b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen * command to invalidate read only caches prior to programming 1953b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen * MI_PIPELINE_SELECT command to change the Pipeline Select Mode. 1954b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen */ 195550018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 195656453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.RenderTargetCacheFlushEnable = true; 195756453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DepthCacheFlushEnable = true; 195856453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DCFlushEnable = true; 195956453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.PostSyncOperation = NoWrite; 196056453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.CommandStreamerStallEnable = true; 196156453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 1962b83785d86d2c7f07323920615c72a9f09695a9a7Jordan Justen 196350018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 196456453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.TextureCacheInvalidationEnable = true; 196556453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.ConstantCacheInvalidationEnable = true; 196656453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.StateCacheInvalidationEnable = true; 196756453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.InstructionCacheInvalidateEnable = true; 196856453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.PostSyncOperation = NoWrite; 196956453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 1970c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen#endif 1971c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen} 1972c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen 1973832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsbergvoid 1974832f73f512e9e6c21d495d7b07e229482371ef2fKristian HøgsberggenX(flush_pipeline_select_3d)(struct anv_cmd_buffer *cmd_buffer) 1975832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg{ 1976832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg if (cmd_buffer->state.current_pipeline != _3D) { 1977c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen flush_pipeline_before_pipeline_select(cmd_buffer, _3D); 1978c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen 197950018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPELINE_SELECT), ps) { 1980371b4a5b33a13f35fa7783510d2d90685a9a2e8aJason Ekstrand#if GEN_GEN >= 9 1981deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ps.MaskBits = 3; 1982832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg#endif 1983deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ps.PipelineSelection = _3D; 1984deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 1985deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand 1986832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg cmd_buffer->state.current_pipeline = _3D; 1987832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg } 1988832f73f512e9e6c21d495d7b07e229482371ef2fKristian Høgsberg} 198985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 19901b126305ded36f6b416ada08e29ff84faeafef99Jordan Justenvoid 19911b126305ded36f6b416ada08e29ff84faeafef99Jordan JustengenX(flush_pipeline_select_gpgpu)(struct anv_cmd_buffer *cmd_buffer) 19921b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen{ 19931b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen if (cmd_buffer->state.current_pipeline != GPGPU) { 1994c8ec65a1f5a85dbef3210dc49684fcfed49b7ea2Jordan Justen flush_pipeline_before_pipeline_select(cmd_buffer, GPGPU); 19951b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen 199650018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPELINE_SELECT), ps) { 19971b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen#if GEN_GEN >= 9 1998deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ps.MaskBits = 3; 19991b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen#endif 2000deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand ps.PipelineSelection = GPGPU; 2001deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand } 2002deb13870d8a8e107efb636618ccb94edff0f60bfJason Ekstrand 20031b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen cmd_buffer->state.current_pipeline = GPGPU; 20041b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen } 20051b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen} 20061b126305ded36f6b416ada08e29ff84faeafef99Jordan Justen 2007a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrandvoid 2008a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason EkstrandgenX(cmd_buffer_emit_gen7_depth_flush)(struct anv_cmd_buffer *cmd_buffer) 2009a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand{ 2010a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand if (GEN_GEN >= 8) 2011a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand return; 2012a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand 2013a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand /* From the Haswell PRM, documentation for 3DSTATE_DEPTH_BUFFER: 2014a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * 2015a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * "Restriction: Prior to changing Depth/Stencil Buffer state (i.e., any 2016a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * combination of 3DSTATE_DEPTH_BUFFER, 3DSTATE_CLEAR_PARAMS, 2017a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * 3DSTATE_STENCIL_BUFFER, 3DSTATE_HIER_DEPTH_BUFFER) SW must first 2018a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * issue a pipelined depth stall (PIPE_CONTROL with Depth Stall bit 2019a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * set), followed by a pipelined depth cache flush (PIPE_CONTROL with 2020a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * Depth Flush Bit set, followed by another pipelined depth stall 2021a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * (PIPE_CONTROL with Depth Stall Bit set), unless SW can otherwise 2022a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * guarantee that the pipeline from WM onwards is already flushed (e.g., 2023a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand * via a preceding MI_FLUSH)." 2024a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand */ 2025a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pipe) { 2026a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand pipe.DepthStallEnable = true; 2027a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand } 2028a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pipe) { 2029a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand pipe.DepthCacheFlushEnable = true; 2030a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand } 2031a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pipe) { 2032a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand pipe.DepthStallEnable = true; 2033a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand } 2034a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand} 2035a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand 2036d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrandstatic uint32_t 2037d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstranddepth_stencil_surface_type(enum isl_surf_dim dim) 2038d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand{ 2039d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand switch (dim) { 2040d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand case ISL_SURF_DIM_1D: 2041d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand if (GEN_GEN >= 9) { 2042d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand /* From the Sky Lake PRM, 3DSTATAE_DEPTH_BUFFER::SurfaceType 2043d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * 2044d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * Programming Notes: 2045d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * The Surface Type of the depth buffer must be the same as the 2046d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * Surface Type of the render target(s) (defined in 2047d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * SURFACE_STATE), unless either the depth buffer or render 2048d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * targets are SURFTYPE_NULL (see exception below for SKL). 1D 2049d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * surface type not allowed for depth surface and stencil surface. 2050d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * 2051d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * Workaround: 2052d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * If depth/stencil is enabled with 1D render target, 2053d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * depth/stencil surface type needs to be set to 2D surface type 2054d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * and height set to 1. Depth will use (legacy) TileY and stencil 2055d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * will use TileW. For this case only, the Surface Type of the 2056d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * depth buffer can be 2D while the Surface Type of the render 2057d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * target(s) are 1D, representing an exception to a programming 2058d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * note above. 2059d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand */ 2060d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand return SURFTYPE_2D; 2061d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } else { 2062d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand return SURFTYPE_1D; 2063d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } 2064d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand case ISL_SURF_DIM_2D: 2065d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand return SURFTYPE_2D; 2066d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand case ISL_SURF_DIM_3D: 2067d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand if (GEN_GEN >= 9) { 2068d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand /* The Sky Lake docs list the value for 3D as "Reserved". However, 2069d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * they have the exact same layout as 2D arrays on gen9+, so we can 2070d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand * just use 2D here. 2071d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand */ 2072d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand return SURFTYPE_2D; 2073d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } else { 2074d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand return SURFTYPE_3D; 2075d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } 2076d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand default: 2077d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand unreachable("Invalid surface dimension"); 2078d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } 2079d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand} 2080d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand 208185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsbergstatic void 208285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsbergcmd_buffer_emit_depth_stencil(struct anv_cmd_buffer *cmd_buffer) 208385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg{ 208485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg struct anv_device *device = cmd_buffer->device; 208585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg const struct anv_framebuffer *fb = cmd_buffer->state.framebuffer; 208685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg const struct anv_image_view *iview = 208785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg anv_cmd_buffer_get_depth_stencil_view(cmd_buffer); 208885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg const struct anv_image *image = iview ? iview->image : NULL; 2089234ecf26c65a8909e91313a8b35e2a8a8bbfc0efJason Ekstrand const bool has_depth = image && (image->aspects & VK_IMAGE_ASPECT_DEPTH_BIT); 209078d074b87a75d599e65ef34f5b866da577b80de3Chad Versace const bool has_hiz = image != NULL && anv_image_has_hiz(image); 2091234ecf26c65a8909e91313a8b35e2a8a8bbfc0efJason Ekstrand const bool has_stencil = 2092234ecf26c65a8909e91313a8b35e2a8a8bbfc0efJason Ekstrand image && (image->aspects & VK_IMAGE_ASPECT_STENCIL_BIT); 209385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 209485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg /* FIXME: Implement the PMA stall W/A */ 209585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg /* FIXME: Width and Height are wrong */ 209685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2097a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand genX(cmd_buffer_emit_gen7_depth_flush)(cmd_buffer); 2098a8b85f1f772ef45cdeba9d5d205d105e689c3bdfJason Ekstrand 209985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg /* Emit 3DSTATE_DEPTH_BUFFER */ 210085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg if (has_depth) { 210150018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_DEPTH_BUFFER), db) { 2102d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand db.SurfaceType = 2103d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand depth_stencil_surface_type(image->depth_surface.isl.dim); 2104a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.DepthWriteEnable = true; 2105a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.StencilWriteEnable = has_stencil; 210678d074b87a75d599e65ef34f5b866da577b80de3Chad Versace 210778d074b87a75d599e65ef34f5b866da577b80de3Chad Versace if (cmd_buffer->state.pass->subpass_count == 1) { 210878d074b87a75d599e65ef34f5b866da577b80de3Chad Versace db.HierarchicalDepthBufferEnable = has_hiz; 210978d074b87a75d599e65ef34f5b866da577b80de3Chad Versace } else { 211078d074b87a75d599e65ef34f5b866da577b80de3Chad Versace anv_finishme("Multiple-subpass HiZ not implemented"); 211178d074b87a75d599e65ef34f5b866da577b80de3Chad Versace } 2112a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand 2113a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.SurfaceFormat = isl_surf_get_depth_format(&device->isl_dev, 2114a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand &image->depth_surface.isl); 2115a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand 2116a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.SurfaceBaseAddress = (struct anv_address) { 211785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg .bo = image->bo, 211822d8666d74f6fa6de53366f76a56277976eced21Kristian Høgsberg .offset = image->offset + image->depth_surface.offset, 2119a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand }; 2120696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin db.DepthBufferObjectControlState = GENX(MOCS); 2121a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand 2122a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.SurfacePitch = image->depth_surface.isl.row_pitch - 1; 212320e95a746df34923eb4aac5e7f1ab6d722432d89Jason Ekstrand db.Height = image->extent.height - 1; 212420e95a746df34923eb4aac5e7f1ab6d722432d89Jason Ekstrand db.Width = image->extent.width - 1; 212529e289fa655938f7814bdbb3de7996a8a0f04b60Jason Ekstrand db.LOD = iview->isl.base_level; 212620e95a746df34923eb4aac5e7f1ab6d722432d89Jason Ekstrand db.Depth = image->array_size - 1; /* FIXME: 3-D */ 212729e289fa655938f7814bdbb3de7996a8a0f04b60Jason Ekstrand db.MinimumArrayElement = iview->isl.base_array_layer; 2128a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand 2129371b4a5b33a13f35fa7783510d2d90685a9a2e8aJason Ekstrand#if GEN_GEN >= 8 2130a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.SurfaceQPitch = 2131696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin isl_surf_get_array_pitch_el_rows(&image->depth_surface.isl) >> 2; 213285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg#endif 2133a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.RenderTargetViewExtent = 1 - 1; 2134a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand } 213585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg } else { 213685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg /* Even when no depth buffer is present, the hardware requires that 213785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH_BUFFER be programmed correctly. The Broadwell PRM says: 213885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 213985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * If a null depth buffer is bound, the driver must instead bind depth as: 214085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH.SurfaceType = SURFTYPE_2D 214185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH.Width = 1 214285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH.Height = 1 214385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH.SuraceFormat = D16_UNORM 214485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH.SurfaceBaseAddress = 0 214585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_DEPTH.HierarchicalDepthBufferEnable = 0 214685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_WM_DEPTH_STENCIL.DepthTestEnable = 0 214785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 3DSTATE_WM_DEPTH_STENCIL.DepthBufferWriteEnable = 0 214885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * 214985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * The PRM is wrong, though. The width and height must be programmed to 215085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg * actual framebuffer's width and height, even when neither depth buffer 21517c1660aa14094e40fba9f39ce194cb6238311b65Jason Ekstrand * nor stencil buffer is present. Also, D16_UNORM is not allowed to 21527c1660aa14094e40fba9f39ce194cb6238311b65Jason Ekstrand * be combined with a stencil buffer so we use D32_FLOAT instead. 215385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg */ 215450018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_DEPTH_BUFFER), db) { 2155d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand if (has_stencil) { 215627433b26b197b8b69d4ca8c9aed567f04950648eJason Ekstrand db.SurfaceType = 2157d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand depth_stencil_surface_type(image->stencil_surface.isl.dim); 2158d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } else { 2159d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand db.SurfaceType = SURFTYPE_2D; 2160d4ef87c1bb4290293148cbd6cb782764df38f8f4Jason Ekstrand } 2161a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.SurfaceFormat = D32_FLOAT; 2162dcca706b4e2d2086b90d77cced0cff6ce4eac953Kenneth Graunke db.Width = MAX2(fb->width, 1) - 1; 2163dcca706b4e2d2086b90d77cced0cff6ce4eac953Kenneth Graunke db.Height = MAX2(fb->height, 1) - 1; 2164a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand db.StencilWriteEnable = has_stencil; 2165a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand } 216685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg } 216785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 216878d074b87a75d599e65ef34f5b866da577b80de3Chad Versace if (has_hiz) { 216978d074b87a75d599e65ef34f5b866da577b80de3Chad Versace anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_HIER_DEPTH_BUFFER), hdb) { 217078d074b87a75d599e65ef34f5b866da577b80de3Chad Versace hdb.HierarchicalDepthBufferObjectControlState = GENX(MOCS); 2171c3eb58664e5e537b21a75172916b42bd4b5504b3Jason Ekstrand hdb.SurfacePitch = image->aux_surface.isl.row_pitch - 1; 217278d074b87a75d599e65ef34f5b866da577b80de3Chad Versace hdb.SurfaceBaseAddress = (struct anv_address) { 217378d074b87a75d599e65ef34f5b866da577b80de3Chad Versace .bo = image->bo, 2174c3eb58664e5e537b21a75172916b42bd4b5504b3Jason Ekstrand .offset = image->offset + image->aux_surface.offset, 217578d074b87a75d599e65ef34f5b866da577b80de3Chad Versace }; 217678d074b87a75d599e65ef34f5b866da577b80de3Chad Versace#if GEN_GEN >= 8 217778d074b87a75d599e65ef34f5b866da577b80de3Chad Versace /* From the SKL PRM Vol2a: 217878d074b87a75d599e65ef34f5b866da577b80de3Chad Versace * 217978d074b87a75d599e65ef34f5b866da577b80de3Chad Versace * The interpretation of this field is dependent on Surface Type 218078d074b87a75d599e65ef34f5b866da577b80de3Chad Versace * as follows: 218178d074b87a75d599e65ef34f5b866da577b80de3Chad Versace * - SURFTYPE_1D: distance in pixels between array slices 218278d074b87a75d599e65ef34f5b866da577b80de3Chad Versace * - SURFTYPE_2D/CUBE: distance in rows between array slices 218378d074b87a75d599e65ef34f5b866da577b80de3Chad Versace * - SURFTYPE_3D: distance in rows between R - slices 2184f469235a6e0c239166ba803e121994063b47ddd3Jason Ekstrand * 2185f469235a6e0c239166ba803e121994063b47ddd3Jason Ekstrand * Unfortunately, the docs aren't 100% accurate here. They fail to 2186f469235a6e0c239166ba803e121994063b47ddd3Jason Ekstrand * mention that the 1-D rule only applies to linear 1-D images. 2187f469235a6e0c239166ba803e121994063b47ddd3Jason Ekstrand * Since depth and HiZ buffers are always tiled, they are treated as 2188f469235a6e0c239166ba803e121994063b47ddd3Jason Ekstrand * 2-D images. Prior to Sky Lake, this field is always in rows. 218978d074b87a75d599e65ef34f5b866da577b80de3Chad Versace */ 219078d074b87a75d599e65ef34f5b866da577b80de3Chad Versace hdb.SurfaceQPitch = 2191f469235a6e0c239166ba803e121994063b47ddd3Jason Ekstrand isl_surf_get_array_pitch_el_rows(&image->aux_surface.isl) >> 2; 219278d074b87a75d599e65ef34f5b866da577b80de3Chad Versace#endif 219378d074b87a75d599e65ef34f5b866da577b80de3Chad Versace } 219478d074b87a75d599e65ef34f5b866da577b80de3Chad Versace } else { 219578d074b87a75d599e65ef34f5b866da577b80de3Chad Versace anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_HIER_DEPTH_BUFFER), hdb); 219678d074b87a75d599e65ef34f5b866da577b80de3Chad Versace } 219778d074b87a75d599e65ef34f5b866da577b80de3Chad Versace 219885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg /* Emit 3DSTATE_STENCIL_BUFFER */ 219985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg if (has_stencil) { 220050018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_STENCIL_BUFFER), sb) { 2201371b4a5b33a13f35fa7783510d2d90685a9a2e8aJason Ekstrand#if GEN_GEN >= 8 || GEN_IS_HASWELL 2202696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin sb.StencilBufferEnable = true; 220385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg#endif 2204696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin sb.StencilBufferObjectControlState = GENX(MOCS); 220585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2206696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin sb.SurfacePitch = image->stencil_surface.isl.row_pitch - 1; 220785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2208371b4a5b33a13f35fa7783510d2d90685a9a2e8aJason Ekstrand#if GEN_GEN >= 8 2209696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin sb.SurfaceQPitch = isl_surf_get_array_pitch_el_rows(&image->stencil_surface.isl) >> 2; 221085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg#endif 2211a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand sb.SurfaceBaseAddress = (struct anv_address) { 221285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg .bo = image->bo, 221385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg .offset = image->offset + image->stencil_surface.offset, 2214a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand }; 2215a71ded0e1847d9d20c11de2fbaea271724170dc8Jason Ekstrand } 221685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg } else { 221750018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_STENCIL_BUFFER), sb); 221885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg } 221985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2220d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery /* From the IVB PRM Vol2P1, 11.5.5.4 3DSTATE_CLEAR_PARAMS: 2221d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * 2222d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * 3DSTATE_CLEAR_PARAMS must always be programmed in the along with 2223d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * the other Depth/Stencil state commands(i.e. 3DSTATE_DEPTH_BUFFER, 2224d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * 3DSTATE_STENCIL_BUFFER, or 3DSTATE_HIER_DEPTH_BUFFER) 2225d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * 2226d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * Testing also shows that some variant of this restriction may exist HSW+. 2227d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * On BDW+, it is not possible to emit 2 of these packets consecutively when 2228d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * both have DepthClearValueValid set. An analysis of such state programming 2229d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * on SKL showed that the GPU doesn't register the latter packet's clear 2230d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery * value. 2231d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery */ 2232d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery anv_batch_emit(&cmd_buffer->batch, GENX(3DSTATE_CLEAR_PARAMS), cp) { 2233d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery if (has_hiz) { 2234d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery cp.DepthClearValueValid = true; 2235d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery const uint32_t ds = 2236d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery cmd_buffer->state.subpass->depth_stencil_attachment; 2237d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery cp.DepthClearValue = 2238d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery cmd_buffer->state.attachments[ds].clear_value.depthStencil.depth; 2239d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery } 2240d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery } 224185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg} 224285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2243b548fdbed5c16f5c0dfc26f65b0037a85c567735Jason Ekstrandstatic void 224485f67cf16e9823c858215e8a7359d18762c2653cKristian HøgsberggenX(cmd_buffer_set_subpass)(struct anv_cmd_buffer *cmd_buffer, 224585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg struct anv_subpass *subpass) 224685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg{ 224785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg cmd_buffer->state.subpass = subpass; 224885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 2249fe4e276b02615b5db8acbf4c65fcfa68982e2e0fJason Ekstrand cmd_buffer->state.dirty |= ANV_CMD_DIRTY_RENDER_TARGETS; 225085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 225185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg cmd_buffer_emit_depth_stencil(cmd_buffer); 225278d074b87a75d599e65ef34f5b866da577b80de3Chad Versace genX(cmd_buffer_emit_hz_op)(cmd_buffer, BLORP_HIZ_OP_HIZ_RESOLVE); 2253d8aacc24cc37dc435e250668aba0817c36996ad1Nanley Chery genX(cmd_buffer_emit_hz_op)(cmd_buffer, BLORP_HIZ_OP_DEPTH_CLEAR); 2254c81ec84c1ec24f11f86b2fb725956437c721fe18Jason Ekstrand 2255c81ec84c1ec24f11f86b2fb725956437c721fe18Jason Ekstrand anv_cmd_buffer_clear_subpass(cmd_buffer); 225685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg} 225785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 225885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsbergvoid genX(CmdBeginRenderPass)( 225985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg VkCommandBuffer commandBuffer, 226085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg const VkRenderPassBeginInfo* pRenderPassBegin, 226185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg VkSubpassContents contents) 226285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg{ 226385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 226485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg ANV_FROM_HANDLE(anv_render_pass, pass, pRenderPassBegin->renderPass); 226585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg ANV_FROM_HANDLE(anv_framebuffer, framebuffer, pRenderPassBegin->framebuffer); 226685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 226785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg cmd_buffer->state.framebuffer = framebuffer; 226885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg cmd_buffer->state.pass = pass; 2269b26bd6790dd1b09e377bd926e9145ec20ce6ac3fJason Ekstrand cmd_buffer->state.render_area = pRenderPassBegin->renderArea; 2270d1d6b788989e73edd2426999d891230500dc1a73Jason Ekstrand genX(cmd_buffer_setup_attachments)(cmd_buffer, pass, pRenderPassBegin); 227185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 227285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg genX(flush_pipeline_select_3d)(cmd_buffer); 227385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 227485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg genX(cmd_buffer_set_subpass)(cmd_buffer, pass->subpasses); 227585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg} 227685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 227785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsbergvoid genX(CmdNextSubpass)( 227885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg VkCommandBuffer commandBuffer, 227985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg VkSubpassContents contents) 228085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg{ 228185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 228285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 228385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg assert(cmd_buffer->level == VK_COMMAND_BUFFER_LEVEL_PRIMARY); 228485f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 228585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg anv_cmd_buffer_resolve_subpass(cmd_buffer); 228685f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg genX(cmd_buffer_set_subpass)(cmd_buffer, cmd_buffer->state.subpass + 1); 228785f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg} 228885f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 228985f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsbergvoid genX(CmdEndRenderPass)( 229085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg VkCommandBuffer commandBuffer) 229185f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg{ 229285f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 229385f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg 229478d074b87a75d599e65ef34f5b866da577b80de3Chad Versace genX(cmd_buffer_emit_hz_op)(cmd_buffer, BLORP_HIZ_OP_DEPTH_RESOLVE); 229585f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg anv_cmd_buffer_resolve_subpass(cmd_buffer); 2296ac7eeebce4ae9107863623321b74b1c08389f180Jason Ekstrand 2297ac7eeebce4ae9107863623321b74b1c08389f180Jason Ekstrand#ifndef NDEBUG 2298ac7eeebce4ae9107863623321b74b1c08389f180Jason Ekstrand anv_dump_add_framebuffer(cmd_buffer, cmd_buffer->state.framebuffer); 2299ac7eeebce4ae9107863623321b74b1c08389f180Jason Ekstrand#endif 230085f67cf16e9823c858215e8a7359d18762c2653cKristian Høgsberg} 230181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 230281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenstatic void 23031e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrandemit_ps_depth_count(struct anv_cmd_buffer *cmd_buffer, 230481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen struct anv_bo *bo, uint32_t offset) 230581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 23061e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 230756453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DestinationAddressType = DAT_PPGTT; 230856453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.PostSyncOperation = WritePSDepthCount; 230956453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DepthStallEnable = true; 231056453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.Address = (struct anv_address) { bo, offset }; 2311a6c3d0f92b754e11e74cea9d6bd5ac329c73a8baJason Ekstrand 2312a6c3d0f92b754e11e74cea9d6bd5ac329c73a8baJason Ekstrand if (GEN_GEN == 9 && cmd_buffer->device->info.gt == 4) 2313a6c3d0f92b754e11e74cea9d6bd5ac329c73a8baJason Ekstrand pc.CommandStreamerStallEnable = true; 231456453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 231581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 231681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 231781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenstatic void 23181e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrandemit_query_availability(struct anv_cmd_buffer *cmd_buffer, 231981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen struct anv_bo *bo, uint32_t offset) 232081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 23211e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 232256453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DestinationAddressType = DAT_PPGTT; 232356453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.PostSyncOperation = WriteImmediateData; 232456453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.Address = (struct anv_address) { bo, offset }; 232556453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.ImmediateData = 1; 232656453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 232781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 232881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 232981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenvoid genX(CmdBeginQuery)( 233081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkCommandBuffer commandBuffer, 233181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkQueryPool queryPool, 233281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t query, 233381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkQueryControlFlags flags) 233481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 233581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 233681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_query_pool, pool, queryPool); 233781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 233881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen /* Workaround: When meta uses the pipeline with the VS disabled, it seems 233981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen * that the pipelining of the depth write breaks. What we see is that 234081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen * samples from the render pass clear leaks into the first query 234181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen * immediately after the clear. Doing a pipecontrol with a post-sync 234281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen * operation and DepthStallEnable seems to work around the issue. 234381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen */ 234481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen if (cmd_buffer->state.need_query_wa) { 234581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen cmd_buffer->state.need_query_wa = false; 234650018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 234756453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DepthCacheFlushEnable = true; 234856453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.DepthStallEnable = true; 234956453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 235081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 235181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 235281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen switch (pool->type) { 235381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_QUERY_TYPE_OCCLUSION: 23541e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrand emit_ps_depth_count(cmd_buffer, &pool->bo, 235581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen query * sizeof(struct anv_query_pool_slot)); 235681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen break; 235781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 235881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_QUERY_TYPE_PIPELINE_STATISTICS: 235981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen default: 236081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen unreachable(""); 236181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 236281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 236381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 236481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenvoid genX(CmdEndQuery)( 236581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkCommandBuffer commandBuffer, 236681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkQueryPool queryPool, 236781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t query) 236881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 236981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 237081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_query_pool, pool, queryPool); 237181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 237281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen switch (pool->type) { 237381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_QUERY_TYPE_OCCLUSION: 23741e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrand emit_ps_depth_count(cmd_buffer, &pool->bo, 237581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen query * sizeof(struct anv_query_pool_slot) + 8); 237681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 23771e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrand emit_query_availability(cmd_buffer, &pool->bo, 237881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen query * sizeof(struct anv_query_pool_slot) + 16); 237981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen break; 238081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 238181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_QUERY_TYPE_PIPELINE_STATISTICS: 238281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen default: 238381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen unreachable(""); 238481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 238581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 238681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 238781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define TIMESTAMP 0x2358 238881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 238981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenvoid genX(CmdWriteTimestamp)( 239081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkCommandBuffer commandBuffer, 239181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkPipelineStageFlagBits pipelineStage, 239281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkQueryPool queryPool, 239381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t query) 239481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 239581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 239681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_query_pool, pool, queryPool); 239781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t offset = query * sizeof(struct anv_query_pool_slot); 239881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 239981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen assert(pool->type == VK_QUERY_TYPE_TIMESTAMP); 240081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 240181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen switch (pipelineStage) { 240281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT: 240350018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(MI_STORE_REGISTER_MEM), srm) { 24048a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.RegisterAddress = TIMESTAMP; 24058a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.MemoryAddress = (struct anv_address) { &pool->bo, offset }; 24068a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 240750018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(MI_STORE_REGISTER_MEM), srm) { 24088a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.RegisterAddress = TIMESTAMP + 4; 24098a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.MemoryAddress = (struct anv_address) { &pool->bo, offset + 4 }; 24108a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 241181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen break; 241281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 241381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen default: 241481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen /* Everything else is bottom-of-pipe */ 241550018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 2416696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin pc.DestinationAddressType = DAT_PPGTT; 2417696f5c1853df39359b9dbd733f4c2a1177481556Lionel Landwerlin pc.PostSyncOperation = WriteTimestamp; 24188a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand pc.Address = (struct anv_address) { &pool->bo, offset }; 2419a6c3d0f92b754e11e74cea9d6bd5ac329c73a8baJason Ekstrand 2420a6c3d0f92b754e11e74cea9d6bd5ac329c73a8baJason Ekstrand if (GEN_GEN == 9 && cmd_buffer->device->info.gt == 4) 2421a6c3d0f92b754e11e74cea9d6bd5ac329c73a8baJason Ekstrand pc.CommandStreamerStallEnable = true; 24228a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 242381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen break; 242481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 242581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 24261e3e347fd5d1d55cdb36c39442def31d121ebae5Jason Ekstrand emit_query_availability(cmd_buffer, &pool->bo, query + 16); 242781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 242881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 242981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#if GEN_GEN > 7 || GEN_IS_HASWELL 243081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 243181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define alu_opcode(v) __gen_uint((v), 20, 31) 243281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define alu_operand1(v) __gen_uint((v), 10, 19) 243381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define alu_operand2(v) __gen_uint((v), 0, 9) 243481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define alu(opcode, operand1, operand2) \ 243581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen alu_opcode(opcode) | alu_operand1(operand1) | alu_operand2(operand2) 243681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 243781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_NOOP 0x000 243881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_LOAD 0x080 243981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_LOADINV 0x480 244081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_LOAD0 0x081 244181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_LOAD1 0x481 244281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_ADD 0x100 244381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_SUB 0x101 244481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_AND 0x102 244581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_OR 0x103 244681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_XOR 0x104 244781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_STORE 0x180 244881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPCODE_STOREINV 0x580 244981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 245081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_R0 0x00 245181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_R1 0x01 245281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_R2 0x02 245381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_R3 0x03 245481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_R4 0x04 245581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_SRCA 0x20 245681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_SRCB 0x21 245781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_ACCU 0x31 245881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_ZF 0x32 245981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define OPERAND_CF 0x33 246081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 246181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#define CS_GPR(n) (0x2600 + (n) * 8) 246281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 246381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenstatic void 246481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenemit_load_alu_reg_u64(struct anv_batch *batch, uint32_t reg, 246581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen struct anv_bo *bo, uint32_t offset) 246681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 246750018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_LOAD_REGISTER_MEM), lrm) { 24688a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand lrm.RegisterAddress = reg, 24698a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand lrm.MemoryAddress = (struct anv_address) { bo, offset }; 24708a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 247150018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_LOAD_REGISTER_MEM), lrm) { 24728a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand lrm.RegisterAddress = reg + 4; 24738a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand lrm.MemoryAddress = (struct anv_address) { bo, offset + 4 }; 24748a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 247581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 247681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 247781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenstatic void 247881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenstore_query_result(struct anv_batch *batch, uint32_t reg, 247981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen struct anv_bo *bo, uint32_t offset, VkQueryResultFlags flags) 248081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 248150018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_STORE_REGISTER_MEM), srm) { 24828a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.RegisterAddress = reg; 24838a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.MemoryAddress = (struct anv_address) { bo, offset }; 24848a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 24858a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand 24868a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand if (flags & VK_QUERY_RESULT_64_BIT) { 248750018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(batch, GENX(MI_STORE_REGISTER_MEM), srm) { 24888a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.RegisterAddress = reg + 4; 24898a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand srm.MemoryAddress = (struct anv_address) { bo, offset + 4 }; 24908a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 24918a6ced83e9e936c4c29854148940025c20cd831eJason Ekstrand } 249281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 249381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 249481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justenvoid genX(CmdCopyQueryPoolResults)( 249581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkCommandBuffer commandBuffer, 249681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkQueryPool queryPool, 249781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t firstQuery, 249881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t queryCount, 249981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkBuffer destBuffer, 250081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkDeviceSize destOffset, 250181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkDeviceSize destStride, 250281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen VkQueryResultFlags flags) 250381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen{ 250481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, commandBuffer); 250581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_query_pool, pool, queryPool); 250681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen ANV_FROM_HANDLE(anv_buffer, buffer, destBuffer); 250781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t slot_offset, dst_offset; 250881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 250956453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand if (flags & VK_QUERY_RESULT_WAIT_BIT) { 251050018522d2f2e1deb91710d63e0985c0b3dc8818Jason Ekstrand anv_batch_emit(&cmd_buffer->batch, GENX(PIPE_CONTROL), pc) { 251156453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.CommandStreamerStallEnable = true; 251256453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand pc.StallAtPixelScoreboard = true; 251356453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 251456453eeaff92fdd39cc0818afd96a373899d58f8Jason Ekstrand } 251581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 251681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen dst_offset = buffer->offset + destOffset; 251781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen for (uint32_t i = 0; i < queryCount; i++) { 251881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 251981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen slot_offset = (firstQuery + i) * sizeof(struct anv_query_pool_slot); 252081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen switch (pool->type) { 252181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_QUERY_TYPE_OCCLUSION: 252281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen emit_load_alu_reg_u64(&cmd_buffer->batch, 252381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen CS_GPR(0), &pool->bo, slot_offset); 252481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen emit_load_alu_reg_u64(&cmd_buffer->batch, 252581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen CS_GPR(1), &pool->bo, slot_offset + 8); 252681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 252781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen /* FIXME: We need to clamp the result for 32 bit. */ 252881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 252981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen uint32_t *dw = anv_batch_emitn(&cmd_buffer->batch, 5, GENX(MI_MATH)); 253081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen dw[1] = alu(OPCODE_LOAD, OPERAND_SRCA, OPERAND_R1); 253181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen dw[2] = alu(OPCODE_LOAD, OPERAND_SRCB, OPERAND_R0); 253281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen dw[3] = alu(OPCODE_SUB, 0, 0); 253381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen dw[4] = alu(OPCODE_STORE, OPERAND_R2, OPERAND_ACCU); 253481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen break; 253581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 253681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen case VK_QUERY_TYPE_TIMESTAMP: 253781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen emit_load_alu_reg_u64(&cmd_buffer->batch, 253881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen CS_GPR(2), &pool->bo, slot_offset); 253981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen break; 254081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 254181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen default: 254281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen unreachable("unhandled query type"); 254381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 254481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 254581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen store_query_result(&cmd_buffer->batch, 254681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen CS_GPR(2), buffer->bo, dst_offset, flags); 254781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 254881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen if (flags & VK_QUERY_RESULT_WITH_AVAILABILITY_BIT) { 254981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen emit_load_alu_reg_u64(&cmd_buffer->batch, CS_GPR(0), 255081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen &pool->bo, slot_offset + 16); 255181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen if (flags & VK_QUERY_RESULT_64_BIT) 255281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen store_query_result(&cmd_buffer->batch, 255381f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen CS_GPR(0), buffer->bo, dst_offset + 8, flags); 255481f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen else 255581f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen store_query_result(&cmd_buffer->batch, 255681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen CS_GPR(0), buffer->bo, dst_offset + 4, flags); 255781f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 255881f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 255981f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen dst_offset += destStride; 256081f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen } 256181f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen} 256281f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen 2563b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand#else 2564b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrandvoid genX(CmdCopyQueryPoolResults)( 2565b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand VkCommandBuffer commandBuffer, 2566b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand VkQueryPool queryPool, 2567b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand uint32_t firstQuery, 2568b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand uint32_t queryCount, 2569b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand VkBuffer destBuffer, 2570b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand VkDeviceSize destOffset, 2571b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand VkDeviceSize destStride, 2572b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand VkQueryResultFlags flags) 2573b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand{ 2574b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand anv_finishme("Queries not yet supported on Ivy Bridge"); 2575b9e99282a6e1b3b2b01645e37bf4b735aace677bJason Ekstrand} 257681f30e2f509b4fcd79376ff02363aba831918ac6Jordan Justen#endif 2577