diff options
Diffstat (limited to 'src/gallium/drivers/ilo')
| -rw-r--r-- | src/gallium/drivers/ilo/Makefile.sources | 2 | ||||
| -rw-r--r-- | src/gallium/drivers/ilo/ilo_builder.c | 566 | ||||
| -rw-r--r-- | src/gallium/drivers/ilo/ilo_builder.h | 490 | ||||
| -rw-r--r-- | src/gallium/drivers/ilo/ilo_builder_decode.c | 583 |
4 files changed, 1641 insertions, 0 deletions
diff --git a/src/gallium/drivers/ilo/Makefile.sources b/src/gallium/drivers/ilo/Makefile.sources index f9be2450164..7f0cf75938d 100644 --- a/src/gallium/drivers/ilo/Makefile.sources +++ b/src/gallium/drivers/ilo/Makefile.sources @@ -15,6 +15,8 @@ C_SOURCES := \ ilo_blitter_blt.c \ ilo_blitter_pipe.c \ ilo_blitter_rectlist.c \ + ilo_builder.c \ + ilo_builder_decode.c \ ilo_common.h \ ilo_context.c \ ilo_context.h \ diff --git a/src/gallium/drivers/ilo/ilo_builder.c b/src/gallium/drivers/ilo/ilo_builder.c new file mode 100644 index 00000000000..229354f6cd6 --- /dev/null +++ b/src/gallium/drivers/ilo/ilo_builder.c @@ -0,0 +1,566 @@ +/* + * Mesa 3-D graphics library + * + * Copyright (C) 2014 LunarG, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Authors: + * Chia-I Wu <[email protected]> + */ + +#include "genhw/genhw.h" +#include "ilo_builder.h" + +enum ilo_builder_writer_flags { + /* + * When this bit is set, ilo_builder_begin() will not realllocate. New + * data will be appended instead. + */ + WRITER_FLAG_APPEND = 1 << 0, + + /* + * When this bit is set, the writer grows when full. When not, callers + * must make sure the writer never needs to grow. + */ + WRITER_FLAG_GROW = 1 << 1, + + /* + * The writer will be mapped directly. + */ + WRITER_FLAG_MAP = 1 << 2, +}; + +/** + * Set the initial size and flags of a writer. + */ +static void +ilo_builder_writer_init(struct ilo_builder *builder, + enum ilo_builder_writer_type which) +{ + struct ilo_builder_writer *writer = &builder->writers[which]; + + switch (which) { + case ILO_BUILDER_WRITER_BATCH: + writer->size = sizeof(uint32_t) * 8192; + break; + case ILO_BUILDER_WRITER_INSTRUCTION: + /* + * The EUs pretch some instructions. But since the kernel invalidates + * the instruction cache between batch buffers, we can set + * WRITER_FLAG_APPEND without worrying the EUs would see invalid + * instructions prefetched. + */ + writer->flags = WRITER_FLAG_APPEND | WRITER_FLAG_GROW; + writer->size = 8192; + break; + default: + assert(!"unknown builder writer"); + return; + break; + } + + if (builder->dev->has_llc) + writer->flags |= WRITER_FLAG_MAP; +} + +/** + * Free all resources used by a writer. Note that the initial size is not + * reset. + */ +static void +ilo_builder_writer_reset(struct ilo_builder *builder, + enum ilo_builder_writer_type which) +{ + struct ilo_builder_writer *writer = &builder->writers[which]; + + if (writer->ptr) { + if (writer->flags & WRITER_FLAG_MAP) + intel_bo_unmap(writer->bo); + else + FREE(writer->ptr); + + writer->ptr = NULL; + } + + if (writer->bo) { + intel_bo_unreference(writer->bo); + writer->bo = NULL; + } + + writer->used = 0; + writer->stolen = 0; + + if (writer->items) { + FREE(writer->items); + writer->item_alloc = 0; + writer->item_used = 0; + } +} + +/** + * Discard everything written so far. + */ +void +ilo_builder_writer_discard(struct ilo_builder *builder, + enum ilo_builder_writer_type which) +{ + struct ilo_builder_writer *writer = &builder->writers[which]; + + intel_bo_truncate_relocs(writer->bo, 0); + writer->used = 0; + writer->stolen = 0; + writer->item_used = 0; +} + +static struct intel_bo * +alloc_writer_bo(struct intel_winsys *winsys, + enum ilo_builder_writer_type which, + unsigned size) +{ + static const char *writer_names[ILO_BUILDER_WRITER_COUNT] = { + [ILO_BUILDER_WRITER_BATCH] = "batch", + [ILO_BUILDER_WRITER_INSTRUCTION] = "instruction", + }; + + return intel_winsys_alloc_buffer(winsys, writer_names[which], size, true); +} + +static void * +map_writer_bo(struct intel_bo *bo, unsigned flags) +{ + assert(flags & WRITER_FLAG_MAP); + + if (flags & WRITER_FLAG_APPEND) + return intel_bo_map_gtt_async(bo); + else + return intel_bo_map(bo, true); +} + +/** + * Allocate and map the buffer for writing. + */ +static bool +ilo_builder_writer_alloc_and_map(struct ilo_builder *builder, + enum ilo_builder_writer_type which) +{ + struct ilo_builder_writer *writer = &builder->writers[which]; + + /* allocate a new bo when not appending */ + if (!(writer->flags & WRITER_FLAG_APPEND) || !writer->bo) { + struct intel_bo *bo; + + bo = alloc_writer_bo(builder->winsys, which, writer->size); + if (bo) { + if (writer->bo) + intel_bo_unreference(writer->bo); + writer->bo = bo; + } else if (writer->bo) { + /* reuse the old bo */ + ilo_builder_writer_discard(builder, which); + } else { + return false; + } + + writer->used = 0; + writer->stolen = 0; + writer->item_used = 0; + } + + /* map the bo or allocate the staging system memory */ + if (writer->flags & WRITER_FLAG_MAP) + writer->ptr = map_writer_bo(writer->bo, writer->flags); + else if (!writer->ptr) + writer->ptr = MALLOC(writer->size); + + return (writer->ptr != NULL); +} + +/** + * Unmap the buffer for submission. + */ +static bool +ilo_builder_writer_unmap(struct ilo_builder *builder, + enum ilo_builder_writer_type which) +{ + struct ilo_builder_writer *writer = &builder->writers[which]; + unsigned offset; + int err = 0; + + if (writer->flags & WRITER_FLAG_MAP) { + intel_bo_unmap(writer->bo); + writer->ptr = NULL; + return true; + } + + offset = builder->begin_used[which]; + if (writer->used > offset) { + err = intel_bo_pwrite(writer->bo, offset, writer->used - offset, + (char *) writer->ptr + offset); + } + + if (writer->stolen && !err) { + const unsigned offset = writer->size - writer->stolen; + err = intel_bo_pwrite(writer->bo, offset, writer->stolen, + (const char *) writer->ptr + offset); + } + + /* keep writer->ptr */ + + return !err; +} + +/** + * Grow a mapped writer to at least \p new_size. + */ +bool +ilo_builder_writer_grow(struct ilo_builder *builder, + enum ilo_builder_writer_type which, + unsigned new_size, bool preserve) +{ + struct ilo_builder_writer *writer = &builder->writers[which]; + struct intel_bo *new_bo; + void *new_ptr; + + if (!(writer->flags & WRITER_FLAG_GROW)) + return false; + + /* stolen data may already be referenced and cannot be moved */ + if (writer->stolen) + return false; + + if (new_size < writer->size << 1) + new_size = writer->size << 1; + /* STATE_BASE_ADDRESS requires page-aligned buffers */ + new_size = align(new_size, 4096); + + new_bo = alloc_writer_bo(builder->winsys, which, new_size); + if (!new_bo) + return false; + + /* map and copy the data over */ + if (writer->flags & WRITER_FLAG_MAP) { + new_ptr = map_writer_bo(new_bo, writer->flags); + + /* + * When WRITER_FLAG_APPEND and WRITER_FLAG_GROW are both set, we may end + * up copying between two GTT-mapped BOs. That is slow. The issue + * could be solved by adding intel_bo_map_async(), or callers may choose + * to manually grow the writer without preserving the data. + */ + if (new_ptr && preserve) + memcpy(new_ptr, writer->ptr, writer->used); + } else if (preserve) { + new_ptr = REALLOC(writer->ptr, writer->size, new_size); + } else { + new_ptr = MALLOC(new_size); + } + + if (!new_ptr) { + intel_bo_unreference(new_bo); + return false; + } + + if (writer->flags & WRITER_FLAG_MAP) + intel_bo_unmap(writer->bo); + else if (!preserve) + FREE(writer->ptr); + + intel_bo_unreference(writer->bo); + + writer->size = new_size; + writer->bo = new_bo; + writer->ptr = new_ptr; + + return true; +} + +/** + * Record an item for later decoding. + */ +bool +ilo_builder_writer_record(struct ilo_builder *builder, + enum ilo_builder_writer_type which, + enum ilo_builder_item_type type, + unsigned offset, unsigned size) +{ + struct ilo_builder_writer *writer = &builder->writers[which]; + struct ilo_builder_item *item; + + if (writer->item_used == writer->item_alloc) { + const unsigned new_alloc = (writer->item_alloc) ? + writer->item_alloc << 1 : 256; + struct ilo_builder_item *items; + + items = REALLOC(writer->items, + sizeof(writer->items[0]) * writer->item_alloc, + sizeof(writer->items[0]) * new_alloc); + if (!items) + return false; + + writer->items = items; + writer->item_alloc = new_alloc; + } + + item = &writer->items[writer->item_used++]; + item->type = type; + item->offset = offset; + item->size = size; + + return true; +} + +/** + * Initialize the builder. + */ +void +ilo_builder_init(struct ilo_builder *builder, + const struct ilo_dev_info *dev, + struct intel_winsys *winsys) +{ + int i; + + memset(builder, 0, sizeof(*builder)); + + builder->dev = dev; + builder->winsys = winsys; + + for (i = 0; i < ILO_BUILDER_WRITER_COUNT; i++) + ilo_builder_writer_init(builder, i); +} + +/** + * Reset the builder and free all resources used. After resetting, the + * builder behaves as if it is newly initialized, except for potentially + * larger initial bo sizes. + */ +void +ilo_builder_reset(struct ilo_builder *builder) +{ + int i; + + for (i = 0; i < ILO_BUILDER_WRITER_COUNT; i++) + ilo_builder_writer_reset(builder, i); +} + +/** + * Allocate and map the BOs. It may re-allocate or reuse existing BOs if + * there is any. + * + * Most builder functions can only be called after ilo_builder_begin() and + * before ilo_builder_end(). + */ +bool +ilo_builder_begin(struct ilo_builder *builder) +{ + int i; + + for (i = 0; i < ILO_BUILDER_WRITER_COUNT; i++) { + if (!ilo_builder_writer_alloc_and_map(builder, i)) { + ilo_builder_reset(builder); + return false; + } + + builder->begin_used[i] = builder->writers[i].used; + } + + builder->unrecoverable_error = false; + builder->sba_instruction_pos = 0; + + return true; +} + +static void +ilo_builder_batch_patch_sba(struct ilo_builder *builder) +{ + const struct ilo_builder_writer *inst = + &builder->writers[ILO_BUILDER_WRITER_INSTRUCTION]; + + if (!builder->sba_instruction_pos) + return; + + ilo_builder_batch_reloc(builder, builder->sba_instruction_pos, + inst->bo, 1, 0); +} + +/** + * Unmap BOs and make sure the written data landed the BOs. The batch buffer + * ready for submission is returned. + */ +struct intel_bo * +ilo_builder_end(struct ilo_builder *builder, unsigned *used) +{ + struct ilo_builder_writer *bat; + int i; + + ilo_builder_batch_patch_sba(builder); + + assert(ilo_builder_validate(builder, 0, NULL)); + + for (i = 0; i < ILO_BUILDER_WRITER_COUNT; i++) { + if (!ilo_builder_writer_unmap(builder, i)) + builder->unrecoverable_error = true; + } + + if (builder->unrecoverable_error) + return NULL; + + bat = &builder->writers[ILO_BUILDER_WRITER_BATCH]; + + *used = bat->used; + + return bat->bo; +} + +/** + * Return true if the builder is in a valid state, after accounting for the + * additional BOs specified. The additional BOs can be listed to avoid + * snapshotting and restoring when they are known ahead of time. + * + * The number of additional BOs should not be more than a few. Like two, for + * copying between two BOs. + * + * Callers must make sure the builder is in a valid state when + * ilo_builder_end() is called. + */ +bool +ilo_builder_validate(struct ilo_builder *builder, + unsigned bo_count, struct intel_bo **bos) +{ + const unsigned max_bo_count = 2; + struct intel_bo *bos_to_submit[ILO_BUILDER_WRITER_COUNT + max_bo_count]; + int i; + + for (i = 0; i < ILO_BUILDER_WRITER_COUNT; i++) + bos_to_submit[i] = builder->writers[i].bo; + + if (bo_count) { + assert(bo_count <= max_bo_count); + if (bo_count > max_bo_count) + return false; + + memcpy(&bos_to_submit[ILO_BUILDER_WRITER_COUNT], + bos, sizeof(*bos) * bo_count); + i += bo_count; + } + + return intel_winsys_can_submit_bo(builder->winsys, bos_to_submit, i); +} + +/** + * Take a snapshot of the writer state. + */ +void +ilo_builder_batch_snapshot(const struct ilo_builder *builder, + struct ilo_builder_snapshot *snapshot) +{ + const enum ilo_builder_writer_type which = ILO_BUILDER_WRITER_BATCH; + const struct ilo_builder_writer *writer = &builder->writers[which]; + + snapshot->reloc_count = intel_bo_get_reloc_count(writer->bo); + snapshot->used = writer->used; + snapshot->stolen = writer->stolen; + snapshot->item_used = writer->item_used; +} + +/** + * Restore the writer state to when the snapshot was taken, except that it + * does not (unnecessarily) shrink BOs or the item array. + */ +void +ilo_builder_batch_restore(struct ilo_builder *builder, + const struct ilo_builder_snapshot *snapshot) +{ + const enum ilo_builder_writer_type which = ILO_BUILDER_WRITER_BATCH; + struct ilo_builder_writer *writer = &builder->writers[which]; + + intel_bo_truncate_relocs(writer->bo, snapshot->reloc_count); + writer->used = snapshot->used; + writer->stolen = snapshot->stolen; + writer->item_used = snapshot->item_used; +} + +/** + * Add a STATE_BASE_ADDRESS to the batch buffer. + */ +void +ilo_builder_batch_state_base_address(struct ilo_builder *builder, + bool init_all) +{ + const uint8_t cmd_len = 10; + const struct ilo_builder_writer *bat = + &builder->writers[ILO_BUILDER_WRITER_BATCH]; + unsigned pos; + uint32_t *dw; + + pos = ilo_builder_batch_pointer(builder, cmd_len, &dw); + + dw[0] = GEN6_RENDER_CMD(COMMON, STATE_BASE_ADDRESS) | (cmd_len - 2); + dw[1] = init_all; + + ilo_builder_batch_reloc(builder, pos + 2, bat->bo, 1, 0); + ilo_builder_batch_reloc(builder, pos + 3, bat->bo, 1, 0); + + dw[4] = init_all; + + /* + * Since the instruction writer has WRITER_FLAG_APPEND set, it is tempting + * not to set Instruction Base Address. The problem is that we do not know + * if the bo has been or will be moved by the kernel. We need a relocation + * entry because of that. + * + * And since we also set WRITER_FLAG_GROW, we have to wait until + * ilo_builder_end(), when the final bo is known, to add the relocation + * entry. + */ + ilo_builder_batch_patch_sba(builder); + builder->sba_instruction_pos = pos + 5; + + /* skip range checks */ + dw[6] = init_all; + dw[7] = 0xfffff000 + init_all; + dw[8] = 0xfffff000 + init_all; + dw[9] = init_all; +} + +/** + * Add a MI_BATCH_BUFFER_END to the batch buffer. Pad if necessary. + */ +void +ilo_builder_batch_mi_batch_buffer_end(struct ilo_builder *builder) +{ + const struct ilo_builder_writer *bat = + &builder->writers[ILO_BUILDER_WRITER_BATCH]; + uint32_t *dw; + + /* + * From the Sandy Bridge PRM, volume 1 part 1, page 107: + * + * "The batch buffer must be QWord aligned and a multiple of QWords in + * length." + */ + if (bat->used & 0x7) { + ilo_builder_batch_pointer(builder, 1, &dw); + dw[0] = GEN6_MI_CMD(MI_BATCH_BUFFER_END); + } else { + ilo_builder_batch_pointer(builder, 2, &dw); + dw[0] = GEN6_MI_CMD(MI_BATCH_BUFFER_END); + dw[1] = GEN6_MI_CMD(MI_NOOP); + } +} diff --git a/src/gallium/drivers/ilo/ilo_builder.h b/src/gallium/drivers/ilo/ilo_builder.h new file mode 100644 index 00000000000..1c822183f12 --- /dev/null +++ b/src/gallium/drivers/ilo/ilo_builder.h @@ -0,0 +1,490 @@ +/* + * Mesa 3-D graphics library + * + * Copyright (C) 2014 LunarG, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Authors: + * Chia-I Wu <[email protected]> + */ + +#ifndef ILO_BUILDER_H +#define ILO_BUILDER_H + +#include "intel_winsys.h" +#include "ilo_common.h" + +enum ilo_builder_writer_type { + ILO_BUILDER_WRITER_BATCH, + ILO_BUILDER_WRITER_INSTRUCTION, + + ILO_BUILDER_WRITER_COUNT, +}; + +enum ilo_builder_item_type { + /* for state buffer */ + ILO_BUILDER_ITEM_BLOB, + ILO_BUILDER_ITEM_CLIP_VIEWPORT, + ILO_BUILDER_ITEM_SF_VIEWPORT, + ILO_BUILDER_ITEM_SCISSOR_RECT, + ILO_BUILDER_ITEM_CC_VIEWPORT, + ILO_BUILDER_ITEM_COLOR_CALC, + ILO_BUILDER_ITEM_DEPTH_STENCIL, + ILO_BUILDER_ITEM_BLEND, + ILO_BUILDER_ITEM_SAMPLER, + + /* for surface buffer */ + ILO_BUILDER_ITEM_SURFACE, + ILO_BUILDER_ITEM_BINDING_TABLE, + + /* for instruction buffer */ + ILO_BUILDER_ITEM_KERNEL, + + ILO_BUILDER_ITEM_COUNT, +}; + +struct ilo_builder_item { + enum ilo_builder_item_type type; + unsigned offset; + unsigned size; +}; + +struct ilo_builder_writer { + /* internal flags */ + unsigned flags; + + unsigned size; + struct intel_bo *bo; + void *ptr; + + /* data written to the bottom */ + unsigned used; + /* data written to the top */ + unsigned stolen; + + /* for decoding */ + struct ilo_builder_item *items; + unsigned item_alloc; + unsigned item_used; +}; + +/** + * A snapshot of the writer state. + */ +struct ilo_builder_snapshot { + unsigned reloc_count; + + unsigned used; + unsigned stolen; + unsigned item_used; +}; + +struct ilo_builder { + const struct ilo_dev_info *dev; + struct intel_winsys *winsys; + + struct ilo_builder_writer writers[ILO_BUILDER_WRITER_COUNT]; + bool unrecoverable_error; + + /* for writers that have their data appended */ + unsigned begin_used[ILO_BUILDER_WRITER_COUNT]; + + /* for STATE_BASE_ADDRESS */ + unsigned sba_instruction_pos; +}; + +void +ilo_builder_init(struct ilo_builder *builder, + const struct ilo_dev_info *dev, + struct intel_winsys *winsys); + +void +ilo_builder_reset(struct ilo_builder *builder); + +void +ilo_builder_decode(struct ilo_builder *builder); + +bool +ilo_builder_begin(struct ilo_builder *builder); + +struct intel_bo * +ilo_builder_end(struct ilo_builder *builder, unsigned *used); + +bool +ilo_builder_validate(struct ilo_builder *builder, + unsigned bo_count, struct intel_bo **bos); + +/** + * Return true if the builder has a relocation entry for \p bo. + */ +static inline bool +ilo_builder_has_reloc(const struct ilo_builder *builder, + struct intel_bo *bo) +{ + int i; + + for (i = 0; i < ILO_BUILDER_WRITER_COUNT; i++) { + const struct ilo_builder_writer *writer = &builder->writers[i]; + if (intel_bo_has_reloc(writer->bo, bo)) + return true; + } + + return false; +} + +void +ilo_builder_writer_discard(struct ilo_builder *builder, + enum ilo_builder_writer_type which); + +bool +ilo_builder_writer_grow(struct ilo_builder *builder, + enum ilo_builder_writer_type which, + unsigned new_size, bool preserve); + +bool +ilo_builder_writer_record(struct ilo_builder *builder, + enum ilo_builder_writer_type which, + enum ilo_builder_item_type type, + unsigned offset, unsigned size); + +static inline void +ilo_builder_writer_checked_record(struct ilo_builder *builder, + enum ilo_builder_writer_type which, + enum ilo_builder_item_type item, + unsigned offset, unsigned size) +{ + if (unlikely(ilo_debug & ILO_DEBUG_3D)) { + if (!ilo_builder_writer_record(builder, which, item, offset, size)) { + builder->unrecoverable_error = true; + builder->writers[which].item_used = 0; + } + } +} + +/** + * Return an offset to a region that is aligned to \p alignment and has at + * least \p size bytes. The region is reserved from the bottom. + */ +static inline unsigned +ilo_builder_writer_reserve_bottom(struct ilo_builder *builder, + enum ilo_builder_writer_type which, + unsigned alignment, unsigned size) +{ + struct ilo_builder_writer *writer = &builder->writers[which]; + unsigned offset; + + assert(alignment && util_is_power_of_two(alignment)); + offset = align(writer->used, alignment); + + if (unlikely(offset + size > writer->size - writer->stolen)) { + if (!ilo_builder_writer_grow(builder, which, + offset + size + writer->stolen, true)) { + builder->unrecoverable_error = true; + ilo_builder_writer_discard(builder, which); + offset = 0; + } + + assert(offset + size <= writer->size - writer->stolen); + } + + return offset; +} + +/** + * Similar to ilo_builder_writer_reserve_bottom(), but reserve from the top. + */ +static inline unsigned +ilo_builder_writer_reserve_top(struct ilo_builder *builder, + enum ilo_builder_writer_type which, + unsigned alignment, unsigned size) +{ + struct ilo_builder_writer *writer = &builder->writers[which]; + unsigned offset; + + assert(alignment && util_is_power_of_two(alignment)); + offset = (writer->size - writer->stolen - size) & ~(alignment - 1); + + if (unlikely(offset < writer->used || + size > writer->size - writer->stolen)) { + if (!ilo_builder_writer_grow(builder, which, + align(writer->used, alignment) + size + writer->stolen, true)) { + builder->unrecoverable_error = true; + ilo_builder_writer_discard(builder, which); + } + + offset = (writer->size - writer->stolen - size) & ~(alignment - 1); + assert(offset + size <= writer->size - writer->stolen); + } + + return offset; +} + +/** + * Add a relocation entry to the writer. + */ +static inline void +ilo_builder_writer_reloc(struct ilo_builder *builder, + enum ilo_builder_writer_type which, + unsigned offset, struct intel_bo *bo, + unsigned bo_offset, unsigned reloc_flags) +{ + struct ilo_builder_writer *writer = &builder->writers[which]; + uint64_t presumed_offset; + int err; + + assert(offset + sizeof(uint32_t) <= writer->used || + (offset >= writer->size - writer->stolen && + offset + sizeof(uint32_t) <= writer->size)); + + err = intel_bo_add_reloc(writer->bo, offset, bo, bo_offset, + reloc_flags, &presumed_offset); + if (unlikely(err)) + builder->unrecoverable_error = true; + + /* 32-bit addressing */ + assert(presumed_offset == (uint64_t) ((uint32_t) presumed_offset)); + *((uint32_t *) ((char *) writer->ptr + offset)) = presumed_offset; +} + +/** + * Reserve a region from the state buffer. Both the offset, in bytes, and the + * pointer to the reserved region are returned. + * + * Note that \p alignment is in bytes and \p len is in DWords. + */ +static inline uint32_t +ilo_builder_state_pointer(struct ilo_builder *builder, + enum ilo_builder_item_type item, + unsigned alignment, unsigned len, + uint32_t **dw) +{ + const enum ilo_builder_writer_type which = ILO_BUILDER_WRITER_BATCH; + const unsigned size = len << 2; + const unsigned offset = ilo_builder_writer_reserve_top(builder, + which, alignment, size); + struct ilo_builder_writer *writer = &builder->writers[which]; + + /* all states are at least aligned to 32-bytes */ + assert(alignment % 32 == 0); + + *dw = (uint32_t *) ((char *) writer->ptr + offset); + + writer->stolen = writer->size - offset; + + ilo_builder_writer_checked_record(builder, which, item, offset, size); + + return offset; +} + +/** + * Write a dynamic state to the state buffer. + */ +static inline uint32_t +ilo_builder_state_write(struct ilo_builder *builder, + enum ilo_builder_item_type item, + unsigned alignment, unsigned len, + const uint32_t *dw) +{ + uint32_t offset, *dst; + + offset = ilo_builder_state_pointer(builder, item, alignment, len, &dst); + memcpy(dst, dw, len << 2); + + return offset; +} + +/** + * Write a surface state to the surface buffer. The offset, in bytes, of the + * state is returned. + * + * Note that \p alignment is in bytes and \p len is in DWords. + */ +static inline uint32_t +ilo_builder_surface_write(struct ilo_builder *builder, + enum ilo_builder_item_type item, + unsigned alignment, unsigned len, + const uint32_t *dw) +{ + assert(item == ILO_BUILDER_ITEM_SURFACE || + item == ILO_BUILDER_ITEM_BINDING_TABLE); + + return ilo_builder_state_write(builder, item, alignment, len, dw); +} + +/** + * Add a relocation entry for a DWord of a surface state. + */ +static inline void +ilo_builder_surface_reloc(struct ilo_builder *builder, + uint32_t offset, unsigned dw_index, + struct intel_bo *bo, unsigned bo_offset, + unsigned reloc_flags) +{ + const enum ilo_builder_writer_type which = ILO_BUILDER_WRITER_BATCH; + + ilo_builder_writer_reloc(builder, which, offset + (dw_index << 2), + bo, bo_offset, reloc_flags); +} + +/** + * Write a kernel to the instruction buffer. The offset, in bytes, of the + * kernel is returned. + */ +static inline uint32_t +ilo_builder_instruction_write(struct ilo_builder *builder, + unsigned size, const void *kernel) +{ + const enum ilo_builder_writer_type which = ILO_BUILDER_WRITER_INSTRUCTION; + /* + * From the Sandy Bridge PRM, volume 4 part 2, page 112: + * + * "Due to prefetch of the instruction stream, the EUs may attempt to + * access up to 8 instructions (128 bytes) beyond the end of the + * kernel program - possibly into the next memory page. Although + * these instructions will not be executed, software must account for + * the prefetch in order to avoid invalid page access faults." + */ + const unsigned reserved_size = size + 128; + /* kernels are aligned to 64 bytes */ + const unsigned alignment = 64; + const unsigned offset = ilo_builder_writer_reserve_bottom(builder, + which, alignment, reserved_size); + struct ilo_builder_writer *writer = &builder->writers[which]; + + memcpy((char *) writer->ptr + offset, kernel, size); + + writer->used = offset + size; + + ilo_builder_writer_checked_record(builder, which, + ILO_BUILDER_ITEM_KERNEL, offset, size); + + return offset; +} + +/** + * Reserve a region from the batch buffer. Both the offset, in DWords, and + * the pointer to the reserved region are returned. + * + * Note that \p len is in DWords. + */ +static inline unsigned +ilo_builder_batch_pointer(struct ilo_builder *builder, + unsigned len, uint32_t **dw) +{ + const enum ilo_builder_writer_type which = ILO_BUILDER_WRITER_BATCH; + /* + * We know the batch bo is always aligned. Using 1 here should allow the + * compiler to optimize away aligning. + */ + const unsigned alignment = 1; + const unsigned size = len << 2; + const unsigned offset = ilo_builder_writer_reserve_bottom(builder, + which, alignment, size); + struct ilo_builder_writer *writer = &builder->writers[which]; + + assert(offset % 4 == 0); + *dw = (uint32_t *) ((char *) writer->ptr + offset); + + writer->used = offset + size; + + return offset >> 2; +} + +/** + * Write a command to the batch buffer. + */ +static inline unsigned +ilo_builder_batch_write(struct ilo_builder *builder, + unsigned len, const uint32_t *dw) +{ + unsigned pos; + uint32_t *dst; + + pos = ilo_builder_batch_pointer(builder, len, &dst); + memcpy(dst, dw, len << 2); + + return pos; +} + +/** + * Add a relocation entry for a DWord of a command. + */ +static inline void +ilo_builder_batch_reloc(struct ilo_builder *builder, unsigned pos, + struct intel_bo *bo, unsigned bo_offset, + unsigned reloc_flags) +{ + const enum ilo_builder_writer_type which = ILO_BUILDER_WRITER_BATCH; + + ilo_builder_writer_reloc(builder, which, pos << 2, + bo, bo_offset, reloc_flags); +} + +static inline unsigned +ilo_builder_batch_used(const struct ilo_builder *builder) +{ + const enum ilo_builder_writer_type which = ILO_BUILDER_WRITER_BATCH; + const struct ilo_builder_writer *writer = &builder->writers[which]; + + return writer->used >> 2; +} + +static inline unsigned +ilo_builder_batch_space(const struct ilo_builder *builder) +{ + const enum ilo_builder_writer_type which = ILO_BUILDER_WRITER_BATCH; + const struct ilo_builder_writer *writer = &builder->writers[which]; + + return (writer->size - writer->stolen - writer->used) >> 2; +} + +static inline void +ilo_builder_batch_discard(struct ilo_builder *builder) +{ + ilo_builder_writer_discard(builder, ILO_BUILDER_WRITER_BATCH); +} + +static inline void +ilo_builder_batch_print_stats(const struct ilo_builder *builder) +{ + const enum ilo_builder_writer_type which = ILO_BUILDER_WRITER_BATCH; + const struct ilo_builder_writer *writer = &builder->writers[which]; + + ilo_printf("%d+%d bytes (%d%% full)\n", + writer->used, writer->stolen, + (writer->used + writer->stolen) * 100 / writer->size); +} + +void +ilo_builder_batch_snapshot(const struct ilo_builder *builder, + struct ilo_builder_snapshot *snapshot); + +void +ilo_builder_batch_restore(struct ilo_builder *builder, + const struct ilo_builder_snapshot *snapshot); + +void +ilo_builder_batch_state_base_address(struct ilo_builder *builder, + bool init_all); + +void +ilo_builder_batch_mi_batch_buffer_end(struct ilo_builder *builder); + +#endif /* ILO_BUILDER_H */ diff --git a/src/gallium/drivers/ilo/ilo_builder_decode.c b/src/gallium/drivers/ilo/ilo_builder_decode.c new file mode 100644 index 00000000000..eaa9efaf26a --- /dev/null +++ b/src/gallium/drivers/ilo/ilo_builder_decode.c @@ -0,0 +1,583 @@ +/* + * Mesa 3-D graphics library + * + * Copyright (C) 2014 LunarG, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Authors: + * Chia-I Wu <[email protected]> + */ + +#include <stdio.h> +#include <stdarg.h> +#include "genhw/genhw.h" +#include "shader/toy_compiler.h" +#include "intel_winsys.h" +#include "ilo_builder.h" + +#define READ(dw, field) (((dw) & field ## __MASK) >> field ## __SHIFT) + +static const uint32_t * +writer_pointer(const struct ilo_builder *builder, + enum ilo_builder_writer_type which, + unsigned offset) +{ + const struct ilo_builder_writer *writer = &builder->writers[which]; + return (const uint32_t *) ((const char *) writer->ptr + offset); +} + +static uint32_t _util_printf_format(5, 6) +writer_dw(const struct ilo_builder *builder, + enum ilo_builder_writer_type which, + unsigned offset, unsigned dw_index, + const char *format, ...) +{ + const uint32_t *dw = writer_pointer(builder, which, offset); + va_list ap; + char desc[16]; + int len; + + ilo_printf("0x%08x: 0x%08x: ", + offset + (dw_index << 2), dw[dw_index]); + + va_start(ap, format); + len = vsnprintf(desc, sizeof(desc), format, ap); + va_end(ap); + + if (len >= sizeof(desc)) { + len = sizeof(desc) - 1; + desc[len] = '\0'; + } + + if (desc[len - 1] == '\n') { + desc[len - 1] = '\0'; + ilo_printf("%8s: \n", desc); + } else { + ilo_printf("%8s: ", desc); + } + + return dw[dw_index]; +} + +static void +writer_decode_blob(const struct ilo_builder *builder, + enum ilo_builder_writer_type which, + const struct ilo_builder_item *item) +{ + const unsigned state_size = sizeof(uint32_t) * 4; + const unsigned count = item->size / state_size; + unsigned offset = item->offset; + unsigned i; + + for (i = 0; i < count; i++) { + const uint32_t *dw = writer_pointer(builder, which, offset); + + writer_dw(builder, which, offset, 0, "BLOB%d", i); + /* output a single line for all four DWords */ + ilo_printf("(% f, % f, % f, % f) (0x%08x, 0x%08x, 0x%08x, 0x%08x)\n", + uif(dw[0]), uif(dw[1]), uif(dw[2]), uif(dw[3]), + dw[0], dw[1], dw[2], dw[3]); + + offset += state_size; + } +} + +static void +writer_decode_clip_viewport(const struct ilo_builder *builder, + enum ilo_builder_writer_type which, + const struct ilo_builder_item *item) +{ + const unsigned state_size = sizeof(uint32_t) * 4; + const unsigned count = item->size / state_size; + unsigned offset = item->offset; + unsigned i; + + for (i = 0; i < count; i++) { + uint32_t dw; + + dw = writer_dw(builder, which, offset, 0, "CLIP VP%d", i); + ilo_printf("xmin = %f\n", uif(dw)); + + dw = writer_dw(builder, which, offset, 1, "CLIP VP%d", i); + ilo_printf("xmax = %f\n", uif(dw)); + + dw = writer_dw(builder, which, offset, 2, "CLIP VP%d", i); + ilo_printf("ymin = %f\n", uif(dw)); + + dw = writer_dw(builder, which, offset, 3, "CLIP VP%d", i); + ilo_printf("ymax = %f\n", uif(dw)); + + offset += state_size; + } +} + +static void +writer_decode_sf_clip_viewport_gen7(const struct ilo_builder *builder, + enum ilo_builder_writer_type which, + const struct ilo_builder_item *item) +{ + const unsigned state_size = sizeof(uint32_t) * 16; + const unsigned count = item->size / state_size; + unsigned offset = item->offset; + unsigned i; + + for (i = 0; i < count; i++) { + uint32_t dw; + + dw = writer_dw(builder, which, offset, 0, "SF_CLIP VP%d", i); + ilo_printf("m00 = %f\n", uif(dw)); + + dw = writer_dw(builder, which, offset, 1, "SF_CLIP VP%d", i); + ilo_printf("m11 = %f\n", uif(dw)); + + dw = writer_dw(builder, which, offset, 2, "SF_CLIP VP%d", i); + ilo_printf("m22 = %f\n", uif(dw)); + + dw = writer_dw(builder, which, offset, 3, "SF_CLIP VP%d", i); + ilo_printf("m30 = %f\n", uif(dw)); + + dw = writer_dw(builder, which, offset, 4, "SF_CLIP VP%d", i); + ilo_printf("m31 = %f\n", uif(dw)); + + dw = writer_dw(builder, which, offset, 5, "SF_CLIP VP%d", i); + ilo_printf("m32 = %f\n", uif(dw)); + + dw = writer_dw(builder, which, offset, 8, "SF_CLIP VP%d", i); + ilo_printf("guardband xmin = %f\n", uif(dw)); + + dw = writer_dw(builder, which, offset, 9, "SF_CLIP VP%d", i); + ilo_printf("guardband xmax = %f\n", uif(dw)); + + dw = writer_dw(builder, which, offset, 10, "SF_CLIP VP%d", i); + ilo_printf("guardband ymin = %f\n", uif(dw)); + + dw = writer_dw(builder, which, offset, 11, "SF_CLIP VP%d", i); + ilo_printf("guardband ymax = %f\n", uif(dw)); + + offset += state_size; + } +} + +static void +writer_decode_sf_viewport_gen6(const struct ilo_builder *builder, + enum ilo_builder_writer_type which, + const struct ilo_builder_item *item) +{ + const unsigned state_size = sizeof(uint32_t) * 8; + const unsigned count = item->size / state_size; + unsigned offset = item->offset; + unsigned i; + + for (i = 0; i < count; i++) { + uint32_t dw; + + dw = writer_dw(builder, which, offset, 0, "SF VP%d", i); + ilo_printf("m00 = %f\n", uif(dw)); + + dw = writer_dw(builder, which, offset, 1, "SF VP%d", i); + ilo_printf("m11 = %f\n", uif(dw)); + + dw = writer_dw(builder, which, offset, 2, "SF VP%d", i); + ilo_printf("m22 = %f\n", uif(dw)); + + dw = writer_dw(builder, which, offset, 3, "SF VP%d", i); + ilo_printf("m30 = %f\n", uif(dw)); + + dw = writer_dw(builder, which, offset, 4, "SF VP%d", i); + ilo_printf("m31 = %f\n", uif(dw)); + + dw = writer_dw(builder, which, offset, 5, "SF VP%d", i); + ilo_printf("m32 = %f\n", uif(dw)); + + offset += state_size; + } +} + +static void +writer_decode_sf_viewport(const struct ilo_builder *builder, + enum ilo_builder_writer_type which, + const struct ilo_builder_item *item) +{ + if (builder->dev->gen >= ILO_GEN(7)) + writer_decode_sf_clip_viewport_gen7(builder, which, item); + else + writer_decode_sf_viewport_gen6(builder, which, item); +} + +static void +writer_decode_scissor_rect(const struct ilo_builder *builder, + enum ilo_builder_writer_type which, + const struct ilo_builder_item *item) +{ + const unsigned state_size = sizeof(uint32_t) * 2; + const unsigned count = item->size / state_size; + unsigned offset = item->offset; + unsigned i; + + for (i = 0; i < count; i++) { + uint32_t dw; + + dw = writer_dw(builder, which, offset, 0, "SCISSOR%d", i); + ilo_printf("xmin %d, ymin %d\n", + READ(dw, GEN6_SCISSOR_DW0_MIN_X), + READ(dw, GEN6_SCISSOR_DW0_MIN_Y)); + + dw = writer_dw(builder, which, offset, 1, "SCISSOR%d", i); + ilo_printf("xmax %d, ymax %d\n", + READ(dw, GEN6_SCISSOR_DW1_MAX_X), + READ(dw, GEN6_SCISSOR_DW1_MAX_Y)); + + offset += state_size; + } +} + +static void +writer_decode_cc_viewport(const struct ilo_builder *builder, + enum ilo_builder_writer_type which, + const struct ilo_builder_item *item) +{ + const unsigned state_size = sizeof(uint32_t) * 2; + const unsigned count = item->size / state_size; + unsigned offset = item->offset; + unsigned i; + + for (i = 0; i < count; i++) { + uint32_t dw; + + dw = writer_dw(builder, which, offset, 0, "CC VP%d", i); + ilo_printf("min_depth = %f\n", uif(dw)); + + dw = writer_dw(builder, which, offset, 1, "CC VP%d", i); + ilo_printf("max_depth = %f\n", uif(dw)); + + offset += state_size; + } +} + +static void +writer_decode_color_calc(const struct ilo_builder *builder, + enum ilo_builder_writer_type which, + const struct ilo_builder_item *item) +{ + uint32_t dw; + + dw = writer_dw(builder, which, item->offset, 0, "CC"); + ilo_printf("alpha test format %s, round disable %d, " + "stencil ref %d, bf stencil ref %d\n", + READ(dw, GEN6_CC_DW0_ALPHATEST) ? "FLOAT32" : "UNORM8", + (bool) (dw & GEN6_CC_DW0_ROUND_DISABLE_DISABLE), + READ(dw, GEN6_CC_DW0_STENCIL0_REF), + READ(dw, GEN6_CC_DW0_STENCIL1_REF)); + + writer_dw(builder, which, item->offset, 1, "CC\n"); + + dw = writer_dw(builder, which, item->offset, 2, "CC"); + ilo_printf("constant red %f\n", uif(dw)); + + dw = writer_dw(builder, which, item->offset, 3, "CC"); + ilo_printf("constant green %f\n", uif(dw)); + + dw = writer_dw(builder, which, item->offset, 4, "CC"); + ilo_printf("constant blue %f\n", uif(dw)); + + dw = writer_dw(builder, which, item->offset, 5, "CC"); + ilo_printf("constant alpha %f\n", uif(dw)); +} + +static void +writer_decode_depth_stencil(const struct ilo_builder *builder, + enum ilo_builder_writer_type which, + const struct ilo_builder_item *item) +{ + uint32_t dw; + + dw = writer_dw(builder, which, item->offset, 0, "D_S"); + ilo_printf("stencil %sable, func %d, write %sable\n", + (dw & GEN6_ZS_DW0_STENCIL_TEST_ENABLE) ? "en" : "dis", + READ(dw, GEN6_ZS_DW0_STENCIL0_FUNC), + (dw & GEN6_ZS_DW0_STENCIL_WRITE_ENABLE) ? "en" : "dis"); + + dw = writer_dw(builder, which, item->offset, 1, "D_S"); + ilo_printf("stencil test mask 0x%x, write mask 0x%x\n", + READ(dw, GEN6_ZS_DW1_STENCIL0_VALUEMASK), + READ(dw, GEN6_ZS_DW1_STENCIL0_WRITEMASK)); + + dw = writer_dw(builder, which, item->offset, 2, "D_S"); + ilo_printf("depth test %sable, func %d, write %sable\n", + (dw & GEN6_ZS_DW2_DEPTH_TEST_ENABLE) ? "en" : "dis", + READ(dw, GEN6_ZS_DW2_DEPTH_FUNC), + (dw & GEN6_ZS_DW2_DEPTH_WRITE_ENABLE) ? "en" : "dis"); +} + +static void +writer_decode_blend(const struct ilo_builder *builder, + enum ilo_builder_writer_type which, + const struct ilo_builder_item *item) +{ + const unsigned state_size = sizeof(uint32_t) * 2; + const unsigned count = item->size / state_size; + unsigned offset = item->offset; + unsigned i; + + for (i = 0; i < count; i++) { + writer_dw(builder, which, offset, 0, "BLEND%d\n", i); + writer_dw(builder, which, offset, 1, "BLEND%d\n", i); + + offset += state_size; + } +} + +static void +writer_decode_sampler(const struct ilo_builder *builder, + enum ilo_builder_writer_type which, + const struct ilo_builder_item *item) +{ + const unsigned state_size = sizeof(uint32_t) * 4; + const unsigned count = item->size / state_size; + unsigned offset = item->offset; + unsigned i; + + for (i = 0; i < count; i++) { + writer_dw(builder, which, offset, 0, "WM SAMP%d", i); + ilo_printf("filtering\n"); + + writer_dw(builder, which, offset, 1, "WM SAMP%d", i); + ilo_printf("wrapping, lod\n"); + + writer_dw(builder, which, offset, 2, "WM SAMP%d", i); + ilo_printf("default color pointer\n"); + + writer_dw(builder, which, offset, 3, "WM SAMP%d", i); + ilo_printf("chroma key, aniso\n"); + + offset += state_size; + } +} + +static void +writer_decode_surface_gen7(const struct ilo_builder *builder, + enum ilo_builder_writer_type which, + const struct ilo_builder_item *item) +{ + uint32_t dw; + + dw = writer_dw(builder, which, item->offset, 0, "SURF"); + ilo_printf("type 0x%x, format 0x%x, tiling %d, %s array\n", + READ(dw, GEN7_SURFACE_DW0_TYPE), + READ(dw, GEN7_SURFACE_DW0_FORMAT), + READ(dw, GEN7_SURFACE_DW0_TILING), + (dw & GEN7_SURFACE_DW0_IS_ARRAY) ? "is" : "not"); + + writer_dw(builder, which, item->offset, 1, "SURF"); + ilo_printf("offset\n"); + + dw = writer_dw(builder, which, item->offset, 2, "SURF"); + ilo_printf("%dx%d size\n", + READ(dw, GEN7_SURFACE_DW2_WIDTH), + READ(dw, GEN7_SURFACE_DW2_HEIGHT)); + + dw = writer_dw(builder, which, item->offset, 3, "SURF"); + ilo_printf("depth %d, pitch %d\n", + READ(dw, GEN7_SURFACE_DW3_DEPTH), + READ(dw, GEN7_SURFACE_DW3_PITCH)); + + dw = writer_dw(builder, which, item->offset, 4, "SURF"); + ilo_printf("min array element %d, array extent %d\n", + READ(dw, GEN7_SURFACE_DW4_MIN_ARRAY_ELEMENT), + READ(dw, GEN7_SURFACE_DW4_RT_VIEW_EXTENT)); + + dw = writer_dw(builder, which, item->offset, 5, "SURF"); + ilo_printf("mip base %d, mips %d, x,y offset: %d,%d\n", + READ(dw, GEN7_SURFACE_DW5_MIN_LOD), + READ(dw, GEN7_SURFACE_DW5_MIP_COUNT_LOD), + READ(dw, GEN7_SURFACE_DW5_X_OFFSET), + READ(dw, GEN7_SURFACE_DW5_Y_OFFSET)); + + writer_dw(builder, which, item->offset, 6, "SURF\n"); + writer_dw(builder, which, item->offset, 7, "SURF\n"); +} + +static void +writer_decode_surface_gen6(const struct ilo_builder *builder, + enum ilo_builder_writer_type which, + const struct ilo_builder_item *item) +{ + uint32_t dw; + + dw = writer_dw(builder, which, item->offset, 0, "SURF"); + ilo_printf("type 0x%x, format 0x%x\n", + READ(dw, GEN6_SURFACE_DW0_TYPE), + READ(dw, GEN6_SURFACE_DW0_FORMAT)); + + writer_dw(builder, which, item->offset, 1, "SURF"); + ilo_printf("offset\n"); + + dw = writer_dw(builder, which, item->offset, 2, "SURF"); + ilo_printf("%dx%d size, %d mips\n", + READ(dw, GEN6_SURFACE_DW2_WIDTH), + READ(dw, GEN6_SURFACE_DW2_HEIGHT), + READ(dw, GEN6_SURFACE_DW2_MIP_COUNT_LOD)); + + dw = writer_dw(builder, which, item->offset, 3, "SURF"); + ilo_printf("pitch %d, tiling %d\n", + READ(dw, GEN6_SURFACE_DW3_PITCH), + READ(dw, GEN6_SURFACE_DW3_TILING)); + + dw = writer_dw(builder, which, item->offset, 4, "SURF"); + ilo_printf("mip base %d\n", + READ(dw, GEN6_SURFACE_DW4_MIN_LOD)); + + dw = writer_dw(builder, which, item->offset, 5, "SURF"); + ilo_printf("x,y offset: %d,%d\n", + READ(dw, GEN6_SURFACE_DW5_X_OFFSET), + READ(dw, GEN6_SURFACE_DW5_Y_OFFSET)); +} + +static void +writer_decode_surface(const struct ilo_builder *builder, + enum ilo_builder_writer_type which, + const struct ilo_builder_item *item) +{ + if (builder->dev->gen >= ILO_GEN(7)) + writer_decode_surface_gen7(builder, which, item); + else + writer_decode_surface_gen6(builder, which, item); +} + +static void +writer_decode_binding_table(const struct ilo_builder *builder, + enum ilo_builder_writer_type which, + const struct ilo_builder_item *item) +{ + const unsigned state_size = sizeof(uint32_t) * 1; + const unsigned count = item->size / state_size; + unsigned offset = item->offset; + unsigned i; + + for (i = 0; i < count; i++) { + writer_dw(builder, which, offset, 0, "BIND"); + ilo_printf("BINDING_TABLE_STATE[%d]\n", i); + + offset += state_size; + } +} + +static void +writer_decode_kernel(const struct ilo_builder *builder, + enum ilo_builder_writer_type which, + const struct ilo_builder_item *item) +{ + const void *kernel; + + ilo_printf("0x%08x:\n", item->offset); + kernel = (const void *) writer_pointer(builder, which, item->offset); + toy_compiler_disassemble(builder->dev, kernel, item->size, true); +} + +static const struct { + void (*func)(const struct ilo_builder *builder, + enum ilo_builder_writer_type which, + const struct ilo_builder_item *item); +} writer_decode_table[ILO_BUILDER_ITEM_COUNT] = { + [ILO_BUILDER_ITEM_BLOB] = { writer_decode_blob }, + [ILO_BUILDER_ITEM_CLIP_VIEWPORT] = { writer_decode_clip_viewport }, + [ILO_BUILDER_ITEM_SF_VIEWPORT] = { writer_decode_sf_viewport }, + [ILO_BUILDER_ITEM_SCISSOR_RECT] = { writer_decode_scissor_rect }, + [ILO_BUILDER_ITEM_CC_VIEWPORT] = { writer_decode_cc_viewport }, + [ILO_BUILDER_ITEM_COLOR_CALC] = { writer_decode_color_calc }, + [ILO_BUILDER_ITEM_DEPTH_STENCIL] = { writer_decode_depth_stencil }, + [ILO_BUILDER_ITEM_BLEND] = { writer_decode_blend }, + [ILO_BUILDER_ITEM_SAMPLER] = { writer_decode_sampler }, + [ILO_BUILDER_ITEM_SURFACE] = { writer_decode_surface }, + [ILO_BUILDER_ITEM_BINDING_TABLE] = { writer_decode_binding_table }, + [ILO_BUILDER_ITEM_KERNEL] = { writer_decode_kernel }, +}; + +static void +ilo_builder_writer_decode_items(struct ilo_builder *builder, + enum ilo_builder_writer_type which) +{ + struct ilo_builder_writer *writer = &builder->writers[which]; + int i; + + if (!writer->item_used) + return; + + writer->ptr = intel_bo_map(writer->bo, false); + if (!writer->ptr) + return; + + for (i = 0; i < writer->item_used; i++) { + const struct ilo_builder_item *item = &writer->items[i]; + + writer_decode_table[item->type].func(builder, which, item); + } + + intel_bo_unmap(writer->bo); +} + +static void +ilo_builder_writer_decode(struct ilo_builder *builder, + enum ilo_builder_writer_type which) +{ + struct ilo_builder_writer *writer = &builder->writers[which]; + + assert(writer->bo && !writer->ptr); + + switch (which) { + case ILO_BUILDER_WRITER_BATCH: + ilo_printf("decoding batch buffer: %d bytes\n", writer->used); + if (writer->used) + intel_winsys_decode_bo(builder->winsys, writer->bo, writer->used); + + ilo_printf("decoding state buffer: %d states\n", + writer->item_used); + ilo_builder_writer_decode_items(builder, which); + break; + case ILO_BUILDER_WRITER_INSTRUCTION: + if (true) { + ilo_printf("skipping instruction buffer: %d kernels\n", + writer->item_used); + } else { + ilo_printf("decoding instruction buffer: %d kernels\n", + writer->item_used); + + ilo_builder_writer_decode_items(builder, which); + } + break; + default: + break; + } +} + +/** + * Decode the builder according to the recorded items. This can be called + * only after a successful ilo_builder_end(). + */ +void +ilo_builder_decode(struct ilo_builder *builder) +{ + int i; + + assert(!builder->unrecoverable_error); + + for (i = 0; i < ILO_BUILDER_WRITER_COUNT; i++) + ilo_builder_writer_decode(builder, i); +} |