X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fdrivers%2Fdri%2Fi965%2Fbrw_wm_surface_state.c;h=a0fed6096d26880a7149fa63d235d0d9a8da409c;hb=688ddb85c8c3357d8e1e9d360c74cd728b128d98;hp=c1a7579bb285f55b6b986ebd5a4908b8254f5e59;hpb=745f5778f3f0faa1fc2eae22edc489811673d70f;p=mesa.git diff --git a/src/mesa/drivers/dri/i965/brw_wm_surface_state.c b/src/mesa/drivers/dri/i965/brw_wm_surface_state.c index c1a7579bb28..a0fed6096d2 100644 --- a/src/mesa/drivers/dri/i965/brw_wm_surface_state.c +++ b/src/mesa/drivers/dri/i965/brw_wm_surface_state.c @@ -30,6 +30,7 @@ */ +#include "compiler/nir/nir.h" #include "main/context.h" #include "main/blend.h" #include "main/mtypes.h" @@ -39,6 +40,7 @@ #include "program/prog_parameter.h" #include "program/prog_instruction.h" #include "main/framebuffer.h" +#include "main/shaderapi.h" #include "isl/isl.h" @@ -53,70 +55,121 @@ #include "brw_defines.h" #include "brw_wm.h" -struct surface_state_info { - unsigned num_dwords; - unsigned ss_align; /* Required alignment of RENDER_SURFACE_STATE in bytes */ - unsigned reloc_dw; - unsigned aux_reloc_dw; - unsigned tex_mocs; - unsigned rb_mocs; +enum { + INTEL_RENDERBUFFER_LAYERED = 1 << 0, + INTEL_AUX_BUFFER_DISABLED = 1 << 1, }; -static const struct surface_state_info surface_state_infos[] = { - [4] = {6, 32, 1, 0}, - [5] = {6, 32, 1, 0}, - [6] = {6, 32, 1, 0}, - [7] = {8, 32, 1, 6, GEN7_MOCS_L3, GEN7_MOCS_L3}, - [8] = {13, 64, 8, 10, BDW_MOCS_WB, BDW_MOCS_PTE}, - [9] = {16, 64, 8, 10, SKL_MOCS_WB, SKL_MOCS_PTE}, +uint32_t tex_mocs[] = { + [7] = GEN7_MOCS_L3, + [8] = BDW_MOCS_WB, + [9] = SKL_MOCS_WB, }; -void +uint32_t rb_mocs[] = { + [7] = GEN7_MOCS_L3, + [8] = BDW_MOCS_PTE, + [9] = SKL_MOCS_PTE, +}; + +static void brw_emit_surface_state(struct brw_context *brw, - struct intel_mipmap_tree *mt, - const struct isl_view *view, - uint32_t mocs, bool for_gather, - uint32_t *surf_offset, int surf_index, + struct intel_mipmap_tree *mt, uint32_t flags, + GLenum target, struct isl_view view, + uint32_t mocs, uint32_t *surf_offset, int surf_index, unsigned read_domains, unsigned write_domains) { - const struct surface_state_info ss_info = surface_state_infos[brw->gen]; + uint32_t tile_x = mt->level[0].slice[0].x_offset; + uint32_t tile_y = mt->level[0].slice[0].y_offset; + uint32_t offset = mt->offset; struct isl_surf surf; intel_miptree_get_isl_surf(brw, mt, &surf); + surf.dim = get_isl_surf_dim(target); + + const enum isl_dim_layout dim_layout = + get_isl_dim_layout(&brw->screen->devinfo, mt->tiling, target); + + if (surf.dim_layout != dim_layout) { + /* The layout of the specified texture target is not compatible with the + * actual layout of the miptree structure in memory -- You're entering + * dangerous territory, this can only possibly work if you only intended + * to access a single level and slice of the texture, and the hardware + * supports the tile offset feature in order to allow non-tile-aligned + * base offsets, since we'll have to point the hardware to the first + * texel of the level instead of relying on the usual base level/layer + * controls. + */ + assert(brw->has_surface_tile_offset); + assert(view.levels == 1 && view.array_len == 1); + assert(tile_x == 0 && tile_y == 0); + + offset += intel_miptree_get_tile_offsets(mt, view.base_level, + view.base_array_layer, + &tile_x, &tile_y); + + /* Minify the logical dimensions of the texture. */ + const unsigned l = view.base_level - mt->first_level; + surf.logical_level0_px.width = minify(surf.logical_level0_px.width, l); + surf.logical_level0_px.height = surf.dim <= ISL_SURF_DIM_1D ? 1 : + minify(surf.logical_level0_px.height, l); + surf.logical_level0_px.depth = surf.dim <= ISL_SURF_DIM_2D ? 1 : + minify(surf.logical_level0_px.depth, l); + + /* Only the base level and layer can be addressed with the overridden + * layout. + */ + surf.logical_level0_px.array_len = 1; + surf.levels = 1; + surf.dim_layout = dim_layout; + + /* The requested slice of the texture is now at the base level and + * layer. + */ + view.base_level = 0; + view.base_array_layer = 0; + } + union isl_color_value clear_color = { .u32 = { 0, 0, 0, 0 } }; + struct brw_bo *aux_bo; struct isl_surf *aux_surf = NULL, aux_surf_s; uint64_t aux_offset = 0; enum isl_aux_usage aux_usage = ISL_AUX_USAGE_NONE; - if (mt->mcs_mt && - ((view->usage & ISL_SURF_USAGE_RENDER_TARGET_BIT) || - mt->fast_clear_state != INTEL_FAST_CLEAR_STATE_RESOLVED)) { + if ((mt->mcs_buf || intel_miptree_sample_with_hiz(brw, mt)) && + !(flags & INTEL_AUX_BUFFER_DISABLED)) { intel_miptree_get_aux_isl_surf(brw, mt, &aux_surf_s, &aux_usage); aux_surf = &aux_surf_s; - assert(mt->mcs_mt->offset == 0); - aux_offset = mt->mcs_mt->bo->offset64; + + if (mt->mcs_buf) { + aux_bo = mt->mcs_buf->bo; + aux_offset = mt->mcs_buf->bo->offset64 + mt->mcs_buf->offset; + } else { + aux_bo = mt->hiz_buf->aux_base.bo; + aux_offset = mt->hiz_buf->aux_base.bo->offset64; + } /* We only really need a clear color if we also have an auxiliary - * surfacae. Without one, it does nothing. + * surface. Without one, it does nothing. */ clear_color = intel_miptree_get_isl_clear_color(brw, mt); } - uint32_t *dw = __brw_state_batch(brw, AUB_TRACE_SURFACE_STATE, - ss_info.num_dwords * 4, ss_info.ss_align, - surf_index, surf_offset); + void *state = brw_state_batch(brw, + brw->isl_dev.ss.size, + brw->isl_dev.ss.align, + surf_offset); - isl_surf_fill_state(&brw->isl_dev, dw, .surf = &surf, .view = view, - .address = mt->bo->offset64 + mt->offset, + isl_surf_fill_state(&brw->isl_dev, state, .surf = &surf, .view = &view, + .address = mt->bo->offset64 + offset, .aux_surf = aux_surf, .aux_usage = aux_usage, .aux_address = aux_offset, - .mocs = mocs, .clear_color = clear_color); + .mocs = mocs, .clear_color = clear_color, + .x_offset_sa = tile_x, .y_offset_sa = tile_y); - drm_intel_bo_emit_reloc(brw->batch.bo, - *surf_offset + 4 * ss_info.reloc_dw, - mt->bo, mt->offset, - read_domains, write_domains); + brw_emit_reloc(&brw->batch, *surf_offset + brw->isl_dev.ss.addr_offset, + mt->bo, offset, read_domains, write_domains); if (aux_surf) { /* On gen7 and prior, the upper 20 bits of surface state DWORD 6 are the @@ -126,25 +179,29 @@ brw_emit_surface_state(struct brw_context *brw, * an ordinary reloc to do the necessary address translation. */ assert((aux_offset & 0xfff) == 0); - drm_intel_bo_emit_reloc(brw->batch.bo, - *surf_offset + 4 * ss_info.aux_reloc_dw, - mt->mcs_mt->bo, dw[ss_info.aux_reloc_dw] & 0xfff, - read_domains, write_domains); + uint32_t *aux_addr = state + brw->isl_dev.ss.aux_addr_offset; + brw_emit_reloc(&brw->batch, + *surf_offset + brw->isl_dev.ss.aux_addr_offset, + aux_bo, *aux_addr - aux_bo->offset64, + read_domains, write_domains); } } uint32_t brw_update_renderbuffer_surface(struct brw_context *brw, struct gl_renderbuffer *rb, - bool layered, unsigned unit /* unused */, + uint32_t flags, unsigned unit /* unused */, uint32_t surf_index) { struct gl_context *ctx = &brw->ctx; struct intel_renderbuffer *irb = intel_renderbuffer(rb); struct intel_mipmap_tree *mt = irb->mt; + if (brw->gen < 9) { + assert(!(flags & INTEL_AUX_BUFFER_DISABLED)); + } + assert(brw_render_target_supported(brw, rb)); - intel_miptree_used_for_rendering(mt); mesa_format rb_format = _mesa_get_render_format(ctx, intel_rb_format(irb)); if (unlikely(!brw->format_supported_as_render_target[rb_format])) { @@ -163,18 +220,13 @@ brw_update_renderbuffer_surface(struct brw_context *brw, .levels = 1, .base_array_layer = irb->mt_layer / layer_multiplier, .array_len = MAX2(irb->layer_count, 1), - .channel_select = { - ISL_CHANNEL_SELECT_RED, - ISL_CHANNEL_SELECT_GREEN, - ISL_CHANNEL_SELECT_BLUE, - ISL_CHANNEL_SELECT_ALPHA, - }, + .swizzle = ISL_SWIZZLE_IDENTITY, .usage = ISL_SURF_USAGE_RENDER_TARGET_BIT, }; uint32_t offset; - brw_emit_surface_state(brw, mt, &view, - surface_state_infos[brw->gen].rb_mocs, false, + brw_emit_surface_state(brw, mt, flags, mt->target, view, + rb_mocs[brw->gen], &offset, surf_index, I915_GEM_DOMAIN_RENDER, I915_GEM_DOMAIN_RENDER); @@ -337,7 +389,9 @@ brw_get_texture_swizzle(const struct gl_context *ctx, case GL_RED: case GL_RG: case GL_RGB: - if (_mesa_get_format_bits(img->TexFormat, GL_ALPHA_BITS) > 0) + if (_mesa_get_format_bits(img->TexFormat, GL_ALPHA_BITS) > 0 || + img->TexFormat == MESA_FORMAT_RGB_DXT1 || + img->TexFormat == MESA_FORMAT_SRGB_DXT1) swizzles[3] = SWIZZLE_ONE; break; } @@ -369,6 +423,97 @@ swizzle_to_scs(GLenum swizzle, bool need_green_to_blue) return (need_green_to_blue && scs == HSW_SCS_GREEN) ? HSW_SCS_BLUE : scs; } +static unsigned +brw_find_matching_rb(const struct gl_framebuffer *fb, + const struct intel_mipmap_tree *mt) +{ + for (unsigned i = 0; i < fb->_NumColorDrawBuffers; i++) { + const struct intel_renderbuffer *irb = + intel_renderbuffer(fb->_ColorDrawBuffers[i]); + + if (irb && irb->mt == mt) + return i; + } + + return fb->_NumColorDrawBuffers; +} + +static inline bool +brw_texture_view_sane(const struct brw_context *brw, + const struct intel_mipmap_tree *mt, + const struct isl_view *view) +{ + /* There are special cases only for lossless compression. */ + if (!intel_miptree_is_lossless_compressed(brw, mt)) + return true; + + if (isl_format_supports_ccs_e(&brw->screen->devinfo, view->format)) + return true; + + /* Logic elsewhere needs to take care to resolve the color buffer prior + * to sampling it as non-compressed. + */ + if (intel_miptree_has_color_unresolved(mt, view->base_level, view->levels, + view->base_array_layer, + view->array_len)) + return false; + + const struct gl_framebuffer *fb = brw->ctx.DrawBuffer; + const unsigned rb_index = brw_find_matching_rb(fb, mt); + + if (rb_index == fb->_NumColorDrawBuffers) + return true; + + /* Underlying surface is compressed but it is sampled using a format that + * the sampling engine doesn't support as compressed. Compression must be + * disabled for both sampling engine and data port in case the same surface + * is used also as render target. + */ + return brw->draw_aux_buffer_disabled[rb_index]; +} + +static bool +brw_disable_aux_surface(const struct brw_context *brw, + const struct intel_mipmap_tree *mt, + const struct isl_view *view) +{ + /* Nothing to disable. */ + if (!mt->mcs_buf) + return false; + + const bool is_unresolved = intel_miptree_has_color_unresolved( + mt, view->base_level, view->levels, + view->base_array_layer, view->array_len); + + /* There are special cases only for lossless compression. */ + if (!intel_miptree_is_lossless_compressed(brw, mt)) + return !is_unresolved; + + const struct gl_framebuffer *fb = brw->ctx.DrawBuffer; + const unsigned rb_index = brw_find_matching_rb(fb, mt); + + /* If we are drawing into this with compression enabled, then we must also + * enable compression when texturing from it regardless of + * fast_clear_state. If we don't then, after the first draw call with + * this setup, there will be data in the CCS which won't get picked up by + * subsequent texturing operations as required by ARB_texture_barrier. + * Since we don't want to re-emit the binding table or do a resolve + * operation every draw call, the easiest thing to do is just enable + * compression on the texturing side. This is completely safe to do + * since, if compressed texturing weren't allowed, we would have disabled + * compression of render targets in whatever_that_function_is_called(). + */ + if (rb_index < fb->_NumColorDrawBuffers) { + if (brw->draw_aux_buffer_disabled[rb_index]) { + assert(!is_unresolved); + } + + return brw->draw_aux_buffer_disabled[rb_index]; + } + + return !is_unresolved; +} + void brw_update_texture_surface(struct gl_context *ctx, unsigned unit, @@ -385,15 +530,20 @@ brw_update_texture_surface(struct gl_context *ctx, } else { struct intel_texture_object *intel_obj = intel_texture_object(obj); struct intel_mipmap_tree *mt = intel_obj->mt; + + if (plane > 0) { + if (mt->plane[plane - 1] == NULL) + return; + mt = mt->plane[plane - 1]; + } + struct gl_sampler_object *sampler = _mesa_get_samplerobj(ctx, unit); /* If this is a view with restricted NumLayers, then our effective depth * is not just the miptree depth. */ - const unsigned mt_num_layers = - mt->logical_depth0 * (_mesa_is_cube_map_texture(mt->target) ? 6 : 1); const unsigned view_num_layers = (obj->Immutable && obj->Target != GL_TEXTURE_3D) ? obj->NumLayers : - mt_num_layers; + mt->logical_depth0; /* Handling GL_ALPHA as a surface format override breaks 1.30+ style * texturing functions that return a float, as our code generation always @@ -406,14 +556,17 @@ brw_update_texture_surface(struct gl_context *ctx, const unsigned swizzle = (unlikely(alpha_depth) ? SWIZZLE_XYZW : brw_get_texture_swizzle(&brw->ctx, obj)); - unsigned format = translate_tex_format( - brw, intel_obj->_Format, sampler->sRGBDecode); + mesa_format mesa_fmt = plane == 0 ? intel_obj->_Format : mt->format; + unsigned format = translate_tex_format(brw, mesa_fmt, + sampler->sRGBDecode); /* Implement gen6 and gen7 gather work-around */ bool need_green_to_blue = false; if (for_gather) { - if (brw->gen == 7 && format == BRW_SURFACEFORMAT_R32G32_FLOAT) { - format = BRW_SURFACEFORMAT_R32G32_FLOAT_LD; + if (brw->gen == 7 && (format == ISL_FORMAT_R32G32_FLOAT || + format == ISL_FORMAT_R32G32_SINT || + format == ISL_FORMAT_R32G32_UINT)) { + format = ISL_FORMAT_R32G32_FLOAT_LD; need_green_to_blue = brw->is_haswell; } else if (brw->gen == 6) { /* Sandybridge's gather4 message is broken for integer formats. @@ -424,19 +577,19 @@ brw_update_texture_surface(struct gl_context *ctx, * bits. */ switch (format) { - case BRW_SURFACEFORMAT_R8_SINT: - case BRW_SURFACEFORMAT_R8_UINT: - format = BRW_SURFACEFORMAT_R8_UNORM; + case ISL_FORMAT_R8_SINT: + case ISL_FORMAT_R8_UINT: + format = ISL_FORMAT_R8_UNORM; break; - case BRW_SURFACEFORMAT_R16_SINT: - case BRW_SURFACEFORMAT_R16_UINT: - format = BRW_SURFACEFORMAT_R16_UNORM; + case ISL_FORMAT_R16_SINT: + case ISL_FORMAT_R16_UINT: + format = ISL_FORMAT_R16_UNORM; break; - case BRW_SURFACEFORMAT_R32_SINT: - case BRW_SURFACEFORMAT_R32_UINT: - format = BRW_SURFACEFORMAT_R32_FLOAT; + case ISL_FORMAT_R32_SINT: + case ISL_FORMAT_R32_UINT: + format = ISL_FORMAT_R32_FLOAT; break; default: @@ -446,15 +599,17 @@ brw_update_texture_surface(struct gl_context *ctx, } if (obj->StencilSampling && firstImage->_BaseFormat == GL_DEPTH_STENCIL) { - assert(brw->gen >= 8); - mt = mt->stencil_mt; - format = BRW_SURFACEFORMAT_R8_UINT; - } else if (obj->Target == GL_TEXTURE_EXTERNAL_OES) { - if (plane > 0) - mt = mt->plane[plane - 1]; - if (mt == NULL) - return; - format = translate_tex_format(brw, mt->format, sampler->sRGBDecode); + if (brw->gen <= 7) { + assert(mt->r8stencil_mt && !mt->stencil_mt->r8stencil_needs_update); + mt = mt->r8stencil_mt; + } else { + mt = mt->stencil_mt; + } + format = ISL_FORMAT_R8_UINT; + } else if (brw->gen <= 7 && mt->format == MESA_FORMAT_S_UINT8) { + assert(mt->r8stencil_mt && !mt->r8stencil_needs_update); + mt = mt->r8stencil_mt; + format = ISL_FORMAT_R8_UINT; } const int surf_index = surf_offset - &brw->wm.base.surf_offset[0]; @@ -465,11 +620,11 @@ brw_update_texture_surface(struct gl_context *ctx, .levels = intel_obj->_MaxLevel - obj->BaseLevel + 1, .base_array_layer = obj->MinLayer, .array_len = view_num_layers, - .channel_select = { - swizzle_to_scs(GET_SWZ(swizzle, 0), need_green_to_blue), - swizzle_to_scs(GET_SWZ(swizzle, 1), need_green_to_blue), - swizzle_to_scs(GET_SWZ(swizzle, 2), need_green_to_blue), - swizzle_to_scs(GET_SWZ(swizzle, 3), need_green_to_blue), + .swizzle = { + .r = swizzle_to_scs(GET_SWZ(swizzle, 0), need_green_to_blue), + .g = swizzle_to_scs(GET_SWZ(swizzle, 1), need_green_to_blue), + .b = swizzle_to_scs(GET_SWZ(swizzle, 2), need_green_to_blue), + .a = swizzle_to_scs(GET_SWZ(swizzle, 3), need_green_to_blue), }, .usage = ISL_SURF_USAGE_TEXTURE_BIT, }; @@ -478,8 +633,12 @@ brw_update_texture_surface(struct gl_context *ctx, obj->Target == GL_TEXTURE_CUBE_MAP_ARRAY) view.usage |= ISL_SURF_USAGE_CUBE_BIT; - brw_emit_surface_state(brw, mt, &view, - surface_state_infos[brw->gen].tex_mocs, for_gather, + assert(brw_texture_view_sane(brw, mt, &view)); + + const int flags = brw_disable_aux_surface(brw, mt, &view) ? + INTEL_AUX_BUFFER_DISABLED : 0; + brw_emit_surface_state(brw, mt, flags, mt->target, view, + tex_mocs[brw->gen], surf_offset, surf_index, I915_GEM_DOMAIN_SAMPLER, 0); } @@ -488,17 +647,16 @@ brw_update_texture_surface(struct gl_context *ctx, void brw_emit_buffer_surface_state(struct brw_context *brw, uint32_t *out_offset, - drm_intel_bo *bo, + struct brw_bo *bo, unsigned buffer_offset, unsigned surface_format, unsigned buffer_size, unsigned pitch, bool rw) { - const struct surface_state_info ss_info = surface_state_infos[brw->gen]; - - uint32_t *dw = brw_state_batch(brw, AUB_TRACE_SURFACE_STATE, - ss_info.num_dwords * 4, ss_info.ss_align, + uint32_t *dw = brw_state_batch(brw, + brw->isl_dev.ss.size, + brw->isl_dev.ss.align, out_offset); isl_buffer_fill_state(&brw->isl_dev, dw, @@ -506,14 +664,13 @@ brw_emit_buffer_surface_state(struct brw_context *brw, .size = buffer_size, .format = surface_format, .stride = pitch, - .mocs = ss_info.tex_mocs); + .mocs = tex_mocs[brw->gen]); if (bo) { - drm_intel_bo_emit_reloc(brw->batch.bo, - *out_offset + 4 * ss_info.reloc_dw, - bo, buffer_offset, - I915_GEM_DOMAIN_SAMPLER, - (rw ? I915_GEM_DOMAIN_SAMPLER : 0)); + brw_emit_reloc(&brw->batch, *out_offset + brw->isl_dev.ss.addr_offset, + bo, buffer_offset, + I915_GEM_DOMAIN_SAMPLER, + (rw ? I915_GEM_DOMAIN_SAMPLER : 0)); } } @@ -527,9 +684,9 @@ brw_update_buffer_texture_surface(struct gl_context *ctx, struct intel_buffer_object *intel_obj = intel_buffer_object(tObj->BufferObject); uint32_t size = tObj->BufferSize; - drm_intel_bo *bo = NULL; + struct brw_bo *bo = NULL; mesa_format format = tObj->_BufferObjectFormat; - uint32_t brw_format = brw_format_for_mesa_format(format); + uint32_t brw_format = brw_isl_format_for_mesa_format(format); int texel_size = _mesa_get_format_bytes(format); if (intel_obj) { @@ -537,6 +694,24 @@ brw_update_buffer_texture_surface(struct gl_context *ctx, bo = intel_bufferobj_buffer(brw, intel_obj, tObj->BufferOffset, size); } + /* The ARB_texture_buffer_specification says: + * + * "The number of texels in the buffer texture's texel array is given by + * + * floor( / ( * sizeof()), + * + * where is the size of the buffer object, in basic + * machine units and and are the element count + * and base data type for elements, as specified in Table X.1. The + * number of texels in the texel array is then clamped to the + * implementation-dependent limit MAX_TEXTURE_BUFFER_SIZE_ARB." + * + * We need to clamp the size in bytes to MAX_TEXTURE_BUFFER_SIZE * stride, + * so that when ISL divides by stride to obtain the number of texels, that + * texel count is clamped to MAX_TEXTURE_BUFFER_SIZE. + */ + size = MIN2(size, ctx->Const.MaxTextureBufferSize * (unsigned) texel_size); + if (brw_format == 0 && format != MESA_FORMAT_RGBA_FLOAT32) { _mesa_problem(NULL, "bad format %s for texture buffer\n", _mesa_get_format_name(format)); @@ -556,13 +731,13 @@ brw_update_buffer_texture_surface(struct gl_context *ctx, */ void brw_create_constant_surface(struct brw_context *brw, - drm_intel_bo *bo, + struct brw_bo *bo, uint32_t offset, uint32_t size, uint32_t *out_offset) { brw_emit_buffer_surface_state(brw, out_offset, bo, offset, - BRW_SURFACEFORMAT_R32G32B32A32_FLOAT, + ISL_FORMAT_R32G32B32A32_FLOAT, size, 1, false); } @@ -573,7 +748,7 @@ brw_create_constant_surface(struct brw_context *brw, */ void brw_create_buffer_surface(struct brw_context *brw, - drm_intel_bo *bo, + struct brw_bo *bo, uint32_t offset, uint32_t size, uint32_t *out_offset) @@ -584,7 +759,7 @@ brw_create_buffer_surface(struct brw_context *brw, * with helper invocations, which cannot write to the buffer. */ brw_emit_buffer_surface_state(brw, out_offset, bo, offset, - BRW_SURFACEFORMAT_RAW, + ISL_FORMAT_RAW, size, 1, true); } @@ -602,11 +777,10 @@ brw_update_sol_surface(struct brw_context *brw, { struct intel_buffer_object *intel_bo = intel_buffer_object(buffer_obj); uint32_t offset_bytes = 4 * offset_dwords; - drm_intel_bo *bo = intel_bufferobj_buffer(brw, intel_bo, + struct brw_bo *bo = intel_bufferobj_buffer(brw, intel_bo, offset_bytes, buffer_obj->Size - offset_bytes); - uint32_t *surf = brw_state_batch(brw, AUB_TRACE_SURFACE_STATE, 6 * 4, 32, - out_offset); + uint32_t *surf = brw_state_batch(brw, 6 * 4, 32, out_offset); uint32_t pitch_minus_1 = 4*stride_dwords - 1; size_t size_dwords = buffer_obj->Size / 4; uint32_t buffer_size_minus_1, width, height, depth, surface_format; @@ -639,16 +813,16 @@ brw_update_sol_surface(struct brw_context *brw, switch (num_vector_components) { case 1: - surface_format = BRW_SURFACEFORMAT_R32_FLOAT; + surface_format = ISL_FORMAT_R32_FLOAT; break; case 2: - surface_format = BRW_SURFACEFORMAT_R32G32_FLOAT; + surface_format = ISL_FORMAT_R32G32_FLOAT; break; case 3: - surface_format = BRW_SURFACEFORMAT_R32G32B32_FLOAT; + surface_format = ISL_FORMAT_R32G32B32_FLOAT; break; case 4: - surface_format = BRW_SURFACEFORMAT_R32G32B32A32_FLOAT; + surface_format = ISL_FORMAT_R32G32B32A32_FLOAT; break; default: unreachable("Invalid vector size for transform feedback output"); @@ -667,10 +841,8 @@ brw_update_sol_surface(struct brw_context *brw, surf[5] = 0; /* Emit relocation to surface contents. */ - drm_intel_bo_emit_reloc(brw->batch.bo, - *out_offset + 4, - bo, offset_bytes, - I915_GEM_DOMAIN_RENDER, I915_GEM_DOMAIN_RENDER); + brw_emit_reloc(&brw->batch, *out_offset + 4, bo, offset_bytes, + I915_GEM_DOMAIN_RENDER, I915_GEM_DOMAIN_RENDER); } /* Creates a new WM constant buffer reflecting the current fragment program's @@ -684,13 +856,13 @@ brw_upload_wm_pull_constants(struct brw_context *brw) { struct brw_stage_state *stage_state = &brw->wm.base; /* BRW_NEW_FRAGMENT_PROGRAM */ - struct brw_fragment_program *fp = - (struct brw_fragment_program *) brw->fragment_program; + struct brw_program *fp = (struct brw_program *) brw->fragment_program; /* BRW_NEW_FS_PROG_DATA */ - struct brw_stage_prog_data *prog_data = &brw->wm.prog_data->base; + struct brw_stage_prog_data *prog_data = brw->wm.base.prog_data; + _mesa_shader_write_subroutine_indices(&brw->ctx, MESA_SHADER_FRAGMENT); /* _NEW_PROGRAM_CONSTANTS */ - brw_upload_pull_constants(brw, BRW_NEW_SURFACES, &fp->program.Base, + brw_upload_pull_constants(brw, BRW_NEW_SURFACES, &fp->program, stage_state, prog_data); } @@ -739,11 +911,10 @@ brw_emit_null_surface_state(struct brw_context *brw, * - Surface Format must be R8G8B8A8_UNORM. */ unsigned surface_type = BRW_SURFACE_NULL; - drm_intel_bo *bo = NULL; + struct brw_bo *bo = NULL; unsigned pitch_minus_1 = 0; uint32_t multisampling_state = 0; - uint32_t *surf = brw_state_batch(brw, AUB_TRACE_SURFACE_STATE, 6 * 4, 32, - out_offset); + uint32_t *surf = brw_state_batch(brw, 6 * 4, 32, out_offset); if (samples > 1) { /* On Gen6, null render targets seem to cause GPU hangs when @@ -772,7 +943,7 @@ brw_emit_null_surface_state(struct brw_context *brw, } surf[0] = (surface_type << BRW_SURFACE_TYPE_SHIFT | - BRW_SURFACEFORMAT_B8G8R8A8_UNORM << BRW_SURFACE_FORMAT_SHIFT); + ISL_FORMAT_B8G8R8A8_UNORM << BRW_SURFACE_FORMAT_SHIFT); if (brw->gen < 6) { surf[0] |= (1 << BRW_SURFACE_WRITEDISABLE_R_SHIFT | 1 << BRW_SURFACE_WRITEDISABLE_G_SHIFT | @@ -794,10 +965,8 @@ brw_emit_null_surface_state(struct brw_context *brw, surf[5] = 0; if (bo) { - drm_intel_bo_emit_reloc(brw->batch.bo, - *out_offset + 4, - bo, 0, - I915_GEM_DOMAIN_RENDER, I915_GEM_DOMAIN_RENDER); + brw_emit_reloc(&brw->batch, *out_offset + 4, bo, 0, + I915_GEM_DOMAIN_RENDER, I915_GEM_DOMAIN_RENDER); } } @@ -809,7 +978,7 @@ brw_emit_null_surface_state(struct brw_context *brw, static uint32_t gen4_update_renderbuffer_surface(struct brw_context *brw, struct gl_renderbuffer *rb, - bool layered, unsigned unit, + uint32_t flags, unsigned unit, uint32_t surf_index) { struct gl_context *ctx = &brw->ctx; @@ -823,7 +992,8 @@ gen4_update_renderbuffer_surface(struct brw_context *brw, mesa_format rb_format = _mesa_get_render_format(ctx, intel_rb_format(irb)); /* BRW_NEW_FS_PROG_DATA */ - assert(!layered); + assert(!(flags & INTEL_RENDERBUFFER_LAYERED)); + assert(!(flags & INTEL_AUX_BUFFER_DISABLED)); if (rb->TexImage && !brw->has_surface_tile_offset) { intel_renderbuffer_get_tile_offsets(irb, &tile_x, &tile_y); @@ -840,9 +1010,7 @@ gen4_update_renderbuffer_surface(struct brw_context *brw, } } - intel_miptree_used_for_rendering(irb->mt); - - surf = brw_state_batch(brw, AUB_TRACE_SURFACE_STATE, 6 * 4, 32, &offset); + surf = brw_state_batch(brw, 6 * 4, 32, &offset); format = brw->render_target_format[rb_format]; if (unlikely(!brw->format_supported_as_render_target[rb_format])) { @@ -878,8 +1046,8 @@ gen4_update_renderbuffer_surface(struct brw_context *brw, if (brw->gen < 6) { /* _NEW_COLOR */ - if (!ctx->Color.ColorLogicOpEnabled && - (ctx->Color.BlendEnabled & (1 << unit))) + if (!ctx->Color.ColorLogicOpEnabled && !ctx->Color._AdvancedBlendMode && + (ctx->Color.BlendEnabled & (1 << unit))) surf[0] |= BRW_SURFACE_BLEND_ENABLED; if (!ctx->Color.ColorMask[unit][0]) @@ -898,12 +1066,8 @@ gen4_update_renderbuffer_surface(struct brw_context *brw, } } - drm_intel_bo_emit_reloc(brw->batch.bo, - offset + 4, - mt->bo, - surf[1] - mt->bo->offset64, - I915_GEM_DOMAIN_RENDER, - I915_GEM_DOMAIN_RENDER); + brw_emit_reloc(&brw->batch, offset + 4, mt->bo, surf[1] - mt->bo->offset64, + I915_GEM_DOMAIN_RENDER, I915_GEM_DOMAIN_RENDER); return offset; } @@ -926,12 +1090,15 @@ brw_update_renderbuffer_surfaces(struct brw_context *brw, if (fb->_NumColorDrawBuffers >= 1) { for (i = 0; i < fb->_NumColorDrawBuffers; i++) { const uint32_t surf_index = render_target_start + i; + const int flags = (_mesa_geometric_layers(fb) > 0 ? + INTEL_RENDERBUFFER_LAYERED : 0) | + (brw->draw_aux_buffer_disabled[i] ? + INTEL_AUX_BUFFER_DISABLED : 0); if (intel_renderbuffer(fb->_ColorDrawBuffers[i])) { surf_offset[surf_index] = brw->vtbl.update_renderbuffer_surface( - brw, fb->_ColorDrawBuffers[i], - _mesa_geometric_layers(fb) > 0, i, surf_index); + brw, fb->_ColorDrawBuffers[i], flags, i, surf_index); } else { brw->vtbl.emit_null_surface_state(brw, w, h, s, &surf_offset[surf_index]); @@ -949,11 +1116,15 @@ update_renderbuffer_surfaces(struct brw_context *brw) { const struct gl_context *ctx = &brw->ctx; + /* BRW_NEW_FS_PROG_DATA */ + const struct brw_wm_prog_data *wm_prog_data = + brw_wm_prog_data(brw->wm.base.prog_data); + /* _NEW_BUFFERS | _NEW_COLOR */ const struct gl_framebuffer *fb = ctx->DrawBuffer; brw_update_renderbuffer_surfaces( brw, fb, - brw->wm.prog_data->binding_table.render_target_start, + wm_prog_data->binding_table.render_target_start, brw->wm.base.surf_offset); brw->ctx.NewDriverState |= BRW_NEW_SURFACES; } @@ -978,6 +1149,96 @@ const struct brw_tracked_state gen6_renderbuffer_surfaces = { .emit = update_renderbuffer_surfaces, }; +static void +update_renderbuffer_read_surfaces(struct brw_context *brw) +{ + const struct gl_context *ctx = &brw->ctx; + + /* BRW_NEW_FS_PROG_DATA */ + const struct brw_wm_prog_data *wm_prog_data = + brw_wm_prog_data(brw->wm.base.prog_data); + + /* BRW_NEW_FRAGMENT_PROGRAM */ + if (!ctx->Extensions.MESA_shader_framebuffer_fetch && + brw->fragment_program && brw->fragment_program->info.outputs_read) { + /* _NEW_BUFFERS */ + const struct gl_framebuffer *fb = ctx->DrawBuffer; + + for (unsigned i = 0; i < fb->_NumColorDrawBuffers; i++) { + struct gl_renderbuffer *rb = fb->_ColorDrawBuffers[i]; + const struct intel_renderbuffer *irb = intel_renderbuffer(rb); + const unsigned surf_index = + wm_prog_data->binding_table.render_target_read_start + i; + uint32_t *surf_offset = &brw->wm.base.surf_offset[surf_index]; + + if (irb) { + const unsigned format = brw->render_target_format[ + _mesa_get_render_format(ctx, intel_rb_format(irb))]; + assert(isl_format_supports_sampling(&brw->screen->devinfo, + format)); + + /* Override the target of the texture if the render buffer is a + * single slice of a 3D texture (since the minimum array element + * field of the surface state structure is ignored by the sampler + * unit for 3D textures on some hardware), or if the render buffer + * is a 1D array (since shaders always provide the array index + * coordinate at the Z component to avoid state-dependent + * recompiles when changing the texture target of the + * framebuffer). + */ + const GLenum target = + (irb->mt->target == GL_TEXTURE_3D && + irb->layer_count == 1) ? GL_TEXTURE_2D : + irb->mt->target == GL_TEXTURE_1D_ARRAY ? GL_TEXTURE_2D_ARRAY : + irb->mt->target; + + /* intel_renderbuffer::mt_layer is expressed in sample units for + * the UMS and CMS multisample layouts, but + * intel_renderbuffer::layer_count is expressed in units of whole + * logical layers regardless of the multisample layout. + */ + const unsigned mt_layer_unit = + (irb->mt->msaa_layout == INTEL_MSAA_LAYOUT_UMS || + irb->mt->msaa_layout == INTEL_MSAA_LAYOUT_CMS) ? + MAX2(irb->mt->num_samples, 1) : 1; + + const struct isl_view view = { + .format = format, + .base_level = irb->mt_level - irb->mt->first_level, + .levels = 1, + .base_array_layer = irb->mt_layer / mt_layer_unit, + .array_len = irb->layer_count, + .swizzle = ISL_SWIZZLE_IDENTITY, + .usage = ISL_SURF_USAGE_TEXTURE_BIT, + }; + + const int flags = brw->draw_aux_buffer_disabled[i] ? + INTEL_AUX_BUFFER_DISABLED : 0; + brw_emit_surface_state(brw, irb->mt, flags, target, view, + tex_mocs[brw->gen], + surf_offset, surf_index, + I915_GEM_DOMAIN_SAMPLER, 0); + + } else { + brw->vtbl.emit_null_surface_state( + brw, _mesa_geometric_width(fb), _mesa_geometric_height(fb), + _mesa_geometric_samples(fb), surf_offset); + } + } + + brw->ctx.NewDriverState |= BRW_NEW_SURFACES; + } +} + +const struct brw_tracked_state brw_renderbuffer_read_surfaces = { + .dirty = { + .mesa = _NEW_BUFFERS, + .brw = BRW_NEW_BATCH | + BRW_NEW_FRAGMENT_PROGRAM | + BRW_NEW_FS_PROG_DATA, + }, + .emit = update_renderbuffer_read_surfaces, +}; static void update_stage_texture_surfaces(struct brw_context *brw, @@ -998,7 +1259,7 @@ update_stage_texture_surfaces(struct brw_context *brw, else surf_offset += stage_state->prog_data->binding_table.plane_start[plane]; - unsigned num_samplers = _mesa_fls(prog->SamplersUsed); + unsigned num_samplers = util_last_bit(prog->SamplersUsed); for (unsigned s = 0; s < num_samplers; s++) { surf_offset[s] = 0; @@ -1044,15 +1305,15 @@ brw_update_texture_surfaces(struct brw_context *brw) * allows the surface format to be overriden for only the * gather4 messages. */ if (brw->gen < 8) { - if (vs && vs->UsesGather) + if (vs && vs->nir->info.uses_texture_gather) update_stage_texture_surfaces(brw, vs, &brw->vs.base, true, 0); - if (tcs && tcs->UsesGather) + if (tcs && tcs->nir->info.uses_texture_gather) update_stage_texture_surfaces(brw, tcs, &brw->tcs.base, true, 0); - if (tes && tes->UsesGather) + if (tes && tes->nir->info.uses_texture_gather) update_stage_texture_surfaces(brw, tes, &brw->tes.base, true, 0); - if (gs && gs->UsesGather) + if (gs && gs->nir->info.uses_texture_gather) update_stage_texture_surfaces(brw, gs, &brw->gs.base, true, 0); - if (fs && fs->UsesGather) + if (fs && fs->nir->info.uses_texture_gather) update_stage_texture_surfaces(brw, fs, &brw->wm.base, true, 0); } @@ -1097,7 +1358,7 @@ brw_update_cs_texture_surfaces(struct brw_context *brw) * gather4 messages. */ if (brw->gen < 8) { - if (cs && cs->UsesGather) + if (cs && cs->nir->info.uses_texture_gather) update_stage_texture_surfaces(brw, cs, &brw->cs.base, true, 0); } @@ -1116,22 +1377,21 @@ const struct brw_tracked_state brw_cs_texture_surfaces = { void -brw_upload_ubo_surfaces(struct brw_context *brw, - struct gl_linked_shader *shader, +brw_upload_ubo_surfaces(struct brw_context *brw, struct gl_program *prog, struct brw_stage_state *stage_state, struct brw_stage_prog_data *prog_data) { struct gl_context *ctx = &brw->ctx; - if (!shader) + if (!prog) return; uint32_t *ubo_surf_offsets = &stage_state->surf_offset[prog_data->binding_table.ubo_start]; - for (int i = 0; i < shader->NumUniformBlocks; i++) { + for (int i = 0; i < prog->info.num_ubos; i++) { struct gl_uniform_buffer_binding *binding = - &ctx->UniformBufferBindings[shader->UniformBlocks[i]->Binding]; + &ctx->UniformBufferBindings[prog->sh.UniformBlocks[i]->Binding]; if (binding->BufferObject == ctx->Shared->NullBufferObj) { brw->vtbl.emit_null_surface_state(brw, 1, 1, 1, &ubo_surf_offsets[i]); @@ -1141,7 +1401,7 @@ brw_upload_ubo_surfaces(struct brw_context *brw, GLsizeiptr size = binding->BufferObject->Size - binding->Offset; if (!binding->AutomaticSize) size = MIN2(size, binding->Size); - drm_intel_bo *bo = + struct brw_bo *bo = intel_bufferobj_buffer(brw, intel_bo, binding->Offset, size); @@ -1154,9 +1414,9 @@ brw_upload_ubo_surfaces(struct brw_context *brw, uint32_t *ssbo_surf_offsets = &stage_state->surf_offset[prog_data->binding_table.ssbo_start]; - for (int i = 0; i < shader->NumShaderStorageBlocks; i++) { + for (int i = 0; i < prog->info.num_ssbos; i++) { struct gl_shader_storage_buffer_binding *binding = - &ctx->ShaderStorageBufferBindings[shader->ShaderStorageBlocks[i]->Binding]; + &ctx->ShaderStorageBufferBindings[prog->sh.ShaderStorageBlocks[i]->Binding]; if (binding->BufferObject == ctx->Shared->NullBufferObj) { brw->vtbl.emit_null_surface_state(brw, 1, 1, 1, &ssbo_surf_offsets[i]); @@ -1166,7 +1426,7 @@ brw_upload_ubo_surfaces(struct brw_context *brw, GLsizeiptr size = binding->BufferObject->Size - binding->Offset; if (!binding->AutomaticSize) size = MIN2(size, binding->Size); - drm_intel_bo *bo = + struct brw_bo *bo = intel_bufferobj_buffer(brw, intel_bo, binding->Offset, size); @@ -1176,7 +1436,7 @@ brw_upload_ubo_surfaces(struct brw_context *brw, } } - if (shader->NumUniformBlocks || shader->NumShaderStorageBlocks) + if (prog->info.num_ubos || prog->info.num_ssbos) brw->ctx.NewDriverState |= BRW_NEW_SURFACES; } @@ -1185,14 +1445,10 @@ brw_upload_wm_ubo_surfaces(struct brw_context *brw) { struct gl_context *ctx = &brw->ctx; /* _NEW_PROGRAM */ - struct gl_shader_program *prog = ctx->_Shader->_CurrentFragmentProgram; - - if (!prog) - return; + struct gl_program *prog = ctx->FragmentProgram._Current; /* BRW_NEW_FS_PROG_DATA */ - brw_upload_ubo_surfaces(brw, prog->_LinkedShaders[MESA_SHADER_FRAGMENT], - &brw->wm.base, &brw->wm.prog_data->base); + brw_upload_ubo_surfaces(brw, prog, &brw->wm.base, brw->wm.base.prog_data); } const struct brw_tracked_state brw_wm_ubo_surfaces = { @@ -1211,15 +1467,11 @@ brw_upload_cs_ubo_surfaces(struct brw_context *brw) { struct gl_context *ctx = &brw->ctx; /* _NEW_PROGRAM */ - struct gl_shader_program *prog = + struct gl_program *prog = ctx->_Shader->CurrentProgram[MESA_SHADER_COMPUTE]; - if (!prog) - return; - /* BRW_NEW_CS_PROG_DATA */ - brw_upload_ubo_surfaces(brw, prog->_LinkedShaders[MESA_SHADER_COMPUTE], - &brw->cs.base, &brw->cs.prog_data->base); + brw_upload_ubo_surfaces(brw, prog, &brw->cs.base, brw->cs.base.prog_data); } const struct brw_tracked_state brw_cs_ubo_surfaces = { @@ -1235,7 +1487,7 @@ const struct brw_tracked_state brw_cs_ubo_surfaces = { void brw_upload_abo_surfaces(struct brw_context *brw, - struct gl_linked_shader *shader, + const struct gl_program *prog, struct brw_stage_state *stage_state, struct brw_stage_prog_data *prog_data) { @@ -1243,17 +1495,17 @@ brw_upload_abo_surfaces(struct brw_context *brw, uint32_t *surf_offsets = &stage_state->surf_offset[prog_data->binding_table.abo_start]; - if (shader && shader->NumAtomicBuffers) { - for (unsigned i = 0; i < shader->NumAtomicBuffers; i++) { + if (prog->info.num_abos) { + for (unsigned i = 0; i < prog->info.num_abos; i++) { struct gl_atomic_buffer_binding *binding = - &ctx->AtomicBufferBindings[shader->AtomicBuffers[i]->Binding]; + &ctx->AtomicBufferBindings[prog->sh.AtomicBuffers[i]->Binding]; struct intel_buffer_object *intel_bo = intel_buffer_object(binding->BufferObject); - drm_intel_bo *bo = intel_bufferobj_buffer( + struct brw_bo *bo = intel_bufferobj_buffer( brw, intel_bo, binding->Offset, intel_bo->Base.Size - binding->Offset); brw_emit_buffer_surface_state(brw, &surf_offsets[i], bo, - binding->Offset, BRW_SURFACEFORMAT_RAW, + binding->Offset, ISL_FORMAT_RAW, bo->size - binding->Offset, 1, true); } @@ -1264,14 +1516,12 @@ brw_upload_abo_surfaces(struct brw_context *brw, static void brw_upload_wm_abo_surfaces(struct brw_context *brw) { - struct gl_context *ctx = &brw->ctx; /* _NEW_PROGRAM */ - struct gl_shader_program *prog = ctx->_Shader->_CurrentFragmentProgram; + const struct gl_program *wm = brw->fragment_program; - if (prog) { + if (wm) { /* BRW_NEW_FS_PROG_DATA */ - brw_upload_abo_surfaces(brw, prog->_LinkedShaders[MESA_SHADER_FRAGMENT], - &brw->wm.base, &brw->wm.prog_data->base); + brw_upload_abo_surfaces(brw, wm, &brw->wm.base, brw->wm.base.prog_data); } } @@ -1289,15 +1539,12 @@ const struct brw_tracked_state brw_wm_abo_surfaces = { static void brw_upload_cs_abo_surfaces(struct brw_context *brw) { - struct gl_context *ctx = &brw->ctx; /* _NEW_PROGRAM */ - struct gl_shader_program *prog = - ctx->_Shader->CurrentProgram[MESA_SHADER_COMPUTE]; + const struct gl_program *cp = brw->compute_program; - if (prog) { + if (cp) { /* BRW_NEW_CS_PROG_DATA */ - brw_upload_abo_surfaces(brw, prog->_LinkedShaders[MESA_SHADER_COMPUTE], - &brw->cs.base, &brw->cs.prog_data->base); + brw_upload_abo_surfaces(brw, cp, &brw->cs.base, brw->cs.base.prog_data); } } @@ -1315,15 +1562,13 @@ const struct brw_tracked_state brw_cs_abo_surfaces = { static void brw_upload_cs_image_surfaces(struct brw_context *brw) { - struct gl_context *ctx = &brw->ctx; /* _NEW_PROGRAM */ - struct gl_shader_program *prog = - ctx->_Shader->CurrentProgram[MESA_SHADER_COMPUTE]; + const struct gl_program *cp = brw->compute_program; - if (prog) { + if (cp) { /* BRW_NEW_CS_PROG_DATA, BRW_NEW_IMAGE_UNITS, _NEW_TEXTURE */ - brw_upload_image_surfaces(brw, prog->_LinkedShaders[MESA_SHADER_COMPUTE], - &brw->cs.base, &brw->cs.prog_data->base); + brw_upload_image_surfaces(brw, cp, &brw->cs.base, + brw->cs.base.prog_data); } } @@ -1341,8 +1586,8 @@ const struct brw_tracked_state brw_cs_image_surfaces = { static uint32_t get_image_format(struct brw_context *brw, mesa_format format, GLenum access) { - const struct brw_device_info *devinfo = brw->intelScreen->devinfo; - uint32_t hw_format = brw_format_for_mesa_format(format); + const struct gen_device_info *devinfo = &brw->screen->devinfo; + uint32_t hw_format = brw_isl_format_for_mesa_format(format); if (access == GL_WRITE_ONLY) { return hw_format; } else if (isl_has_matching_typed_storage_image_format(devinfo, hw_format)) { @@ -1355,7 +1600,7 @@ get_image_format(struct brw_context *brw, mesa_format format, GLenum access) /* The hardware doesn't actually support a typed format that we can use * so we have to fall back to untyped read/write messages. */ - return BRW_SURFACEFORMAT_RAW; + return ISL_FORMAT_RAW; } } @@ -1382,10 +1627,10 @@ update_buffer_image_param(struct brw_context *brw, struct brw_image_param *param) { struct gl_buffer_object *obj = u->TexObj->BufferObject; - + const uint32_t size = MIN2((uint32_t)u->TexObj->BufferSize, obj->Size); update_default_image_param(brw, u, surface_idx, param); - param->size[0] = obj->Size / _mesa_get_format_bytes(u->_ActualFormat); + param->size[0] = size / _mesa_get_format_bytes(u->_ActualFormat); param->stride[0] = _mesa_get_format_bytes(u->_ActualFormat); } @@ -1471,7 +1716,7 @@ update_image_surface(struct brw_context *brw, if (obj->Target == GL_TEXTURE_BUFFER) { struct intel_buffer_object *intel_obj = intel_buffer_object(obj->BufferObject); - const unsigned texel_size = (format == BRW_SURFACEFORMAT_RAW ? 1 : + const unsigned texel_size = (format == ISL_FORMAT_RAW ? 1 : _mesa_get_format_bytes(u->_ActualFormat)); brw_emit_buffer_surface_state( @@ -1485,7 +1730,7 @@ update_image_surface(struct brw_context *brw, struct intel_texture_object *intel_obj = intel_texture_object(obj); struct intel_mipmap_tree *mt = intel_obj->mt; - if (format == BRW_SURFACEFORMAT_RAW) { + if (format == ISL_FORMAT_RAW) { brw_emit_buffer_surface_state( brw, surf_offset, mt->bo, mt->offset, format, mt->bo->size - mt->offset, 1 /* pitch */, @@ -1502,19 +1747,17 @@ update_image_surface(struct brw_context *brw, .levels = 1, .base_array_layer = obj->MinLayer + u->_Layer, .array_len = num_layers, - .channel_select = { - ISL_CHANNEL_SELECT_RED, - ISL_CHANNEL_SELECT_GREEN, - ISL_CHANNEL_SELECT_BLUE, - ISL_CHANNEL_SELECT_ALPHA, - }, + .swizzle = ISL_SWIZZLE_IDENTITY, .usage = ISL_SURF_USAGE_STORAGE_BIT, }; const int surf_index = surf_offset - &brw->wm.base.surf_offset[0]; - - brw_emit_surface_state(brw, mt, &view, - surface_state_infos[brw->gen].rb_mocs, false, + const bool unresolved = intel_miptree_has_color_unresolved( + mt, view.base_level, view.levels, + view.base_array_layer, view.array_len); + const int flags = unresolved ? 0 : INTEL_AUX_BUFFER_DISABLED; + brw_emit_surface_state(brw, mt, flags, mt->target, view, + tex_mocs[brw->gen], surf_offset, surf_index, I915_GEM_DOMAIN_SAMPLER, access == GL_READ_ONLY ? 0 : @@ -1532,18 +1775,19 @@ update_image_surface(struct brw_context *brw, void brw_upload_image_surfaces(struct brw_context *brw, - struct gl_linked_shader *shader, + const struct gl_program *prog, struct brw_stage_state *stage_state, struct brw_stage_prog_data *prog_data) { + assert(prog); struct gl_context *ctx = &brw->ctx; - if (shader && shader->NumImages) { - for (unsigned i = 0; i < shader->NumImages; i++) { - struct gl_image_unit *u = &ctx->ImageUnits[shader->ImageUnits[i]]; + if (prog->info.num_images) { + for (unsigned i = 0; i < prog->info.num_images; i++) { + struct gl_image_unit *u = &ctx->ImageUnits[prog->sh.ImageUnits[i]]; const unsigned surf_idx = prog_data->binding_table.image_start + i; - update_image_surface(brw, u, shader->ImageAccess[i], + update_image_surface(brw, u, prog->sh.ImageAccess[i], surf_idx, &stage_state->surf_offset[surf_idx], &prog_data->image_param[i]); @@ -1561,14 +1805,13 @@ brw_upload_image_surfaces(struct brw_context *brw, static void brw_upload_wm_image_surfaces(struct brw_context *brw) { - struct gl_context *ctx = &brw->ctx; /* BRW_NEW_FRAGMENT_PROGRAM */ - struct gl_shader_program *prog = ctx->_Shader->_CurrentFragmentProgram; + const struct gl_program *wm = brw->fragment_program; - if (prog) { + if (wm) { /* BRW_NEW_FS_PROG_DATA, BRW_NEW_IMAGE_UNITS, _NEW_TEXTURE */ - brw_upload_image_surfaces(brw, prog->_LinkedShaders[MESA_SHADER_FRAGMENT], - &brw->wm.base, &brw->wm.prog_data->base); + brw_upload_image_surfaces(brw, wm, &brw->wm.base, + brw->wm.base.prog_data); } } @@ -1603,14 +1846,17 @@ brw_upload_cs_work_groups_surface(struct brw_context *brw) { struct gl_context *ctx = &brw->ctx; /* _NEW_PROGRAM */ - struct gl_shader_program *prog = + struct gl_program *prog = ctx->_Shader->CurrentProgram[MESA_SHADER_COMPUTE]; + /* BRW_NEW_CS_PROG_DATA */ + const struct brw_cs_prog_data *cs_prog_data = + brw_cs_prog_data(brw->cs.base.prog_data); - if (prog && brw->cs.prog_data->uses_num_work_groups) { + if (prog && cs_prog_data->uses_num_work_groups) { const unsigned surf_idx = - brw->cs.prog_data->binding_table.work_groups_start; + cs_prog_data->binding_table.work_groups_start; uint32_t *surf_offset = &brw->cs.base.surf_offset[surf_idx]; - drm_intel_bo *bo; + struct brw_bo *bo; uint32_t bo_offset; if (brw->compute.num_work_groups_bo == NULL) { @@ -1628,7 +1874,7 @@ brw_upload_cs_work_groups_surface(struct brw_context *brw) brw_emit_buffer_surface_state(brw, surf_offset, bo, bo_offset, - BRW_SURFACEFORMAT_RAW, + ISL_FORMAT_RAW, 3 * sizeof(GLuint), 1, true); brw->ctx.NewDriverState |= BRW_NEW_SURFACES; } @@ -1637,6 +1883,7 @@ brw_upload_cs_work_groups_surface(struct brw_context *brw) const struct brw_tracked_state brw_cs_work_groups_surface = { .dirty = { .brw = BRW_NEW_BLORP | + BRW_NEW_CS_PROG_DATA | BRW_NEW_CS_WORK_GROUPS }, .emit = brw_upload_cs_work_groups_surface,