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