aboutsummaryrefslogtreecommitdiffstats
path: root/src/gallium/drivers/iris
diff options
context:
space:
mode:
Diffstat (limited to 'src/gallium/drivers/iris')
-rw-r--r--src/gallium/drivers/iris/iris_batch.c620
-rw-r--r--src/gallium/drivers/iris/iris_batch.h115
-rw-r--r--src/gallium/drivers/iris/iris_bufmgr.c1322
-rw-r--r--src/gallium/drivers/iris/iris_bufmgr.h308
-rw-r--r--src/gallium/drivers/iris/iris_context.h78
-rw-r--r--src/gallium/drivers/iris/iris_draw.c178
-rw-r--r--src/gallium/drivers/iris/iris_formats.c474
-rw-r--r--src/gallium/drivers/iris/iris_pipe.c309
-rw-r--r--src/gallium/drivers/iris/iris_program.c95
-rw-r--r--src/gallium/drivers/iris/iris_resource.c368
-rw-r--r--src/gallium/drivers/iris/iris_resource.h39
-rw-r--r--src/gallium/drivers/iris/iris_screen.c524
-rw-r--r--src/gallium/drivers/iris/iris_screen.h62
-rw-r--r--src/gallium/drivers/iris/iris_state.c920
-rw-r--r--src/gallium/drivers/iris/meson.build68
15 files changed, 5480 insertions, 0 deletions
diff --git a/src/gallium/drivers/iris/iris_batch.c b/src/gallium/drivers/iris/iris_batch.c
new file mode 100644
index 00000000000..e63584fe07b
--- /dev/null
+++ b/src/gallium/drivers/iris/iris_batch.c
@@ -0,0 +1,620 @@
+/*
+ * Copyright © 2017 Intel Corporation
+ *
+ * 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 (including the
+ * next paragraph) 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 VMWARE AND/OR ITS SUPPLIERS 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.
+ */
+
+#include "iris_batch.h"
+#include "iris_bufmgr.h"
+#include "iris_context.h"
+
+#include "drm-uapi/i915_drm.h"
+
+#include "util/hash_table.h"
+#include "main/macros.h"
+
+#include <errno.h>
+#include <xf86drm.h>
+
+#define FILE_DEBUG_FLAG DEBUG_BUFMGR
+
+/**
+ * Target sizes of the batch and state buffers. We create the initial
+ * buffers at these sizes, and flush when they're nearly full. If we
+ * underestimate how close we are to the end, and suddenly need more space
+ * in the middle of a draw, we can grow the buffers, and finish the draw.
+ * At that point, we'll be over our target size, so the next operation
+ * should flush. Each time we flush the batch, we recreate both buffers
+ * at the original target size, so it doesn't grow without bound.
+ */
+#define BATCH_SZ (20 * 1024)
+#define STATE_SZ (16 * 1024)
+
+/* The kernel assumes batchbuffers are smaller than 256kB. */
+#define MAX_BATCH_SIZE (256 * 1024)
+
+/* 3DSTATE_BINDING_TABLE_POINTERS has a U16 offset from Surface State Base
+ * Address, which means that we can't put binding tables beyond 64kB. This
+ * effectively limits the maximum statebuffer size to 64kB.
+ */
+#define MAX_STATE_SIZE (64 * 1024)
+
+static unsigned
+iris_batch_used(struct iris_batch *batch)
+{
+ return batch->cmd_map_next - batch->cmd_map;
+}
+
+static unsigned
+iris_state_used(struct iris_batch *batch)
+{
+ return batch->state_map_next - batch->state_map;
+}
+
+static void
+iris_batch_reset(struct iris_batch *batch);
+
+static bool
+uint_key_compare(const void *a, const void *b)
+{
+ return a == b;
+}
+
+static uint32_t
+uint_key_hash(const void *key)
+{
+ return (uintptr_t) key;
+}
+
+static void
+init_reloc_list(struct iris_reloc_list *rlist, int count)
+{
+ rlist->reloc_count = 0;
+ rlist->reloc_array_size = count;
+ rlist->relocs = malloc(rlist->reloc_array_size *
+ sizeof(struct drm_i915_gem_relocation_entry));
+}
+
+void
+iris_batch_init(struct iris_batch *batch,
+ struct iris_screen *screen,
+ struct pipe_debug_callback *dbg)
+{
+ batch->screen = screen;
+ batch->dbg = dbg;
+
+ init_reloc_list(&batch->batch_relocs, 256);
+ init_reloc_list(&batch->state_relocs, 256);
+
+ batch->exec_count = 0;
+ batch->exec_array_size = 100;
+ batch->exec_bos =
+ malloc(batch->exec_array_size * sizeof(batch->exec_bos[0]));
+ batch->validation_list =
+ malloc(batch->exec_array_size * sizeof(batch->validation_list[0]));
+
+ if (unlikely(INTEL_DEBUG)) {
+ batch->state_sizes =
+ _mesa_hash_table_create(NULL, uint_key_hash, uint_key_compare);
+ }
+
+ iris_batch_reset(batch);
+}
+
+#define READ_ONCE(x) (*(volatile __typeof__(x) *)&(x))
+
+static unsigned
+add_exec_bo(struct iris_batch *batch, struct iris_bo *bo)
+{
+ unsigned index = READ_ONCE(bo->index);
+
+ if (index < batch->exec_count && batch->exec_bos[index] == bo)
+ return index;
+
+ /* May have been shared between multiple active batches */
+ for (index = 0; index < batch->exec_count; index++) {
+ if (batch->exec_bos[index] == bo)
+ return index;
+ }
+
+ iris_bo_reference(bo);
+
+ if (batch->exec_count == batch->exec_array_size) {
+ batch->exec_array_size *= 2;
+ batch->exec_bos =
+ realloc(batch->exec_bos,
+ batch->exec_array_size * sizeof(batch->exec_bos[0]));
+ batch->validation_list =
+ realloc(batch->validation_list,
+ batch->exec_array_size * sizeof(batch->validation_list[0]));
+ }
+
+ batch->validation_list[batch->exec_count] =
+ (struct drm_i915_gem_exec_object2) {
+ .handle = bo->gem_handle,
+ .alignment = bo->align,
+ .offset = bo->gtt_offset,
+ .flags = bo->kflags,
+ };
+
+ bo->index = batch->exec_count;
+ batch->exec_bos[batch->exec_count] = bo;
+ batch->aperture_space += bo->size;
+
+ return batch->exec_count++;
+}
+
+static void
+iris_batch_reset(struct iris_batch *batch)
+{
+ struct iris_screen *screen = batch->screen;
+ struct iris_bufmgr *bufmgr = screen->bufmgr;
+
+ if (batch->last_cmd_bo != NULL) {
+ iris_bo_unreference(batch->last_cmd_bo);
+ batch->last_cmd_bo = NULL;
+ }
+ batch->last_cmd_bo = batch->cmd_bo;
+
+ batch->cmd_bo = iris_bo_alloc(bufmgr, "batchbuffer", BATCH_SZ, 4096);
+ batch->cmd_map = iris_bo_map(NULL, batch->cmd_bo, MAP_READ | MAP_WRITE);
+ batch->cmd_map_next = batch->cmd_map;
+
+ batch->state_bo = iris_bo_alloc(bufmgr, "statebuffer", STATE_SZ, 4096);
+ batch->state_bo->kflags = EXEC_OBJECT_CAPTURE;
+ batch->state_map =
+ iris_bo_map(NULL, batch->state_bo, MAP_READ | MAP_WRITE);
+
+ /* Avoid making 0 a valid state offset - otherwise the decoder will try
+ * and decode data when we use offset 0 as a null pointer.
+ */
+ batch->state_map_next = batch->state_map + 1;
+
+ add_exec_bo(batch, batch->cmd_bo);
+ assert(batch->cmd_bo->index == 0);
+
+ if (batch->state_sizes)
+ _mesa_hash_table_clear(batch->state_sizes, NULL);
+}
+
+static void
+iris_batch_reset_and_clear_render_cache(struct iris_batch *batch)
+{
+ iris_batch_reset(batch);
+ // XXX: iris_render_cache_set_clear(batch);
+}
+
+void
+iris_batch_free(struct iris_batch *batch)
+{
+ for (int i = 0; i < batch->exec_count; i++) {
+ iris_bo_unreference(batch->exec_bos[i]);
+ }
+ free(batch->batch_relocs.relocs);
+ free(batch->state_relocs.relocs);
+ free(batch->exec_bos);
+ free(batch->validation_list);
+
+ iris_bo_unreference(batch->cmd_bo);
+ iris_bo_unreference(batch->state_bo);
+ iris_bo_unreference(batch->last_cmd_bo);
+ if (batch->state_sizes)
+ _mesa_hash_table_destroy(batch->state_sizes, NULL);
+}
+
+/**
+ * Grow either the batch or state buffer to a new larger size.
+ *
+ * We can't actually grow buffers, so we allocate a new one, copy over
+ * the existing contents, and update our lists to refer to the new one.
+ *
+ * Note that this is only temporary - each new batch recreates the buffers
+ * at their original target size (BATCH_SZ or STATE_SZ).
+ */
+static void
+grow_buffer(struct iris_batch *batch,
+ struct iris_bo **bo_ptr,
+ void **map_ptr,
+ void **map_next_ptr,
+ unsigned new_size)
+{
+ struct iris_bufmgr *bufmgr = batch->screen->bufmgr;
+
+ const unsigned existing_bytes = *map_next_ptr - *map_ptr;
+
+ void *old_map = *map_ptr;
+ struct iris_bo *old_bo = *bo_ptr;
+
+ struct iris_bo *new_bo = iris_bo_alloc(bufmgr, old_bo->name, new_size, 4096);
+
+ perf_debug(batch->dbg, "Growing %s - ran out of space\n", old_bo->name);
+
+ void *new_map = iris_bo_map(NULL, new_bo, MAP_READ | MAP_WRITE);
+ memcpy(new_map, old_map, existing_bytes);
+
+ /* Try to put the new BO at the same GTT offset as the old BO (which
+ * we're throwing away, so it doesn't need to be there).
+ *
+ * This guarantees that our relocations continue to work: values we've
+ * already written into the buffer, values we're going to write into the
+ * buffer, and the validation/relocation lists all will match.
+ */
+ new_bo->gtt_offset = old_bo->gtt_offset;
+ new_bo->index = old_bo->index;
+
+ /* Batch/state buffers are per-context, and if we've run out of space,
+ * we must have actually used them before, so...they will be in the list.
+ */
+ assert(old_bo->index < batch->exec_count);
+ assert(batch->exec_bos[old_bo->index] == old_bo);
+
+ /* Update the validation list to use the new BO. */
+ batch->exec_bos[old_bo->index] = new_bo;
+ batch->validation_list[old_bo->index].handle = new_bo->gem_handle;
+ iris_bo_reference(new_bo);
+ iris_bo_unreference(old_bo);
+
+ /* Drop the *bo_ptr reference. This should free the old BO. */
+ iris_bo_unreference(old_bo);
+
+ *bo_ptr = new_bo;
+ *map_ptr = new_map;
+ *map_next_ptr = new_map + existing_bytes;
+}
+
+void
+iris_require_command_space(struct iris_batch *batch, unsigned size)
+{
+ if (iris_batch_used(batch) + size >= BATCH_SZ) {
+ if (!batch->no_wrap) {
+ iris_batch_flush(batch);
+ } else {
+ const unsigned new_size =
+ MIN2(batch->cmd_bo->size + batch->cmd_bo->size / 2,
+ MAX_BATCH_SIZE);
+ grow_buffer(batch, &batch->cmd_bo, &batch->cmd_map,
+ &batch->cmd_map_next, new_size);
+ assert(iris_batch_used(batch) + size < batch->cmd_bo->size);
+ }
+ }
+}
+
+void
+iris_batch_emit(struct iris_batch *batch, const void *data, unsigned size)
+{
+ iris_require_command_space(batch, size);
+ memcpy(batch->cmd_map_next, data, size);
+}
+
+/**
+ * Called when starting a new batch buffer.
+ */
+static void
+iris_new_batch(struct iris_batch *batch)
+{
+ /* Unreference any BOs held by the previous batch, and reset counts. */
+ for (int i = 0; i < batch->exec_count; i++) {
+ iris_bo_unreference(batch->exec_bos[i]);
+ batch->exec_bos[i] = NULL;
+ }
+ batch->batch_relocs.reloc_count = 0;
+ batch->state_relocs.reloc_count = 0;
+ batch->exec_count = 0;
+ batch->aperture_space = 0;
+
+ iris_bo_unreference(batch->state_bo);
+
+ /* Create a new batchbuffer and reset the associated state: */
+ iris_batch_reset_and_clear_render_cache(batch);
+}
+
+/**
+ * Called from iris_batch_flush before emitting MI_BATCHBUFFER_END and
+ * sending it off.
+ *
+ * This function can emit state (say, to preserve registers that aren't saved
+ * between batches).
+ */
+static void
+iris_finish_batch(struct iris_batch *batch)
+{
+ batch->no_wrap = true;
+
+ /* Mark the end of the buffer. */
+ const uint32_t MI_BATCH_BUFFER_END = (0xA << 23);
+ iris_batch_emit(batch, &MI_BATCH_BUFFER_END, sizeof(uint32_t));
+
+ batch->no_wrap = false;
+}
+
+static int
+submit_batch(struct iris_batch *batch, int in_fence_fd, int *out_fence_fd)
+{
+ iris_bo_unmap(batch->cmd_bo);
+ iris_bo_unmap(batch->state_bo);
+
+ /* The requirement for using I915_EXEC_NO_RELOC are:
+ *
+ * The addresses written in the objects must match the corresponding
+ * reloc.gtt_offset which in turn must match the corresponding
+ * execobject.offset.
+ *
+ * Any render targets written to in the batch must be flagged with
+ * EXEC_OBJECT_WRITE.
+ *
+ * To avoid stalling, execobject.offset should match the current
+ * address of that object within the active context.
+ */
+ int flags = I915_EXEC_NO_RELOC |
+ I915_EXEC_BATCH_FIRST |
+ I915_EXEC_HANDLE_LUT |
+ I915_EXEC_RENDER;
+
+ /* Set statebuffer relocations */
+ const unsigned state_index = batch->state_bo->index;
+ if (state_index < batch->exec_count &&
+ batch->exec_bos[state_index] == batch->state_bo) {
+ struct drm_i915_gem_exec_object2 *entry =
+ &batch->validation_list[state_index];
+ assert(entry->handle == batch->state_bo->gem_handle);
+ entry->relocation_count = batch->state_relocs.reloc_count;
+ entry->relocs_ptr = (uintptr_t) batch->state_relocs.relocs;
+ }
+
+ /* Set batchbuffer relocations */
+ struct drm_i915_gem_exec_object2 *entry = &batch->validation_list[0];
+ assert(entry->handle == batch->cmd_bo->gem_handle);
+ entry->relocation_count = batch->batch_relocs.reloc_count;
+ entry->relocs_ptr = (uintptr_t) batch->batch_relocs.relocs;
+
+ struct drm_i915_gem_execbuffer2 execbuf = {
+ .buffers_ptr = (uintptr_t) batch->validation_list,
+ .buffer_count = batch->exec_count,
+ .batch_start_offset = 0,
+ .batch_len = iris_batch_used(batch),
+ .flags = flags,
+ .rsvd1 = batch->hw_ctx_id, /* rsvd1 is actually the context ID */
+ };
+
+ unsigned long cmd = DRM_IOCTL_I915_GEM_EXECBUFFER2;
+
+ if (in_fence_fd != -1) {
+ execbuf.rsvd2 = in_fence_fd;
+ execbuf.flags |= I915_EXEC_FENCE_IN;
+ }
+
+ if (out_fence_fd != NULL) {
+ cmd = DRM_IOCTL_I915_GEM_EXECBUFFER2_WR;
+ *out_fence_fd = -1;
+ execbuf.flags |= I915_EXEC_FENCE_OUT;
+ }
+
+ int ret = drm_ioctl(batch->screen->fd, cmd, &execbuf);
+ if (ret != 0)
+ ret = -errno;
+
+ for (int i = 0; i < batch->exec_count; i++) {
+ struct iris_bo *bo = batch->exec_bos[i];
+
+ bo->idle = false;
+ bo->index = -1;
+
+ /* Update iris_bo::gtt_offset */
+ if (batch->validation_list[i].offset != bo->gtt_offset) {
+ DBG("BO %d migrated: 0x%" PRIx64 " -> 0x%llx\n",
+ bo->gem_handle, bo->gtt_offset,
+ batch->validation_list[i].offset);
+ bo->gtt_offset = batch->validation_list[i].offset;
+ }
+ }
+
+ if (ret == 0 && out_fence_fd != NULL)
+ *out_fence_fd = execbuf.rsvd2 >> 32;
+
+ return ret;
+}
+
+/**
+ * The in_fence_fd is ignored if -1. Otherwise this function takes ownership
+ * of the fd.
+ *
+ * The out_fence_fd is ignored if NULL. Otherwise, the caller takes ownership
+ * of the returned fd.
+ */
+int
+_iris_batch_flush_fence(struct iris_batch *batch,
+ int in_fence_fd, int *out_fence_fd,
+ const char *file, int line)
+{
+ if (iris_batch_used(batch) == 0)
+ return 0;
+
+ /* Check that we didn't just wrap our batchbuffer at a bad time. */
+ assert(!batch->no_wrap);
+
+ iris_finish_batch(batch);
+
+ if (unlikely(INTEL_DEBUG & (DEBUG_BATCH | DEBUG_SUBMIT))) {
+ int bytes_for_commands = iris_batch_used(batch);
+ int bytes_for_state = iris_state_used(batch);
+ fprintf(stderr, "%19s:%-3d: Batchbuffer flush with %5db (%0.1f%%) (pkt),"
+ " %5db (%0.1f%%) (state), %4d BOs (%0.1fMb aperture),"
+ " %4d batch relocs, %4d state relocs\n", file, line,
+ bytes_for_commands, 100.0f * bytes_for_commands / BATCH_SZ,
+ bytes_for_state, 100.0f * bytes_for_state / STATE_SZ,
+ batch->exec_count,
+ (float) batch->aperture_space / (1024 * 1024),
+ batch->batch_relocs.reloc_count,
+ batch->state_relocs.reloc_count);
+ }
+
+ int ret = submit_batch(batch, in_fence_fd, out_fence_fd);
+ if (ret < 0)
+ return ret;
+
+ //throttle(brw);
+
+ //if (unlikely(INTEL_DEBUG & DEBUG_BATCH))
+ //do_batch_dump(brw);
+
+ //if (brw->ctx.Const.ResetStrategy == GL_LOSE_CONTEXT_ON_RESET_ARB)
+ //iris_check_for_reset(ice);
+
+ if (unlikely(INTEL_DEBUG & DEBUG_SYNC)) {
+ dbg_printf("waiting for idle\n");
+ iris_bo_wait_rendering(batch->cmd_bo);
+ }
+
+ /* Start a new batch buffer. */
+ iris_new_batch(batch);
+
+ return 0;
+}
+
+bool
+iris_batch_references(struct iris_batch *batch, struct iris_bo *bo)
+{
+ unsigned index = READ_ONCE(bo->index);
+ if (index < batch->exec_count && batch->exec_bos[index] == bo)
+ return true;
+
+ for (int i = 0; i < batch->exec_count; i++) {
+ if (batch->exec_bos[i] == bo)
+ return true;
+ }
+ return false;
+}
+
+/* This is the only way buffers get added to the validate list.
+ */
+static uint64_t
+emit_reloc(struct iris_batch *batch,
+ struct iris_reloc_list *rlist, uint32_t offset,
+ struct iris_bo *target, uint32_t target_offset,
+ unsigned int reloc_flags)
+{
+ assert(target != NULL);
+
+ if (rlist->reloc_count == rlist->reloc_array_size) {
+ rlist->reloc_array_size *= 2;
+ rlist->relocs = realloc(rlist->relocs,
+ rlist->reloc_array_size *
+ sizeof(struct drm_i915_gem_relocation_entry));
+ }
+
+ unsigned int index = add_exec_bo(batch, target);
+ struct drm_i915_gem_exec_object2 *entry = &batch->validation_list[index];
+
+ rlist->relocs[rlist->reloc_count++] =
+ (struct drm_i915_gem_relocation_entry) {
+ .offset = offset,
+ .delta = target_offset,
+ .target_handle = index,
+ .presumed_offset = entry->offset,
+ };
+
+ /* Using the old buffer offset, write in what the right data would be, in
+ * case the buffer doesn't move and we can short-circuit the relocation
+ * processing in the kernel
+ */
+ return entry->offset + target_offset;
+}
+
+uint64_t
+iris_batch_reloc(struct iris_batch *batch, uint32_t batch_offset,
+ struct iris_bo *target, uint32_t target_offset,
+ unsigned int reloc_flags)
+{
+ assert(batch_offset <= batch->cmd_bo->size - sizeof(uint32_t));
+
+ return emit_reloc(batch, &batch->batch_relocs, batch_offset,
+ target, target_offset, reloc_flags);
+}
+
+uint64_t
+iris_state_reloc(struct iris_batch *batch, uint32_t state_offset,
+ struct iris_bo *target, uint32_t target_offset,
+ unsigned int reloc_flags)
+{
+ assert(state_offset <= batch->state_bo->size - sizeof(uint32_t));
+
+ return emit_reloc(batch, &batch->state_relocs, state_offset,
+ target, target_offset, reloc_flags);
+}
+
+
+static uint32_t
+iris_state_entry_size(struct iris_batch *batch, uint32_t offset)
+{
+ struct hash_entry *entry =
+ _mesa_hash_table_search(batch->state_sizes, (void *)(uintptr_t) offset);
+ return entry ? (uintptr_t) entry->data : 0;
+}
+
+/**
+ * Reserve some space in the statebuffer, or flush.
+ *
+ * This is used to estimate when we're near the end of the batch,
+ * so we can flush early.
+ */
+void
+iris_require_state_space(struct iris_batch *batch, unsigned size)
+{
+ if (iris_state_used(batch) + size >= STATE_SZ)
+ iris_batch_flush(batch);
+}
+
+/**
+ * Allocates a block of space in the batchbuffer for indirect state.
+ */
+void *
+iris_alloc_state(struct iris_batch *batch,
+ int size, int alignment,
+ uint32_t *out_offset)
+{
+ assert(size < batch->cmd_bo->size);
+
+ if (ALIGN(iris_state_used(batch), alignment) + size >= STATE_SZ) {
+ if (!batch->no_wrap) {
+ iris_batch_flush(batch);
+ } else {
+ const unsigned new_size =
+ MIN2(batch->state_bo->size + batch->state_bo->size / 2,
+ MAX_STATE_SIZE);
+ grow_buffer(batch, &batch->state_bo, &batch->state_map,
+ &batch->state_map_next, new_size);
+ }
+ }
+
+ unsigned offset = ALIGN(iris_state_used(batch), alignment);
+ assert(offset + size < batch->state_bo->size);
+
+ if (unlikely(batch->state_sizes)) {
+ _mesa_hash_table_insert(batch->state_sizes,
+ (void *) (uintptr_t) offset,
+ (void *) (uintptr_t) size);
+ }
+
+ batch->state_map_next = batch->state_map + offset + size;
+
+ *out_offset = offset;
+ return batch->state_map + offset;
+}
diff --git a/src/gallium/drivers/iris/iris_batch.h b/src/gallium/drivers/iris/iris_batch.h
new file mode 100644
index 00000000000..4c681539d6f
--- /dev/null
+++ b/src/gallium/drivers/iris/iris_batch.h
@@ -0,0 +1,115 @@
+/*
+ * Copyright © 2017 Intel Corporation
+ *
+ * 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 (including the next
+ * paragraph) 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.
+ */
+
+#ifndef IRIS_BATCH_DOT_H
+#define IRIS_BATCH_DOT_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+struct iris_address {
+ struct iris_bo *bo;
+ unsigned reloc_flags;
+ uint32_t offset;
+};
+
+struct iris_reloc_list {
+ struct drm_i915_gem_relocation_entry *relocs;
+ int reloc_count;
+ int reloc_array_size;
+};
+
+struct iris_batch {
+ struct iris_screen *screen;
+ struct pipe_debug_callback *dbg;
+
+ /** Current batchbuffer being queued up. */
+ struct iris_bo *cmd_bo;
+ /** Current statebuffer being queued up. */
+ struct iris_bo *state_bo;
+
+ /** Last BO submitted to the hardware. Used for glFinish(). */
+ struct iris_bo *last_cmd_bo;
+
+ uint32_t hw_ctx_id;
+
+ void *cmd_map_next;
+ void *cmd_map;
+ void *state_map;
+ void *state_map_next;
+
+ bool no_wrap;
+
+ struct iris_reloc_list batch_relocs;
+ struct iris_reloc_list state_relocs;
+
+ /** The validation list */
+ struct drm_i915_gem_exec_object2 *validation_list;
+ struct iris_bo **exec_bos;
+ int exec_count;
+ int exec_array_size;
+
+ /** The amount of aperture space (in bytes) used by all exec_bos */
+ int aperture_space;
+
+ /** Map from batch offset to iris_alloc_state data (with DEBUG_BATCH) */
+ struct hash_table *state_sizes;
+};
+
+void iris_batch_init(struct iris_batch *batch,
+ struct iris_screen *screen,
+ struct pipe_debug_callback *dbg);
+void iris_batch_free(struct iris_batch *batch);
+void iris_require_command_space(struct iris_batch *batch, unsigned size);
+void iris_require_state_space(struct iris_batch *batch, unsigned size);
+void iris_batch_emit(struct iris_batch *batch, const void *data, unsigned size);
+void *iris_alloc_state(struct iris_batch *batch, int size, int alignment,
+ uint32_t *out_offset);
+
+int _iris_batch_flush_fence(struct iris_batch *batch,
+ int in_fence_fd, int *out_fence_fd,
+ const char *file, int line);
+
+
+#define iris_batch_flush_fence(batch, in_fence_fd, out_fence_fd) \
+ _iris_batch_flush_fence((batch), (in_fence_fd), (out_fence_fd), \
+ __FILE__, __LINE__)
+
+#define iris_batch_flush(batch) iris_batch_flush_fence((batch), -1, NULL)
+
+bool iris_batch_references(struct iris_batch *batch, struct iris_bo *bo);
+
+#define RELOC_WRITE EXEC_OBJECT_WRITE
+
+uint64_t iris_batch_reloc(struct iris_batch *batch,
+ uint32_t batch_offset,
+ struct iris_bo *target,
+ uint32_t target_offset,
+ unsigned flags);
+
+uint64_t iris_state_reloc(struct iris_batch *batch,
+ uint32_t batch_offset,
+ struct iris_bo *target,
+ uint32_t target_offset,
+ unsigned flags);
+#endif
diff --git a/src/gallium/drivers/iris/iris_bufmgr.c b/src/gallium/drivers/iris/iris_bufmgr.c
new file mode 100644
index 00000000000..ce1066beaf0
--- /dev/null
+++ b/src/gallium/drivers/iris/iris_bufmgr.c
@@ -0,0 +1,1322 @@
+/*
+ * Copyright © 2017 Intel Corporation
+ *
+ * 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 (including the next
+ * paragraph) 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.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <xf86drm.h>
+#include <util/u_atomic.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <assert.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <stdbool.h>
+#include <time.h>
+
+#include "errno.h"
+#ifndef ETIME
+#define ETIME ETIMEDOUT
+#endif
+#include "common/gen_clflush.h"
+#include "common/gen_debug.h"
+#include "dev/gen_device_info.h"
+#include "main/macros.h"
+#include "util/macros.h"
+#include "util/hash_table.h"
+#include "util/list.h"
+#include "iris_bufmgr.h"
+#include "iris_context.h"
+#include "string.h"
+
+#include "drm-uapi/i915_drm.h"
+
+#ifdef HAVE_VALGRIND
+#include <valgrind.h>
+#include <memcheck.h>
+#define VG(x) x
+#else
+#define VG(x)
+#endif
+
+/* VALGRIND_FREELIKE_BLOCK unfortunately does not actually undo the earlier
+ * VALGRIND_MALLOCLIKE_BLOCK but instead leaves vg convinced the memory is
+ * leaked. All because it does not call VG(cli_free) from its
+ * VG_USERREQ__FREELIKE_BLOCK handler. Instead of treating the memory like
+ * and allocation, we mark it available for use upon mmapping and remove
+ * it upon unmapping.
+ */
+#define VG_DEFINED(ptr, size) VG(VALGRIND_MAKE_MEM_DEFINED(ptr, size))
+#define VG_NOACCESS(ptr, size) VG(VALGRIND_MAKE_MEM_NOACCESS(ptr, size))
+
+#define PAGE_SIZE 4096
+
+#define FILE_DEBUG_FLAG DEBUG_BUFMGR
+
+/**
+ * Call ioctl, restarting if it is interupted
+ */
+int
+drm_ioctl(int fd, unsigned long request, void *arg)
+{
+ int ret;
+
+ do {
+ ret = ioctl(fd, request, arg);
+ } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
+ return ret;
+}
+
+
+
+static inline int
+atomic_add_unless(int *v, int add, int unless)
+{
+ int c, old;
+ c = p_atomic_read(v);
+ while (c != unless && (old = p_atomic_cmpxchg(v, c, c + add)) != c)
+ c = old;
+ return c == unless;
+}
+
+struct bo_cache_bucket {
+ struct list_head head;
+ uint64_t size;
+};
+
+struct iris_bufmgr {
+ int fd;
+
+ mtx_t lock;
+
+ /** Array of lists of cached gem objects of power-of-two sizes */
+ struct bo_cache_bucket cache_bucket[14 * 4];
+ int num_buckets;
+ time_t time;
+
+ struct hash_table *name_table;
+ struct hash_table *handle_table;
+
+ bool has_llc:1;
+ bool bo_reuse:1;
+};
+
+static int bo_set_tiling_internal(struct iris_bo *bo, uint32_t tiling_mode,
+ uint32_t stride);
+
+static void bo_free(struct iris_bo *bo);
+
+static uint32_t
+key_hash_uint(const void *key)
+{
+ return _mesa_hash_data(key, 4);
+}
+
+static bool
+key_uint_equal(const void *a, const void *b)
+{
+ return *((unsigned *) a) == *((unsigned *) b);
+}
+
+static struct iris_bo *
+hash_find_bo(struct hash_table *ht, unsigned int key)
+{
+ struct hash_entry *entry = _mesa_hash_table_search(ht, &key);
+ return entry ? (struct iris_bo *) entry->data : NULL;
+}
+
+/**
+ * This function finds the correct bucket fit for the input size.
+ * The function works with O(1) complexity when the requested size
+ * was queried instead of iterating the size through all the buckets.
+ */
+static struct bo_cache_bucket *
+bucket_for_size(struct iris_bufmgr *bufmgr, uint64_t size)
+{
+ /* Calculating the pages and rounding up to the page size. */
+ const unsigned pages = (size + PAGE_SIZE - 1) / PAGE_SIZE;
+
+ /* Row Bucket sizes clz((x-1) | 3) Row Column
+ * in pages stride size
+ * 0: 1 2 3 4 -> 30 30 30 30 4 1
+ * 1: 5 6 7 8 -> 29 29 29 29 4 1
+ * 2: 10 12 14 16 -> 28 28 28 28 8 2
+ * 3: 20 24 28 32 -> 27 27 27 27 16 4
+ */
+ const unsigned row = 30 - __builtin_clz((pages - 1) | 3);
+ const unsigned row_max_pages = 4 << row;
+
+ /* The '& ~2' is the special case for row 1. In row 1, max pages /
+ * 2 is 2, but the previous row maximum is zero (because there is
+ * no previous row). All row maximum sizes are power of 2, so that
+ * is the only case where that bit will be set.
+ */
+ const unsigned prev_row_max_pages = (row_max_pages / 2) & ~2;
+ int col_size_log2 = row - 1;
+ col_size_log2 += (col_size_log2 < 0);
+
+ const unsigned col = (pages - prev_row_max_pages +
+ ((1 << col_size_log2) - 1)) >> col_size_log2;
+
+ /* Calculating the index based on the row and column. */
+ const unsigned index = (row * 4) + (col - 1);
+
+ return (index < bufmgr->num_buckets) ?
+ &bufmgr->cache_bucket[index] : NULL;
+}
+
+int
+iris_bo_busy(struct iris_bo *bo)
+{
+ struct iris_bufmgr *bufmgr = bo->bufmgr;
+ struct drm_i915_gem_busy busy = { .handle = bo->gem_handle };
+
+ int ret = drm_ioctl(bufmgr->fd, DRM_IOCTL_I915_GEM_BUSY, &busy);
+ if (ret == 0) {
+ bo->idle = !busy.busy;
+ return busy.busy;
+ }
+ return false;
+}
+
+int
+iris_bo_madvise(struct iris_bo *bo, int state)
+{
+ struct drm_i915_gem_madvise madv = {
+ .handle = bo->gem_handle,
+ .madv = state,
+ .retained = 1,
+ };
+
+ drm_ioctl(bo->bufmgr->fd, DRM_IOCTL_I915_GEM_MADVISE, &madv);
+
+ return madv.retained;
+}
+
+/* drop the oldest entries that have been purged by the kernel */
+static void
+iris_bo_cache_purge_bucket(struct iris_bufmgr *bufmgr,
+ struct bo_cache_bucket *bucket)
+{
+ list_for_each_entry_safe(struct iris_bo, bo, &bucket->head, head) {
+ if (iris_bo_madvise(bo, I915_MADV_DONTNEED))
+ break;
+
+ list_del(&bo->head);
+ bo_free(bo);
+ }
+}
+
+static struct iris_bo *
+bo_alloc_internal(struct iris_bufmgr *bufmgr,
+ const char *name,
+ uint64_t size,
+ unsigned flags,
+ uint32_t tiling_mode,
+ uint32_t stride, uint64_t alignment)
+{
+ struct iris_bo *bo;
+ unsigned int page_size = getpagesize();
+ int ret;
+ struct bo_cache_bucket *bucket;
+ bool alloc_from_cache;
+ uint64_t bo_size;
+ bool busy = false;
+ bool zeroed = false;
+
+ if (flags & BO_ALLOC_BUSY)
+ busy = true;
+
+ if (flags & BO_ALLOC_ZEROED)
+ zeroed = true;
+
+ /* BUSY does doesn't really jive with ZEROED as we have to wait for it to
+ * be idle before we can memset. Just disallow that combination.
+ */
+ assert(!(busy && zeroed));
+
+ /* Round the allocated size up to a power of two number of pages. */
+ bucket = bucket_for_size(bufmgr, size);
+
+ /* If we don't have caching at this size, don't actually round the
+ * allocation up.
+ */
+ if (bucket == NULL) {
+ bo_size = size;
+ if (bo_size < page_size)
+ bo_size = page_size;
+ } else {
+ bo_size = bucket->size;
+ }
+
+ mtx_lock(&bufmgr->lock);
+ /* Get a buffer out of the cache if available */
+retry:
+ alloc_from_cache = false;
+ if (bucket != NULL && !list_empty(&bucket->head)) {
+ if (busy && !zeroed) {
+ /* Allocate new render-target BOs from the tail (MRU)
+ * of the list, as it will likely be hot in the GPU
+ * cache and in the aperture for us. If the caller
+ * asked us to zero the buffer, we don't want this
+ * because we are going to mmap it.
+ */
+ bo = LIST_ENTRY(struct iris_bo, bucket->head.prev, head);
+ list_del(&bo->head);
+ alloc_from_cache = true;
+ bo->align = alignment;
+ } else {
+ assert(alignment == 0);
+ /* For non-render-target BOs (where we're probably
+ * going to map it first thing in order to fill it
+ * with data), check if the last BO in the cache is
+ * unbusy, and only reuse in that case. Otherwise,
+ * allocating a new buffer is probably faster than
+ * waiting for the GPU to finish.
+ */
+ bo = LIST_ENTRY(struct iris_bo, bucket->head.next, head);
+ if (!iris_bo_busy(bo)) {
+ alloc_from_cache = true;
+ list_del(&bo->head);
+ }
+ }
+
+ if (alloc_from_cache) {
+ if (!iris_bo_madvise(bo, I915_MADV_WILLNEED)) {
+ bo_free(bo);
+ iris_bo_cache_purge_bucket(bufmgr, bucket);
+ goto retry;
+ }
+
+ if (bo_set_tiling_internal(bo, tiling_mode, stride)) {
+ bo_free(bo);
+ goto retry;
+ }
+
+ if (zeroed) {
+ void *map = iris_bo_map(NULL, bo, MAP_WRITE | MAP_RAW);
+ if (!map) {
+ bo_free(bo);
+ goto retry;
+ }
+ memset(map, 0, bo_size);
+ }
+ }
+ }
+
+ if (!alloc_from_cache) {
+ bo = calloc(1, sizeof(*bo));
+ if (!bo)
+ goto err;
+
+ bo->size = bo_size;
+ bo->idle = true;
+
+ struct drm_i915_gem_create create = { .size = bo_size };
+
+ /* All new BOs we get from the kernel are zeroed, so we don't need to
+ * worry about that here.
+ */
+ ret = drm_ioctl(bufmgr->fd, DRM_IOCTL_I915_GEM_CREATE, &create);
+ if (ret != 0) {
+ free(bo);
+ goto err;
+ }
+
+ bo->gem_handle = create.handle;
+
+ bo->bufmgr = bufmgr;
+ bo->align = alignment;
+
+ bo->tiling_mode = I915_TILING_NONE;
+ bo->swizzle_mode = I915_BIT_6_SWIZZLE_NONE;
+ bo->stride = 0;
+
+ if (bo_set_tiling_internal(bo, tiling_mode, stride))
+ goto err_free;
+
+ /* Calling set_domain() will allocate pages for the BO outside of the
+ * struct mutex lock in the kernel, which is more efficient than waiting
+ * to create them during the first execbuf that uses the BO.
+ */
+ struct drm_i915_gem_set_domain sd = {
+ .handle = bo->gem_handle,
+ .read_domains = I915_GEM_DOMAIN_CPU,
+ .write_domain = 0,
+ };
+
+ if (drm_ioctl(bo->bufmgr->fd, DRM_IOCTL_I915_GEM_SET_DOMAIN, &sd) != 0)
+ goto err_free;
+ }
+
+ bo->name = name;
+ p_atomic_set(&bo->refcount, 1);
+ bo->reusable = true;
+ bo->cache_coherent = bufmgr->has_llc;
+ bo->index = -1;
+
+ mtx_unlock(&bufmgr->lock);
+
+ DBG("bo_create: buf %d (%s) %llub\n", bo->gem_handle, bo->name,
+ (unsigned long long) size);
+
+ return bo;
+
+err_free:
+ bo_free(bo);
+err:
+ mtx_unlock(&bufmgr->lock);
+ return NULL;
+}
+
+struct iris_bo *
+iris_bo_alloc(struct iris_bufmgr *bufmgr,
+ const char *name, uint64_t size, uint64_t alignment)
+{
+ return bo_alloc_internal(bufmgr, name, size, 0, I915_TILING_NONE, 0, 0);
+}
+
+struct iris_bo *
+iris_bo_alloc_tiled(struct iris_bufmgr *bufmgr, const char *name,
+ uint64_t size, uint32_t tiling_mode, uint32_t pitch,
+ unsigned flags)
+{
+ return bo_alloc_internal(bufmgr, name, size, flags, tiling_mode, pitch, 0);
+}
+
+/**
+ * Returns a iris_bo wrapping the given buffer object handle.
+ *
+ * This can be used when one application needs to pass a buffer object
+ * to another.
+ */
+struct iris_bo *
+iris_bo_gem_create_from_name(struct iris_bufmgr *bufmgr,
+ const char *name, unsigned int handle)
+{
+ struct iris_bo *bo;
+
+ /* At the moment most applications only have a few named bo.
+ * For instance, in a DRI client only the render buffers passed
+ * between X and the client are named. And since X returns the
+ * alternating names for the front/back buffer a linear search
+ * provides a sufficiently fast match.
+ */
+ mtx_lock(&bufmgr->lock);
+ bo = hash_find_bo(bufmgr->name_table, handle);
+ if (bo) {
+ iris_bo_reference(bo);
+ goto out;
+ }
+
+ struct drm_gem_open open_arg = { .name = handle };
+ int ret = drm_ioctl(bufmgr->fd, DRM_IOCTL_GEM_OPEN, &open_arg);
+ if (ret != 0) {
+ DBG("Couldn't reference %s handle 0x%08x: %s\n",
+ name, handle, strerror(errno));
+ bo = NULL;
+ goto out;
+ }
+ /* Now see if someone has used a prime handle to get this
+ * object from the kernel before by looking through the list
+ * again for a matching gem_handle
+ */
+ bo = hash_find_bo(bufmgr->handle_table, open_arg.handle);
+ if (bo) {
+ iris_bo_reference(bo);
+ goto out;
+ }
+
+ bo = calloc(1, sizeof(*bo));
+ if (!bo)
+ goto out;
+
+ p_atomic_set(&bo->refcount, 1);
+
+ bo->size = open_arg.size;
+ bo->gtt_offset = 0;
+ bo->bufmgr = bufmgr;
+ bo->gem_handle = open_arg.handle;
+ bo->name = name;
+ bo->global_name = handle;
+ bo->reusable = false;
+ bo->external = true;
+
+ _mesa_hash_table_insert(bufmgr->handle_table, &bo->gem_handle, bo);
+ _mesa_hash_table_insert(bufmgr->name_table, &bo->global_name, bo);
+
+ struct drm_i915_gem_get_tiling get_tiling = { .handle = bo->gem_handle };
+ ret = drm_ioctl(bufmgr->fd, DRM_IOCTL_I915_GEM_GET_TILING, &get_tiling);
+ if (ret != 0)
+ goto err_unref;
+
+ bo->tiling_mode = get_tiling.tiling_mode;
+ bo->swizzle_mode = get_tiling.swizzle_mode;
+ /* XXX stride is unknown */
+ DBG("bo_create_from_handle: %d (%s)\n", handle, bo->name);
+
+out:
+ mtx_unlock(&bufmgr->lock);
+ return bo;
+
+err_unref:
+ bo_free(bo);
+ mtx_unlock(&bufmgr->lock);
+ return NULL;
+}
+
+static void
+bo_free(struct iris_bo *bo)
+{
+ struct iris_bufmgr *bufmgr = bo->bufmgr;
+
+ if (bo->map_cpu) {
+ VG_NOACCESS(bo->map_cpu, bo->size);
+ munmap(bo->map_cpu, bo->size);
+ }
+ if (bo->map_wc) {
+ VG_NOACCESS(bo->map_wc, bo->size);
+ munmap(bo->map_wc, bo->size);
+ }
+ if (bo->map_gtt) {
+ VG_NOACCESS(bo->map_gtt, bo->size);
+ munmap(bo->map_gtt, bo->size);
+ }
+
+ if (bo->external) {
+ struct hash_entry *entry;
+
+ if (bo->global_name) {
+ entry = _mesa_hash_table_search(bufmgr->name_table, &bo->global_name);
+ _mesa_hash_table_remove(bufmgr->name_table, entry);
+ }
+
+ entry = _mesa_hash_table_search(bufmgr->handle_table, &bo->gem_handle);
+ _mesa_hash_table_remove(bufmgr->handle_table, entry);
+ }
+
+ /* Close this object */
+ struct drm_gem_close close = { .handle = bo->gem_handle };
+ int ret = drm_ioctl(bufmgr->fd, DRM_IOCTL_GEM_CLOSE, &close);
+ if (ret != 0) {
+ DBG("DRM_IOCTL_GEM_CLOSE %d failed (%s): %s\n",
+ bo->gem_handle, bo->name, strerror(errno));
+ }
+ free(bo);
+}
+
+/** Frees all cached buffers significantly older than @time. */
+static void
+cleanup_bo_cache(struct iris_bufmgr *bufmgr, time_t time)
+{
+ int i;
+
+ if (bufmgr->time == time)
+ return;
+
+ for (i = 0; i < bufmgr->num_buckets; i++) {
+ struct bo_cache_bucket *bucket = &bufmgr->cache_bucket[i];
+
+ list_for_each_entry_safe(struct iris_bo, bo, &bucket->head, head) {
+ if (time - bo->free_time <= 1)
+ break;
+
+ list_del(&bo->head);
+
+ bo_free(bo);
+ }
+ }
+
+ bufmgr->time = time;
+}
+
+static void
+bo_unreference_final(struct iris_bo *bo, time_t time)
+{
+ struct iris_bufmgr *bufmgr = bo->bufmgr;
+ struct bo_cache_bucket *bucket;
+
+ DBG("bo_unreference final: %d (%s)\n", bo->gem_handle, bo->name);
+
+ bucket = bucket_for_size(bufmgr, bo->size);
+ /* Put the buffer into our internal cache for reuse if we can. */
+ if (bufmgr->bo_reuse && bo->reusable && bucket != NULL &&
+ iris_bo_madvise(bo, I915_MADV_DONTNEED)) {
+ bo->free_time = time;
+
+ bo->name = NULL;
+ bo->kflags = 0;
+
+ list_addtail(&bo->head, &bucket->head);
+ } else {
+ bo_free(bo);
+ }
+}
+
+void
+iris_bo_unreference(struct iris_bo *bo)
+{
+ if (bo == NULL)
+ return;
+
+ assert(p_atomic_read(&bo->refcount) > 0);
+
+ if (atomic_add_unless(&bo->refcount, -1, 1)) {
+ struct iris_bufmgr *bufmgr = bo->bufmgr;
+ struct timespec time;
+
+ clock_gettime(CLOCK_MONOTONIC, &time);
+
+ mtx_lock(&bufmgr->lock);
+
+ if (p_atomic_dec_zero(&bo->refcount)) {
+ bo_unreference_final(bo, time.tv_sec);
+ cleanup_bo_cache(bufmgr, time.tv_sec);
+ }
+
+ mtx_unlock(&bufmgr->lock);
+ }
+}
+
+static void
+bo_wait_with_stall_warning(struct pipe_debug_callback *dbg,
+ struct iris_bo *bo,
+ const char *action)
+{
+ bool busy = dbg && !bo->idle;
+ double elapsed = unlikely(busy) ? -get_time() : 0.0;
+
+ iris_bo_wait_rendering(bo);
+
+ if (unlikely(busy)) {
+ elapsed += get_time();
+ if (elapsed > 1e-5) /* 0.01ms */ {
+ perf_debug(dbg, "%s a busy \"%s\" BO stalled and took %.03f ms.\n",
+ action, bo->name, elapsed * 1000);
+ }
+ }
+}
+
+static void
+print_flags(unsigned flags)
+{
+ if (flags & MAP_READ)
+ DBG("READ ");
+ if (flags & MAP_WRITE)
+ DBG("WRITE ");
+ if (flags & MAP_ASYNC)
+ DBG("ASYNC ");
+ if (flags & MAP_PERSISTENT)
+ DBG("PERSISTENT ");
+ if (flags & MAP_COHERENT)
+ DBG("COHERENT ");
+ if (flags & MAP_RAW)
+ DBG("RAW ");
+ DBG("\n");
+}
+
+static void *
+iris_bo_map_cpu(struct pipe_debug_callback *dbg,
+ struct iris_bo *bo, unsigned flags)
+{
+ struct iris_bufmgr *bufmgr = bo->bufmgr;
+
+ /* We disallow CPU maps for writing to non-coherent buffers, as the
+ * CPU map can become invalidated when a batch is flushed out, which
+ * can happen at unpredictable times. You should use WC maps instead.
+ */
+ assert(bo->cache_coherent || !(flags & MAP_WRITE));
+
+ if (!bo->map_cpu) {
+ DBG("iris_bo_map_cpu: %d (%s)\n", bo->gem_handle, bo->name);
+
+ struct drm_i915_gem_mmap mmap_arg = {
+ .handle = bo->gem_handle,
+ .size = bo->size,
+ };
+ int ret = drm_ioctl(bufmgr->fd, DRM_IOCTL_I915_GEM_MMAP, &mmap_arg);
+ if (ret != 0) {
+ ret = -errno;
+ DBG("%s:%d: Error mapping buffer %d (%s): %s .\n",
+ __FILE__, __LINE__, bo->gem_handle, bo->name, strerror(errno));
+ return NULL;
+ }
+ void *map = (void *) (uintptr_t) mmap_arg.addr_ptr;
+ VG_DEFINED(map, bo->size);
+
+ if (p_atomic_cmpxchg(&bo->map_cpu, NULL, map)) {
+ VG_NOACCESS(map, bo->size);
+ munmap(map, bo->size);
+ }
+ }
+ assert(bo->map_cpu);
+
+ DBG("iris_bo_map_cpu: %d (%s) -> %p, ", bo->gem_handle, bo->name,
+ bo->map_cpu);
+ print_flags(flags);
+
+ if (!(flags & MAP_ASYNC)) {
+ bo_wait_with_stall_warning(dbg, bo, "CPU mapping");
+ }
+
+ if (!bo->cache_coherent && !bo->bufmgr->has_llc) {
+ /* If we're reusing an existing CPU mapping, the CPU caches may
+ * contain stale data from the last time we read from that mapping.
+ * (With the BO cache, it might even be data from a previous buffer!)
+ * Even if it's a brand new mapping, the kernel may have zeroed the
+ * buffer via CPU writes.
+ *
+ * We need to invalidate those cachelines so that we see the latest
+ * contents, and so long as we only read from the CPU mmap we do not
+ * need to write those cachelines back afterwards.
+ *
+ * On LLC, the emprical evidence suggests that writes from the GPU
+ * that bypass the LLC (i.e. for scanout) do *invalidate* the CPU
+ * cachelines. (Other reads, such as the display engine, bypass the
+ * LLC entirely requiring us to keep dirty pixels for the scanout
+ * out of any cache.)
+ */
+ gen_invalidate_range(bo->map_cpu, bo->size);
+ }
+
+ return bo->map_cpu;
+}
+
+static void *
+iris_bo_map_wc(struct pipe_debug_callback *dbg,
+ struct iris_bo *bo, unsigned flags)
+{
+ struct iris_bufmgr *bufmgr = bo->bufmgr;
+
+ if (!bo->map_wc) {
+ DBG("iris_bo_map_wc: %d (%s)\n", bo->gem_handle, bo->name);
+
+ struct drm_i915_gem_mmap mmap_arg = {
+ .handle = bo->gem_handle,
+ .size = bo->size,
+ .flags = I915_MMAP_WC,
+ };
+ int ret = drm_ioctl(bufmgr->fd, DRM_IOCTL_I915_GEM_MMAP, &mmap_arg);
+ if (ret != 0) {
+ ret = -errno;
+ DBG("%s:%d: Error mapping buffer %d (%s): %s .\n",
+ __FILE__, __LINE__, bo->gem_handle, bo->name, strerror(errno));
+ return NULL;
+ }
+
+ void *map = (void *) (uintptr_t) mmap_arg.addr_ptr;
+ VG_DEFINED(map, bo->size);
+
+ if (p_atomic_cmpxchg(&bo->map_wc, NULL, map)) {
+ VG_NOACCESS(map, bo->size);
+ munmap(map, bo->size);
+ }
+ }
+ assert(bo->map_wc);
+
+ DBG("iris_bo_map_wc: %d (%s) -> %p\n", bo->gem_handle, bo->name, bo->map_wc);
+ print_flags(flags);
+
+ if (!(flags & MAP_ASYNC)) {
+ bo_wait_with_stall_warning(dbg, bo, "WC mapping");
+ }
+
+ return bo->map_wc;
+}
+
+/**
+ * Perform an uncached mapping via the GTT.
+ *
+ * Write access through the GTT is not quite fully coherent. On low power
+ * systems especially, like modern Atoms, we can observe reads from RAM before
+ * the write via GTT has landed. A write memory barrier that flushes the Write
+ * Combining Buffer (i.e. sfence/mfence) is not sufficient to order the later
+ * read after the write as the GTT write suffers a small delay through the GTT
+ * indirection. The kernel uses an uncached mmio read to ensure the GTT write
+ * is ordered with reads (either by the GPU, WB or WC) and unconditionally
+ * flushes prior to execbuf submission. However, if we are not informing the
+ * kernel about our GTT writes, it will not flush before earlier access, such
+ * as when using the cmdparser. Similarly, we need to be careful if we should
+ * ever issue a CPU read immediately following a GTT write.
+ *
+ * Telling the kernel about write access also has one more important
+ * side-effect. Upon receiving notification about the write, it cancels any
+ * scanout buffering for FBC/PSR and friends. Later FBC/PSR is then flushed by
+ * either SW_FINISH or DIRTYFB. The presumption is that we never write to the
+ * actual scanout via a mmaping, only to a backbuffer and so all the FBC/PSR
+ * tracking is handled on the buffer exchange instead.
+ */
+static void *
+iris_bo_map_gtt(struct pipe_debug_callback *dbg,
+ struct iris_bo *bo, unsigned flags)
+{
+ struct iris_bufmgr *bufmgr = bo->bufmgr;
+
+ /* Get a mapping of the buffer if we haven't before. */
+ if (bo->map_gtt == NULL) {
+ DBG("bo_map_gtt: mmap %d (%s)\n", bo->gem_handle, bo->name);
+
+ struct drm_i915_gem_mmap_gtt mmap_arg = { .handle = bo->gem_handle };
+
+ /* Get the fake offset back... */
+ int ret = drm_ioctl(bufmgr->fd, DRM_IOCTL_I915_GEM_MMAP_GTT, &mmap_arg);
+ if (ret != 0) {
+ DBG("%s:%d: Error preparing buffer map %d (%s): %s .\n",
+ __FILE__, __LINE__, bo->gem_handle, bo->name, strerror(errno));
+ return NULL;
+ }
+
+ /* and mmap it. */
+ void *map = mmap(0, bo->size, PROT_READ | PROT_WRITE,
+ MAP_SHARED, bufmgr->fd, mmap_arg.offset);
+ if (map == MAP_FAILED) {
+ DBG("%s:%d: Error mapping buffer %d (%s): %s .\n",
+ __FILE__, __LINE__, bo->gem_handle, bo->name, strerror(errno));
+ return NULL;
+ }
+
+ /* We don't need to use VALGRIND_MALLOCLIKE_BLOCK because Valgrind will
+ * already intercept this mmap call. However, for consistency between
+ * all the mmap paths, we mark the pointer as defined now and mark it
+ * as inaccessible afterwards.
+ */
+ VG_DEFINED(map, bo->size);
+
+ if (p_atomic_cmpxchg(&bo->map_gtt, NULL, map)) {
+ VG_NOACCESS(map, bo->size);
+ munmap(map, bo->size);
+ }
+ }
+ assert(bo->map_gtt);
+
+ DBG("bo_map_gtt: %d (%s) -> %p, ", bo->gem_handle, bo->name, bo->map_gtt);
+ print_flags(flags);
+
+ if (!(flags & MAP_ASYNC)) {
+ bo_wait_with_stall_warning(dbg, bo, "GTT mapping");
+ }
+
+ return bo->map_gtt;
+}
+
+static bool
+can_map_cpu(struct iris_bo *bo, unsigned flags)
+{
+ if (bo->cache_coherent)
+ return true;
+
+ /* Even if the buffer itself is not cache-coherent (such as a scanout), on
+ * an LLC platform reads always are coherent (as they are performed via the
+ * central system agent). It is just the writes that we need to take special
+ * care to ensure that land in main memory and not stick in the CPU cache.
+ */
+ if (!(flags & MAP_WRITE) && bo->bufmgr->has_llc)
+ return true;
+
+ /* If PERSISTENT or COHERENT are set, the mmapping needs to remain valid
+ * across batch flushes where the kernel will change cache domains of the
+ * bo, invalidating continued access to the CPU mmap on non-LLC device.
+ *
+ * Similarly, ASYNC typically means that the buffer will be accessed via
+ * both the CPU and the GPU simultaneously. Batches may be executed that
+ * use the BO even while it is mapped. While OpenGL technically disallows
+ * most drawing while non-persistent mappings are active, we may still use
+ * the GPU for blits or other operations, causing batches to happen at
+ * inconvenient times.
+ */
+ if (flags & (MAP_PERSISTENT | MAP_COHERENT | MAP_ASYNC))
+ return false;
+
+ return !(flags & MAP_WRITE);
+}
+
+void *
+iris_bo_map(struct pipe_debug_callback *dbg,
+ struct iris_bo *bo, unsigned flags)
+{
+ if (bo->tiling_mode != I915_TILING_NONE && !(flags & MAP_RAW))
+ return iris_bo_map_gtt(dbg, bo, flags);
+
+ void *map;
+
+ if (can_map_cpu(bo, flags))
+ map = iris_bo_map_cpu(dbg, bo, flags);
+ else
+ map = iris_bo_map_wc(dbg, bo, flags);
+
+ /* Allow the attempt to fail by falling back to the GTT where necessary.
+ *
+ * Not every buffer can be mmaped directly using the CPU (or WC), for
+ * example buffers that wrap stolen memory or are imported from other
+ * devices. For those, we have little choice but to use a GTT mmapping.
+ * However, if we use a slow GTT mmapping for reads where we expected fast
+ * access, that order of magnitude difference in throughput will be clearly
+ * expressed by angry users.
+ *
+ * We skip MAP_RAW because we want to avoid map_gtt's fence detiling.
+ */
+ if (!map && !(flags & MAP_RAW)) {
+ perf_debug(dbg, "Fallback GTT mapping for %s with access flags %x\n",
+ bo->name, flags);
+ map = iris_bo_map_gtt(dbg, bo, flags);
+ }
+
+ return map;
+}
+
+int
+iris_bo_subdata(struct iris_bo *bo, uint64_t offset,
+ uint64_t size, const void *data)
+{
+ struct iris_bufmgr *bufmgr = bo->bufmgr;
+
+ struct drm_i915_gem_pwrite pwrite = {
+ .handle = bo->gem_handle,
+ .offset = offset,
+ .size = size,
+ .data_ptr = (uint64_t) (uintptr_t) data,
+ };
+
+ int ret = drm_ioctl(bufmgr->fd, DRM_IOCTL_I915_GEM_PWRITE, &pwrite);
+ if (ret != 0) {
+ ret = -errno;
+ DBG("%s:%d: Error writing data to buffer %d: "
+ "(%"PRIu64" %"PRIu64") %s .\n",
+ __FILE__, __LINE__, bo->gem_handle, offset, size, strerror(errno));
+ }
+
+ return ret;
+}
+
+/** Waits for all GPU rendering with the object to have completed. */
+void
+iris_bo_wait_rendering(struct iris_bo *bo)
+{
+ /* We require a kernel recent enough for WAIT_IOCTL support.
+ * See intel_init_bufmgr()
+ */
+ iris_bo_wait(bo, -1);
+}
+
+/**
+ * Waits on a BO for the given amount of time.
+ *
+ * @bo: buffer object to wait for
+ * @timeout_ns: amount of time to wait in nanoseconds.
+ * If value is less than 0, an infinite wait will occur.
+ *
+ * Returns 0 if the wait was successful ie. the last batch referencing the
+ * object has completed within the allotted time. Otherwise some negative return
+ * value describes the error. Of particular interest is -ETIME when the wait has
+ * failed to yield the desired result.
+ *
+ * Similar to iris_bo_wait_rendering except a timeout parameter allows
+ * the operation to give up after a certain amount of time. Another subtle
+ * difference is the internal locking semantics are different (this variant does
+ * not hold the lock for the duration of the wait). This makes the wait subject
+ * to a larger userspace race window.
+ *
+ * The implementation shall wait until the object is no longer actively
+ * referenced within a batch buffer at the time of the call. The wait will
+ * not guarantee that the buffer is re-issued via another thread, or an flinked
+ * handle. Userspace must make sure this race does not occur if such precision
+ * is important.
+ *
+ * Note that some kernels have broken the inifite wait for negative values
+ * promise, upgrade to latest stable kernels if this is the case.
+ */
+int
+iris_bo_wait(struct iris_bo *bo, int64_t timeout_ns)
+{
+ struct iris_bufmgr *bufmgr = bo->bufmgr;
+
+ /* If we know it's idle, don't bother with the kernel round trip */
+ if (bo->idle && !bo->external)
+ return 0;
+
+ struct drm_i915_gem_wait wait = {
+ .bo_handle = bo->gem_handle,
+ .timeout_ns = timeout_ns,
+ };
+ int ret = drm_ioctl(bufmgr->fd, DRM_IOCTL_I915_GEM_WAIT, &wait);
+ if (ret == -1)
+ return -errno;
+
+ bo->idle = true;
+
+ return ret;
+}
+
+void
+iris_bufmgr_destroy(struct iris_bufmgr *bufmgr)
+{
+ mtx_destroy(&bufmgr->lock);
+
+ /* Free any cached buffer objects we were going to reuse */
+ for (int i = 0; i < bufmgr->num_buckets; i++) {
+ struct bo_cache_bucket *bucket = &bufmgr->cache_bucket[i];
+
+ list_for_each_entry_safe(struct iris_bo, bo, &bucket->head, head) {
+ list_del(&bo->head);
+
+ bo_free(bo);
+ }
+ }
+
+ _mesa_hash_table_destroy(bufmgr->name_table, NULL);
+ _mesa_hash_table_destroy(bufmgr->handle_table, NULL);
+
+ free(bufmgr);
+}
+
+static int
+bo_set_tiling_internal(struct iris_bo *bo, uint32_t tiling_mode,
+ uint32_t stride)
+{
+ struct iris_bufmgr *bufmgr = bo->bufmgr;
+ struct drm_i915_gem_set_tiling set_tiling;
+ int ret;
+
+ if (bo->global_name == 0 &&
+ tiling_mode == bo->tiling_mode && stride == bo->stride)
+ return 0;
+
+ memset(&set_tiling, 0, sizeof(set_tiling));
+ do {
+ /* set_tiling is slightly broken and overwrites the
+ * input on the error path, so we have to open code
+ * drm_ioctl.
+ */
+ set_tiling.handle = bo->gem_handle;
+ set_tiling.tiling_mode = tiling_mode;
+ set_tiling.stride = stride;
+
+ ret = ioctl(bufmgr->fd, DRM_IOCTL_I915_GEM_SET_TILING, &set_tiling);
+ } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
+ if (ret == -1)
+ return -errno;
+
+ bo->tiling_mode = set_tiling.tiling_mode;
+ bo->swizzle_mode = set_tiling.swizzle_mode;
+ bo->stride = set_tiling.stride;
+ return 0;
+}
+
+int
+iris_bo_get_tiling(struct iris_bo *bo, uint32_t *tiling_mode,
+ uint32_t *swizzle_mode)
+{
+ *tiling_mode = bo->tiling_mode;
+ *swizzle_mode = bo->swizzle_mode;
+ return 0;
+}
+
+struct iris_bo *
+iris_bo_import_dmabuf(struct iris_bufmgr *bufmgr, int prime_fd)
+{
+ uint32_t handle;
+ struct iris_bo *bo;
+
+ mtx_lock(&bufmgr->lock);
+ int ret = drmPrimeFDToHandle(bufmgr->fd, prime_fd, &handle);
+ if (ret) {
+ DBG("import_dmabuf: failed to obtain handle from fd: %s\n",
+ strerror(errno));
+ mtx_unlock(&bufmgr->lock);
+ return NULL;
+ }
+
+ /*
+ * See if the kernel has already returned this buffer to us. Just as
+ * for named buffers, we must not create two bo's pointing at the same
+ * kernel object
+ */
+ bo = hash_find_bo(bufmgr->handle_table, handle);
+ if (bo) {
+ iris_bo_reference(bo);
+ goto out;
+ }
+
+ bo = calloc(1, sizeof(*bo));
+ if (!bo)
+ goto out;
+
+ p_atomic_set(&bo->refcount, 1);
+
+ /* Determine size of bo. The fd-to-handle ioctl really should
+ * return the size, but it doesn't. If we have kernel 3.12 or
+ * later, we can lseek on the prime fd to get the size. Older
+ * kernels will just fail, in which case we fall back to the
+ * provided (estimated or guess size). */
+ ret = lseek(prime_fd, 0, SEEK_END);
+ if (ret != -1)
+ bo->size = ret;
+
+ bo->bufmgr = bufmgr;
+
+ bo->gem_handle = handle;
+ _mesa_hash_table_insert(bufmgr->handle_table, &bo->gem_handle, bo);
+
+ bo->name = "prime";
+ bo->reusable = false;
+ bo->external = true;
+
+ struct drm_i915_gem_get_tiling get_tiling = { .handle = bo->gem_handle };
+ if (drm_ioctl(bufmgr->fd, DRM_IOCTL_I915_GEM_GET_TILING, &get_tiling))
+ goto err;
+
+ bo->tiling_mode = get_tiling.tiling_mode;
+ bo->swizzle_mode = get_tiling.swizzle_mode;
+ /* XXX stride is unknown */
+
+out:
+ mtx_unlock(&bufmgr->lock);
+ return bo;
+
+err:
+ bo_free(bo);
+ mtx_unlock(&bufmgr->lock);
+ return NULL;
+}
+
+static void
+iris_bo_make_external(struct iris_bo *bo)
+{
+ struct iris_bufmgr *bufmgr = bo->bufmgr;
+
+ if (!bo->external) {
+ mtx_lock(&bufmgr->lock);
+ if (!bo->external) {
+ _mesa_hash_table_insert(bufmgr->handle_table, &bo->gem_handle, bo);
+ bo->external = true;
+ }
+ mtx_unlock(&bufmgr->lock);
+ }
+}
+
+int
+iris_bo_export_dmabuf(struct iris_bo *bo, int *prime_fd)
+{
+ struct iris_bufmgr *bufmgr = bo->bufmgr;
+
+ iris_bo_make_external(bo);
+
+ if (drmPrimeHandleToFD(bufmgr->fd, bo->gem_handle,
+ DRM_CLOEXEC, prime_fd) != 0)
+ return -errno;
+
+ bo->reusable = false;
+
+ return 0;
+}
+
+uint32_t
+iris_bo_export_gem_handle(struct iris_bo *bo)
+{
+ iris_bo_make_external(bo);
+
+ return bo->gem_handle;
+}
+
+int
+iris_bo_flink(struct iris_bo *bo, uint32_t *name)
+{
+ struct iris_bufmgr *bufmgr = bo->bufmgr;
+
+ if (!bo->global_name) {
+ struct drm_gem_flink flink = { .handle = bo->gem_handle };
+
+ if (drm_ioctl(bufmgr->fd, DRM_IOCTL_GEM_FLINK, &flink))
+ return -errno;
+
+ iris_bo_make_external(bo);
+ mtx_lock(&bufmgr->lock);
+ if (!bo->global_name) {
+ bo->global_name = flink.name;
+ _mesa_hash_table_insert(bufmgr->name_table, &bo->global_name, bo);
+ }
+ mtx_unlock(&bufmgr->lock);
+
+ bo->reusable = false;
+ }
+
+ *name = bo->global_name;
+ return 0;
+}
+
+/**
+ * Enables unlimited caching of buffer objects for reuse.
+ *
+ * This is potentially very memory expensive, as the cache at each bucket
+ * size is only bounded by how many buffers of that size we've managed to have
+ * in flight at once.
+ */
+void
+iris_bufmgr_enable_reuse(struct iris_bufmgr *bufmgr)
+{
+ bufmgr->bo_reuse = true;
+}
+
+static void
+add_bucket(struct iris_bufmgr *bufmgr, int size)
+{
+ unsigned int i = bufmgr->num_buckets;
+
+ assert(i < ARRAY_SIZE(bufmgr->cache_bucket));
+
+ list_inithead(&bufmgr->cache_bucket[i].head);
+ bufmgr->cache_bucket[i].size = size;
+ bufmgr->num_buckets++;
+
+ assert(bucket_for_size(bufmgr, size) == &bufmgr->cache_bucket[i]);
+ assert(bucket_for_size(bufmgr, size - 2048) == &bufmgr->cache_bucket[i]);
+ assert(bucket_for_size(bufmgr, size + 1) != &bufmgr->cache_bucket[i]);
+}
+
+static void
+init_cache_buckets(struct iris_bufmgr *bufmgr)
+{
+ uint64_t size, cache_max_size = 64 * 1024 * 1024;
+
+ /* OK, so power of two buckets was too wasteful of memory.
+ * Give 3 other sizes between each power of two, to hopefully
+ * cover things accurately enough. (The alternative is
+ * probably to just go for exact matching of sizes, and assume
+ * that for things like composited window resize the tiled
+ * width/height alignment and rounding of sizes to pages will
+ * get us useful cache hit rates anyway)
+ */
+ add_bucket(bufmgr, 4096);
+ add_bucket(bufmgr, 4096 * 2);
+ add_bucket(bufmgr, 4096 * 3);
+
+ /* Initialize the linked lists for BO reuse cache. */
+ for (size = 4 * 4096; size <= cache_max_size; size *= 2) {
+ add_bucket(bufmgr, size);
+
+ add_bucket(bufmgr, size + size * 1 / 4);
+ add_bucket(bufmgr, size + size * 2 / 4);
+ add_bucket(bufmgr, size + size * 3 / 4);
+ }
+}
+
+uint32_t
+iris_create_hw_context(struct iris_bufmgr *bufmgr)
+{
+ struct drm_i915_gem_context_create create = { };
+ int ret = drm_ioctl(bufmgr->fd, DRM_IOCTL_I915_GEM_CONTEXT_CREATE, &create);
+ if (ret != 0) {
+ DBG("DRM_IOCTL_I915_GEM_CONTEXT_CREATE failed: %s\n", strerror(errno));
+ return 0;
+ }
+
+ return create.ctx_id;
+}
+
+int
+iris_hw_context_set_priority(struct iris_bufmgr *bufmgr,
+ uint32_t ctx_id,
+ int priority)
+{
+ struct drm_i915_gem_context_param p = {
+ .ctx_id = ctx_id,
+ .param = I915_CONTEXT_PARAM_PRIORITY,
+ .value = priority,
+ };
+ int err;
+
+ err = 0;
+ if (drm_ioctl(bufmgr->fd, DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM, &p))
+ err = -errno;
+
+ return err;
+}
+
+void
+iris_destroy_hw_context(struct iris_bufmgr *bufmgr, uint32_t ctx_id)
+{
+ struct drm_i915_gem_context_destroy d = { .ctx_id = ctx_id };
+
+ if (ctx_id != 0 &&
+ drm_ioctl(bufmgr->fd, DRM_IOCTL_I915_GEM_CONTEXT_DESTROY, &d) != 0) {
+ fprintf(stderr, "DRM_IOCTL_I915_GEM_CONTEXT_DESTROY failed: %s\n",
+ strerror(errno));
+ }
+}
+
+int
+iris_reg_read(struct iris_bufmgr *bufmgr, uint32_t offset, uint64_t *result)
+{
+ struct drm_i915_reg_read reg_read = { .offset = offset };
+ int ret = drm_ioctl(bufmgr->fd, DRM_IOCTL_I915_REG_READ, &reg_read);
+
+ *result = reg_read.val;
+ return ret;
+}
+
+/**
+ * Initializes the GEM buffer manager, which uses the kernel to allocate, map,
+ * and manage map buffer objections.
+ *
+ * \param fd File descriptor of the opened DRM device.
+ */
+struct iris_bufmgr *
+iris_bufmgr_init(struct gen_device_info *devinfo, int fd)
+{
+ struct iris_bufmgr *bufmgr = calloc(1, sizeof(*bufmgr));
+ if (bufmgr == NULL)
+ return NULL;
+
+ /* Handles to buffer objects belong to the device fd and are not
+ * reference counted by the kernel. If the same fd is used by
+ * multiple parties (threads sharing the same screen bufmgr, or
+ * even worse the same device fd passed to multiple libraries)
+ * ownership of those handles is shared by those independent parties.
+ *
+ * Don't do this! Ensure that each library/bufmgr has its own device
+ * fd so that its namespace does not clash with another.
+ */
+ bufmgr->fd = fd;
+
+ if (mtx_init(&bufmgr->lock, mtx_plain) != 0) {
+ free(bufmgr);
+ return NULL;
+ }
+
+ bufmgr->has_llc = devinfo->has_llc;
+
+ init_cache_buckets(bufmgr);
+
+ bufmgr->name_table =
+ _mesa_hash_table_create(NULL, key_hash_uint, key_uint_equal);
+ bufmgr->handle_table =
+ _mesa_hash_table_create(NULL, key_hash_uint, key_uint_equal);
+
+ return bufmgr;
+}
diff --git a/src/gallium/drivers/iris/iris_bufmgr.h b/src/gallium/drivers/iris/iris_bufmgr.h
new file mode 100644
index 00000000000..13b877669a0
--- /dev/null
+++ b/src/gallium/drivers/iris/iris_bufmgr.h
@@ -0,0 +1,308 @@
+/*
+ * Copyright © 2017 Intel Corporation
+ *
+ * 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 (including the next
+ * paragraph) 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.
+ */
+
+#ifndef IRIS_BUFMGR_H
+#define IRIS_BUFMGR_H
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include "util/macros.h"
+#include "util/u_atomic.h"
+#include "util/list.h"
+
+struct gen_device_info;
+struct pipe_debug_callback;
+
+struct iris_bo {
+ /**
+ * Size in bytes of the buffer object.
+ *
+ * The size may be larger than the size originally requested for the
+ * allocation, such as being aligned to page size.
+ */
+ uint64_t size;
+
+ /**
+ * Alignment requirement for object
+ *
+ * Used for GTT mapping & pinning the object.
+ */
+ uint64_t align;
+
+ /** Buffer manager context associated with this buffer object */
+ struct iris_bufmgr *bufmgr;
+
+ /** The GEM handle for this buffer object. */
+ uint32_t gem_handle;
+
+ /**
+ * Offset of the buffer inside the Graphics Translation Table.
+ *
+ * This is effectively our GPU address for the buffer and we use it
+ * as our base for all state pointers into the buffer. However, since the
+ * kernel may be forced to move it around during the course of the
+ * buffer's lifetime, we can only know where the buffer was on the last
+ * execbuf. We presume, and are usually right, that the buffer will not
+ * move and so we use that last offset for the next batch and by doing
+ * so we can avoid having the kernel perform a relocation fixup pass as
+ * our pointers inside the batch will be using the correct base offset.
+ *
+ * Since we do use it as a base address for the next batch of pointers,
+ * the kernel treats our offset as a request, and if possible will
+ * arrange the buffer to placed at that address (trying to balance
+ * the cost of buffer migration versus the cost of performing
+ * relocations). Furthermore, we can force the kernel to place the buffer,
+ * or report a failure if we specified a conflicting offset, at our chosen
+ * offset by specifying EXEC_OBJECT_PINNED.
+ *
+ * Note the GTT may be either per context, or shared globally across the
+ * system. On a shared system, our buffers have to contend for address
+ * space with both aperture mappings and framebuffers and so are more
+ * likely to be moved. On a full ppGTT system, each batch exists in its
+ * own GTT, and so each buffer may have their own offset within each
+ * context.
+ */
+ uint64_t gtt_offset;
+
+ /**
+ * The validation list index for this buffer, or -1 when not in a batch.
+ * Note that a single buffer may be in multiple batches (contexts), and
+ * this is a global field, which refers to the last batch using the BO.
+ * It should not be considered authoritative, but can be used to avoid a
+ * linear walk of the validation list in the common case by guessing that
+ * exec_bos[bo->index] == bo and confirming whether that's the case.
+ */
+ unsigned index;
+
+ /**
+ * Boolean of whether the GPU is definitely not accessing the buffer.
+ *
+ * This is only valid when reusable, since non-reusable
+ * buffers are those that have been shared with other
+ * processes, so we don't know their state.
+ */
+ bool idle;
+
+ int refcount;
+ const char *name;
+
+ uint64_t kflags;
+
+ /**
+ * Kenel-assigned global name for this object
+ *
+ * List contains both flink named and prime fd'd objects
+ */
+ unsigned global_name;
+
+ /**
+ * Current tiling mode
+ */
+ uint32_t tiling_mode;
+ uint32_t swizzle_mode;
+ uint32_t stride;
+
+ time_t free_time;
+
+ /** Mapped address for the buffer, saved across map/unmap cycles */
+ void *map_cpu;
+ /** GTT virtual address for the buffer, saved across map/unmap cycles */
+ void *map_gtt;
+ /** WC CPU address for the buffer, saved across map/unmap cycles */
+ void *map_wc;
+
+ /** BO cache list */
+ struct list_head head;
+
+ /**
+ * Boolean of whether this buffer can be re-used
+ */
+ bool reusable;
+
+ /**
+ * Boolean of whether this buffer has been shared with an external client.
+ */
+ bool external;
+
+ /**
+ * Boolean of whether this buffer is cache coherent
+ */
+ bool cache_coherent;
+};
+
+#define BO_ALLOC_BUSY (1<<0)
+#define BO_ALLOC_ZEROED (1<<1)
+
+/**
+ * Allocate a buffer object.
+ *
+ * Buffer objects are not necessarily initially mapped into CPU virtual
+ * address space or graphics device aperture. They must be mapped
+ * using iris_bo_map() to be used by the CPU.
+ */
+struct iris_bo *iris_bo_alloc(struct iris_bufmgr *bufmgr, const char *name,
+ uint64_t size, uint64_t alignment);
+
+/**
+ * Allocate a tiled buffer object.
+ *
+ * Alignment for tiled objects is set automatically; the 'flags'
+ * argument provides a hint about how the object will be used initially.
+ *
+ * Valid tiling formats are:
+ * I915_TILING_NONE
+ * I915_TILING_X
+ * I915_TILING_Y
+ */
+struct iris_bo *iris_bo_alloc_tiled(struct iris_bufmgr *bufmgr,
+ const char *name,
+ uint64_t size,
+ uint32_t tiling_mode,
+ uint32_t pitch,
+ unsigned flags);
+
+/** Takes a reference on a buffer object */
+static inline void
+iris_bo_reference(struct iris_bo *bo)
+{
+ p_atomic_inc(&bo->refcount);
+}
+
+/**
+ * Releases a reference on a buffer object, freeing the data if
+ * no references remain.
+ */
+void iris_bo_unreference(struct iris_bo *bo);
+
+#define MAP_READ 0x01
+#define MAP_WRITE 0x02
+#define MAP_ASYNC 0x20
+#define MAP_PERSISTENT 0x40
+#define MAP_COHERENT 0x80
+/* internal */
+#define MAP_INTERNAL_MASK (0xff << 24)
+#define MAP_RAW (0x01 << 24)
+
+/**
+ * Maps the buffer into userspace.
+ *
+ * This function will block waiting for any existing execution on the
+ * buffer to complete, first. The resulting mapping is returned.
+ */
+MUST_CHECK void *iris_bo_map(struct pipe_debug_callback *dbg,
+ struct iris_bo *bo, unsigned flags);
+
+/**
+ * Reduces the refcount on the userspace mapping of the buffer
+ * object.
+ */
+static inline int iris_bo_unmap(struct iris_bo *bo) { return 0; }
+
+/** Write data into an object. */
+int iris_bo_subdata(struct iris_bo *bo, uint64_t offset,
+ uint64_t size, const void *data);
+/**
+ * Waits for rendering to an object by the GPU to have completed.
+ *
+ * This is not required for any access to the BO by bo_map,
+ * bo_subdata, etc. It is merely a way for the driver to implement
+ * glFinish.
+ */
+void iris_bo_wait_rendering(struct iris_bo *bo);
+
+/**
+ * Tears down the buffer manager instance.
+ */
+void iris_bufmgr_destroy(struct iris_bufmgr *bufmgr);
+
+/**
+ * Get the current tiling (and resulting swizzling) mode for the bo.
+ *
+ * \param buf Buffer to get tiling mode for
+ * \param tiling_mode returned tiling mode
+ * \param swizzle_mode returned swizzling mode
+ */
+int iris_bo_get_tiling(struct iris_bo *bo, uint32_t *tiling_mode,
+ uint32_t *swizzle_mode);
+
+/**
+ * Create a visible name for a buffer which can be used by other apps
+ *
+ * \param buf Buffer to create a name for
+ * \param name Returned name
+ */
+int iris_bo_flink(struct iris_bo *bo, uint32_t *name);
+
+/**
+ * Returns 1 if mapping the buffer for write could cause the process
+ * to block, due to the object being active in the GPU.
+ */
+int iris_bo_busy(struct iris_bo *bo);
+
+/**
+ * Specify the volatility of the buffer.
+ * \param bo Buffer to create a name for
+ * \param madv The purgeable status
+ *
+ * Use I915_MADV_DONTNEED to mark the buffer as purgeable, and it will be
+ * reclaimed under memory pressure. If you subsequently require the buffer,
+ * then you must pass I915_MADV_WILLNEED to mark the buffer as required.
+ *
+ * Returns 1 if the buffer was retained, or 0 if it was discarded whilst
+ * marked as I915_MADV_DONTNEED.
+ */
+int iris_bo_madvise(struct iris_bo *bo, int madv);
+
+/* drm_bacon_bufmgr_gem.c */
+struct iris_bufmgr *iris_bufmgr_init(struct gen_device_info *devinfo, int fd);
+struct iris_bo *iris_bo_gem_create_from_name(struct iris_bufmgr *bufmgr,
+ const char *name,
+ unsigned handle);
+void iris_bufmgr_enable_reuse(struct iris_bufmgr *bufmgr);
+
+int iris_bo_wait(struct iris_bo *bo, int64_t timeout_ns);
+
+uint32_t iris_create_hw_context(struct iris_bufmgr *bufmgr);
+
+#define IRIS_CONTEXT_LOW_PRIORITY ((I915_CONTEXT_MIN_USER_PRIORITY-1)/2)
+#define IRIS_CONTEXT_MEDIUM_PRIORITY (I915_CONTEXT_DEFAULT_PRIORITY)
+#define IRIS_CONTEXT_HIGH_PRIORITY ((I915_CONTEXT_MAX_USER_PRIORITY+1)/2)
+
+int iris_hw_context_set_priority(struct iris_bufmgr *bufmgr,
+ uint32_t ctx_id, int priority);
+
+void iris_destroy_hw_context(struct iris_bufmgr *bufmgr, uint32_t ctx_id);
+
+int iris_bo_export_dmabuf(struct iris_bo *bo, int *prime_fd);
+struct iris_bo *iris_bo_import_dmabuf(struct iris_bufmgr *bufmgr, int prime_fd);
+
+uint32_t iris_bo_export_gem_handle(struct iris_bo *bo);
+
+int iris_reg_read(struct iris_bufmgr *bufmgr, uint32_t offset, uint64_t *out);
+
+int drm_ioctl(int fd, unsigned long request, void *arg);
+
+
+#endif /* IRIS_BUFMGR_H */
diff --git a/src/gallium/drivers/iris/iris_context.h b/src/gallium/drivers/iris/iris_context.h
new file mode 100644
index 00000000000..49d199fbd67
--- /dev/null
+++ b/src/gallium/drivers/iris/iris_context.h
@@ -0,0 +1,78 @@
+/*
+ * Copyright © 2017 Intel Corporation
+ *
+ * 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
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, 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 (including the next
+ * paragraph) 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 NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHOR(S) AND/OR THEIR SUPPLIERS 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.
+ */
+#ifndef IRIS_CONTEXT_H
+#define IRIS_CONTEXT_H
+
+#include "pipe/p_context.h"
+#include "pipe/p_state.h"
+#include "util/u_debug.h"
+#include "intel/common/gen_debug.h"
+#include "iris_screen.h"
+
+struct iris_bo;
+
+#define IRIS_MAX_TEXTURE_SAMPLERS 32
+#define IRIS_MAX_VIEWPORTS 16
+
+enum iris_dirty {
+ IRIS_DIRTY_COLOR_CALC_STATE,
+ IRIS_DIRTY_POLYGON_STIPPLE,
+ IRIS_DIRTY_SCISSOR_RECT,
+ IRIS_DIRTY_WM_DEPTH_STENCIL,
+};
+
+#define IRIS_NEW_COLOR_CALC_STATE (1ull << IRIS_DIRTY_COLOR_CALC_STATE)
+#define IRIS_NEW_POLYGON_STIPPLE (1ull << IRIS_DIRTY_POLYGON_STIPPLE)
+#define IRIS_NEW_SCISSOR_RECT (1ull << IRIS_DIRTY_SCISSOR_RECT)
+#define IRIS_NEW_WM_DEPTH_STENCIL (1ull << IRIS_DIRTY_WM_DEPTH_STENCIL)
+
+struct iris_context {
+ struct pipe_context ctx;
+
+ struct pipe_debug_callback dbg;
+
+ struct {
+ uint64_t dirty;
+ struct pipe_blend_color blend_color;
+ struct pipe_poly_stipple poly_stipple;
+ struct pipe_scissor_state scissors[IRIS_MAX_VIEWPORTS];
+ struct pipe_stencil_ref stencil_ref;
+ } state;
+};
+
+#define perf_debug(dbg, ...) do { \
+ if (INTEL_DEBUG & DEBUG_PERF) \
+ dbg_printf(__VA_ARGS__); \
+ if (unlikely(dbg)) \
+ pipe_debug_message(dbg, PERF_INFO, __VA_ARGS__); \
+} while(0)
+
+double get_time(void);
+
+struct pipe_context *
+iris_create_context(struct pipe_screen *screen, void *priv, unsigned flags);
+
+void iris_init_program_functions(struct pipe_context *ctx);
+void iris_init_state_functions(struct pipe_context *ctx);
+
+#endif
diff --git a/src/gallium/drivers/iris/iris_draw.c b/src/gallium/drivers/iris/iris_draw.c
new file mode 100644
index 00000000000..b2472dd3a2c
--- /dev/null
+++ b/src/gallium/drivers/iris/iris_draw.c
@@ -0,0 +1,178 @@
+/*
+ * Copyright © 2017 Intel Corporation
+ *
+ * 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
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, 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 (including the next
+ * paragraph) 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 NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHOR(S) AND/OR THEIR SUPPLIERS 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.
+ */
+#include <stdio.h>
+#include <errno.h>
+#include "pipe/p_defines.h"
+#include "pipe/p_state.h"
+#include "pipe/p_context.h"
+#include "pipe/p_screen.h"
+#include "util/u_inlines.h"
+#include "util/u_transfer.h"
+#include "intel/compiler/brw_compiler.h"
+#include "iris_context.h"
+
+#define __gen_address_type unsigned
+#define __gen_user_data void
+
+static uint64_t
+__gen_combine_address(void *user_data, void *location,
+ unsigned address, uint32_t delta)
+{
+ return delta;
+}
+
+#define __genxml_cmd_length(cmd) cmd ## _length
+#define __genxml_cmd_length_bias(cmd) cmd ## _length_bias
+#define __genxml_cmd_header(cmd) cmd ## _header
+#define __genxml_cmd_pack(cmd) cmd ## _pack
+
+#define iris_pack_command(cmd, dst, name) \
+ for (struct cmd name = { __genxml_cmd_header(cmd) }, \
+ *_dst = (void *)(dst); __builtin_expect(_dst != NULL, 1); \
+ __genxml_cmd_pack(cmd)(NULL, (void *)dst, &name), \
+ _dst = NULL)
+
+#define iris_pack_state(cmd, dst, name) \
+ for (struct cmd name = {}, \
+ *_dst = (void *)(dst); __builtin_expect(_dst != NULL, 1); \
+ __genxml_cmd_pack(cmd)(NULL, (void *)_dst, &name), \
+ _dst = NULL)
+
+#include "genxml/genX_pack.h"
+#include "genxml/gen_macros.h"
+
+static void
+iris_draw_vbo(struct pipe_context *ctx, const struct pipe_draw_info *info)
+{
+#if 0
+ l3 configuration
+
+ 3DSTATE_VIEWPORT_STATE_POINTERS_CC - CC_VIEWPORT
+ -> from iris_depth_stencil_alpha_state
+
+ 3DSTATE_VIEWPORT_STATE_POINTERS_SF_CL - SF_CLIP_VIEWPORT
+ -> pipe_viewport_state for matrix elements, guardband is calculated
+ from those. can calculate screen space from matrix apparently...
+
+ 3DSTATE_SCISSOR_STATE_POINTERS - SCISSOR_RECT
+ -> from ice->state.scissors
+
+ 3DSTATE_PUSH_CONSTANT_ALLOC_*
+ 3DSTATE_URB_*
+ -> TODO
+
+ 3DSTATE_PS_BLEND
+ 3DSTATE_BLEND_STATE_POINTERS - BLEND_STATE
+ -> from iris_blend_state (most) + iris_depth_stencil_alpha_state
+ (alpha test function/enable) + has writeable RT from ???????
+
+ 3DSTATE_CC_STATE_POINTERS - COLOR_CALC_STATE
+ -> from ice->state.blend_color + iris_depth_stencil_alpha_state
+ (ref_value)
+
+ 3DSTATE_CONSTANT_* - push constants
+ -> TODO
+
+ Surfaces:
+ - pull constants
+ - ubos/ssbos/abos
+ - images
+ - textures
+ - render targets - write and read
+ 3DSTATE_BINDING_TABLE_POINTERS_*
+ -> TODO
+
+ 3DSTATE_SAMPLER_STATE_POINTERS_*
+ -> TODO
+
+ 3DSTATE_MULTISAMPLE
+ 3DSTATE_SAMPLE_MASK
+
+ 3DSTATE_VS
+ 3DSTATE_HS
+ 3DSTATE_TE
+ 3DSTATE_DS
+ 3DSTATE_GS
+ 3DSTATE_PS_EXTRA
+ 3DSTATE_PS
+ 3DSTATE_STREAMOUT
+ 3DSTATE_SO_BUFFER
+ 3DSTATE_SO_DECL_LIST
+
+ 3DSTATE_CLIP
+ -> iris_raster_state + ??? (Non-perspective Bary, ForceZeroRTAIndex)
+
+ 3DSTATE_RASTER
+ 3DSTATE_SF
+ -> iris_raster_state
+
+ 3DSTATE_WM
+ -> iris_raster_state + FS state (barycentric, EDSC)
+ 3DSTATE_SBE
+ -> iris_raster_state (point sprite texture coordinate origin)
+ -> bunch of shader state...
+ 3DSTATE_SBE_SWIZ
+ -> FS state
+
+ 3DSTATE_DEPTH_BUFFER
+ 3DSTATE_HIER_DEPTH_BUFFER
+ 3DSTATE_STENCIL_BUFFER
+ 3DSTATE_CLEAR_PARAMS
+ -> iris_framebuffer_state?
+
+ 3DSTATE_VF_TOPOLOGY
+ -> pipe_draw_info (prim_mode)
+ 3DSTATE_VF
+ -> pipe_draw_info (restart_index, primitive_restart)
+
+ 3DSTATE_INDEX_BUFFER
+ -> pipe_draw_info (index)
+ 3DSTATE_VERTEX_BUFFERS
+ -> pipe_vertex_buffer (set_vertex_buffer hook)
+ 3DSTATE_VERTEX_ELEMENTS
+ -> iris_vertex_element
+ 3DSTATE_VF_INSTANCING
+ -> iris_vertex_element
+ 3DSTATE_VF_SGVS
+ -> TODO ???
+ 3DSTATE_VF_COMPONENT_PACKING
+ -> TODO ???
+
+ 3DPRIMITIVE
+ -> pipe_draw_info
+
+ rare:
+ 3DSTATE_POLY_STIPPLE_OFFSET
+ 3DSTATE_POLY_STIPPLE_PATTERN
+ -> ice->state.poly_stipple
+ 3DSTATE_LINE_STIPPLE
+ -> iris_raster_state
+
+ once:
+ 3DSTATE_AA_LINE_PARAMETERS
+ 3DSTATE_WM_CHROMAKEY
+ 3DSTATE_SAMPLE_PATTERN
+ 3DSTATE_DRAWING_RECTANGLE
+ 3DSTATE_WM_HZ_OP
+#endif
+}
diff --git a/src/gallium/drivers/iris/iris_formats.c b/src/gallium/drivers/iris/iris_formats.c
new file mode 100644
index 00000000000..54a638a45f3
--- /dev/null
+++ b/src/gallium/drivers/iris/iris_formats.c
@@ -0,0 +1,474 @@
+/*
+ * Copyright © 2017 Intel Corporation
+ *
+ * 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 (including the next
+ * paragraph) 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.
+ */
+
+#include "util/u_format.h"
+#include "util/macros.h"
+
+#include "iris_resource.h"
+#include "iris_screen.h"
+
+enum isl_format
+iris_isl_format_for_pipe_format(enum pipe_format pf)
+{
+ static const enum isl_format table[PIPE_FORMAT_COUNT] = {
+ [0 ... PIPE_FORMAT_COUNT-1] = ISL_FORMAT_UNSUPPORTED,
+
+ [PIPE_FORMAT_B8G8R8A8_UNORM] = ISL_FORMAT_B8G8R8A8_UNORM,
+ [PIPE_FORMAT_B8G8R8X8_UNORM] = ISL_FORMAT_B8G8R8X8_UNORM,
+ //[PIPE_FORMAT_A8R8G8B8_UNORM] = ISL_FORMAT_A8R8G8B8_UNORM,
+ //[PIPE_FORMAT_X8R8G8B8_UNORM] = ISL_FORMAT_X8R8G8B8_UNORM,
+ [PIPE_FORMAT_B5G5R5A1_UNORM] = ISL_FORMAT_B5G5R5A1_UNORM,
+ [PIPE_FORMAT_B4G4R4A4_UNORM] = ISL_FORMAT_B4G4R4A4_UNORM,
+ [PIPE_FORMAT_B5G6R5_UNORM] = ISL_FORMAT_B5G6R5_UNORM,
+ [PIPE_FORMAT_R10G10B10A2_UNORM] = ISL_FORMAT_R10G10B10A2_UNORM,
+ [PIPE_FORMAT_L8_UNORM] = ISL_FORMAT_L8_UNORM,
+ [PIPE_FORMAT_A8_UNORM] = ISL_FORMAT_A8_UNORM,
+ [PIPE_FORMAT_I8_UNORM] = ISL_FORMAT_I8_UNORM,
+ [PIPE_FORMAT_L8A8_UNORM] = ISL_FORMAT_L8A8_UNORM,
+ [PIPE_FORMAT_L16_UNORM] = ISL_FORMAT_L16_UNORM,
+ //[PIPE_FORMAT_UYVY] = ISL_FORMAT_UYVY,
+ //[PIPE_FORMAT_YUYV] = ISL_FORMAT_YUYV,
+ [PIPE_FORMAT_Z16_UNORM] = ISL_FORMAT_R16_UNORM,
+ [PIPE_FORMAT_Z32_UNORM] = ISL_FORMAT_R32_UNORM,
+ [PIPE_FORMAT_Z32_FLOAT] = ISL_FORMAT_R32_FLOAT,
+ //[PIPE_FORMAT_Z24_UNORM_S8_UINT] = ISL_FORMAT_R24_UNORM_S8_UINT,
+ //[PIPE_FORMAT_S8_UINT_Z24_UNORM] = ISL_FORMAT_S8_UINT_Z24_UNORM,
+ [PIPE_FORMAT_Z24X8_UNORM] = ISL_FORMAT_R24_UNORM_X8_TYPELESS,
+ //[PIPE_FORMAT_X8Z24_UNORM] = ISL_FORMAT_R24_UNORM_X8_TYPELESS,
+ [PIPE_FORMAT_S8_UINT] = ISL_FORMAT_R8_UINT,
+ [PIPE_FORMAT_R64_FLOAT] = ISL_FORMAT_R64_FLOAT,
+ [PIPE_FORMAT_R64G64_FLOAT] = ISL_FORMAT_R64G64_FLOAT,
+ [PIPE_FORMAT_R64G64B64_FLOAT] = ISL_FORMAT_R64G64B64_FLOAT,
+ [PIPE_FORMAT_R64G64B64A64_FLOAT] = ISL_FORMAT_R64G64B64A64_FLOAT,
+ [PIPE_FORMAT_R32_FLOAT] = ISL_FORMAT_R32_FLOAT,
+ [PIPE_FORMAT_R32G32_FLOAT] = ISL_FORMAT_R32G32_FLOAT,
+ [PIPE_FORMAT_R32G32B32_FLOAT] = ISL_FORMAT_R32G32B32_FLOAT,
+ [PIPE_FORMAT_R32G32B32A32_FLOAT] = ISL_FORMAT_R32G32B32A32_FLOAT,
+ [PIPE_FORMAT_R32_UNORM] = ISL_FORMAT_R32_UNORM,
+ [PIPE_FORMAT_R32G32_UNORM] = ISL_FORMAT_R32G32_UNORM,
+ [PIPE_FORMAT_R32G32B32_UNORM] = ISL_FORMAT_R32G32B32_UNORM,
+ [PIPE_FORMAT_R32G32B32A32_UNORM] = ISL_FORMAT_R32G32B32A32_UNORM,
+ [PIPE_FORMAT_R32_USCALED] = ISL_FORMAT_R32_USCALED,
+ [PIPE_FORMAT_R32G32_USCALED] = ISL_FORMAT_R32G32_USCALED,
+ [PIPE_FORMAT_R32G32B32_USCALED] = ISL_FORMAT_R32G32B32_USCALED,
+ [PIPE_FORMAT_R32G32B32A32_USCALED] = ISL_FORMAT_R32G32B32A32_USCALED,
+ [PIPE_FORMAT_R32_SNORM] = ISL_FORMAT_R32_SNORM,
+ [PIPE_FORMAT_R32G32_SNORM] = ISL_FORMAT_R32G32_SNORM,
+ [PIPE_FORMAT_R32G32B32_SNORM] = ISL_FORMAT_R32G32B32_SNORM,
+ [PIPE_FORMAT_R32G32B32A32_SNORM] = ISL_FORMAT_R32G32B32A32_SNORM,
+ [PIPE_FORMAT_R32_SSCALED] = ISL_FORMAT_R32_SSCALED,
+ [PIPE_FORMAT_R32G32_SSCALED] = ISL_FORMAT_R32G32_SSCALED,
+ [PIPE_FORMAT_R32G32B32_SSCALED] = ISL_FORMAT_R32G32B32_SSCALED,
+ [PIPE_FORMAT_R32G32B32A32_SSCALED] = ISL_FORMAT_R32G32B32A32_SSCALED,
+ [PIPE_FORMAT_R16_UNORM] = ISL_FORMAT_R16_UNORM,
+ [PIPE_FORMAT_R16G16_UNORM] = ISL_FORMAT_R16G16_UNORM,
+ [PIPE_FORMAT_R16G16B16_UNORM] = ISL_FORMAT_R16G16B16_UNORM,
+ [PIPE_FORMAT_R16G16B16A16_UNORM] = ISL_FORMAT_R16G16B16A16_UNORM,
+ [PIPE_FORMAT_R16_USCALED] = ISL_FORMAT_R16_USCALED,
+ [PIPE_FORMAT_R16G16_USCALED] = ISL_FORMAT_R16G16_USCALED,
+ [PIPE_FORMAT_R16G16B16_USCALED] = ISL_FORMAT_R16G16B16_USCALED,
+ [PIPE_FORMAT_R16G16B16A16_USCALED] = ISL_FORMAT_R16G16B16A16_USCALED,
+ [PIPE_FORMAT_R16_SNORM] = ISL_FORMAT_R16_SNORM,
+ [PIPE_FORMAT_R16G16_SNORM] = ISL_FORMAT_R16G16_SNORM,
+ [PIPE_FORMAT_R16G16B16_SNORM] = ISL_FORMAT_R16G16B16_SNORM,
+ [PIPE_FORMAT_R16G16B16A16_SNORM] = ISL_FORMAT_R16G16B16A16_SNORM,
+ [PIPE_FORMAT_R16_SSCALED] = ISL_FORMAT_R16_SSCALED,
+ [PIPE_FORMAT_R16G16_SSCALED] = ISL_FORMAT_R16G16_SSCALED,
+ [PIPE_FORMAT_R16G16B16_SSCALED] = ISL_FORMAT_R16G16B16_SSCALED,
+ [PIPE_FORMAT_R16G16B16A16_SSCALED] = ISL_FORMAT_R16G16B16A16_SSCALED,
+ [PIPE_FORMAT_R8_UNORM] = ISL_FORMAT_R8_UNORM,
+ [PIPE_FORMAT_R8G8_UNORM] = ISL_FORMAT_R8G8_UNORM,
+ [PIPE_FORMAT_R8G8B8_UNORM] = ISL_FORMAT_R8G8B8_UNORM,
+ [PIPE_FORMAT_R8G8B8A8_UNORM] = ISL_FORMAT_R8G8B8A8_UNORM,
+ //[PIPE_FORMAT_X8B8G8R8_UNORM] = ISL_FORMAT_X8B8G8R8_UNORM,
+ [PIPE_FORMAT_R8_USCALED] = ISL_FORMAT_R8_USCALED,
+ [PIPE_FORMAT_R8G8_USCALED] = ISL_FORMAT_R8G8_USCALED,
+ [PIPE_FORMAT_R8G8B8_USCALED] = ISL_FORMAT_R8G8B8_USCALED,
+ [PIPE_FORMAT_R8G8B8A8_USCALED] = ISL_FORMAT_R8G8B8A8_USCALED,
+ [PIPE_FORMAT_R8_SNORM] = ISL_FORMAT_R8_SNORM,
+ [PIPE_FORMAT_R8G8_SNORM] = ISL_FORMAT_R8G8_SNORM,
+ [PIPE_FORMAT_R8G8B8_SNORM] = ISL_FORMAT_R8G8B8_SNORM,
+ [PIPE_FORMAT_R8G8B8A8_SNORM] = ISL_FORMAT_R8G8B8A8_SNORM,
+ [PIPE_FORMAT_R8_SSCALED] = ISL_FORMAT_R8_SSCALED,
+ [PIPE_FORMAT_R8G8_SSCALED] = ISL_FORMAT_R8G8_SSCALED,
+ [PIPE_FORMAT_R8G8B8_SSCALED] = ISL_FORMAT_R8G8B8_SSCALED,
+ [PIPE_FORMAT_R8G8B8A8_SSCALED] = ISL_FORMAT_R8G8B8A8_SSCALED,
+ [PIPE_FORMAT_R32_FIXED] = ISL_FORMAT_R32_SFIXED,
+ [PIPE_FORMAT_R32G32_FIXED] = ISL_FORMAT_R32G32_SFIXED,
+ [PIPE_FORMAT_R32G32B32_FIXED] = ISL_FORMAT_R32G32B32_SFIXED,
+ [PIPE_FORMAT_R32G32B32A32_FIXED] = ISL_FORMAT_R32G32B32A32_SFIXED,
+ [PIPE_FORMAT_R16_FLOAT] = ISL_FORMAT_R16_FLOAT,
+ [PIPE_FORMAT_R16G16_FLOAT] = ISL_FORMAT_R16G16_FLOAT,
+ [PIPE_FORMAT_R16G16B16_FLOAT] = ISL_FORMAT_R16G16B16_FLOAT,
+ [PIPE_FORMAT_R16G16B16A16_FLOAT] = ISL_FORMAT_R16G16B16A16_FLOAT,
+
+ [PIPE_FORMAT_L8_SRGB] = ISL_FORMAT_L8_UNORM_SRGB,
+ [PIPE_FORMAT_L8A8_SRGB] = ISL_FORMAT_L8A8_UNORM_SRGB,
+ //[PIPE_FORMAT_R8G8B8_SRGB] = ISL_FORMAT_R8G8B8_UNORM_SRGB,
+ //[PIPE_FORMAT_A8B8G8R8_SRGB] = ISL_FORMAT_A8B8G8R8_UNORM_SRGB,
+ //[PIPE_FORMAT_X8B8G8R8_SRGB] = ISL_FORMAT_X8B8G8R8_UNORM_SRGB,
+ [PIPE_FORMAT_B8G8R8A8_SRGB] = ISL_FORMAT_B8G8R8A8_UNORM_SRGB,
+ [PIPE_FORMAT_B8G8R8X8_SRGB] = ISL_FORMAT_B8G8R8X8_UNORM_SRGB,
+ //[PIPE_FORMAT_A8R8G8B8_SRGB] = ISL_FORMAT_A8R8G8B8_UNORM_SRGB,
+ //[PIPE_FORMAT_X8R8G8B8_SRGB] = ISL_FORMAT_X8R8G8B8_UNORM_SRGB,
+ [PIPE_FORMAT_R8G8B8A8_SRGB] = ISL_FORMAT_R8G8B8A8_UNORM_SRGB,
+
+ [PIPE_FORMAT_DXT1_RGB] = ISL_FORMAT_BC1_UNORM,
+ [PIPE_FORMAT_DXT1_RGBA] = ISL_FORMAT_BC1_UNORM,
+ [PIPE_FORMAT_DXT3_RGBA] = ISL_FORMAT_BC2_UNORM,
+ [PIPE_FORMAT_DXT5_RGBA] = ISL_FORMAT_BC3_UNORM,
+
+ [PIPE_FORMAT_DXT1_SRGB] = ISL_FORMAT_BC1_UNORM_SRGB,
+ [PIPE_FORMAT_DXT1_SRGBA] = ISL_FORMAT_BC1_UNORM_SRGB,
+ [PIPE_FORMAT_DXT3_SRGBA] = ISL_FORMAT_BC2_UNORM_SRGB,
+ [PIPE_FORMAT_DXT5_SRGBA] = ISL_FORMAT_BC3_UNORM_SRGB,
+
+ [PIPE_FORMAT_RGTC1_UNORM] = ISL_FORMAT_BC4_UNORM,
+ [PIPE_FORMAT_RGTC1_SNORM] = ISL_FORMAT_BC4_SNORM,
+ [PIPE_FORMAT_RGTC2_UNORM] = ISL_FORMAT_BC5_UNORM,
+ [PIPE_FORMAT_RGTC2_SNORM] = ISL_FORMAT_BC5_SNORM,
+
+ //[PIPE_FORMAT_R8G8_B8G8_UNORM] = ISL_FORMAT_R8G8_B8G8_UNORM,
+ //[PIPE_FORMAT_G8R8_G8B8_UNORM] = ISL_FORMAT_G8R8_G8B8_UNORM,
+
+ //[PIPE_FORMAT_R8SG8SB8UX8U_NORM] = ISL_FORMAT_R8SG8SB8UX8U_NORM,
+ //[PIPE_FORMAT_R5SG5SB6U_NORM] = ISL_FORMAT_R5SG5SB6U_NORM,
+
+ //[PIPE_FORMAT_A8B8G8R8_UNORM] = ISL_FORMAT_A8B8G8R8_UNORM,
+ [PIPE_FORMAT_B5G5R5X1_UNORM] = ISL_FORMAT_B5G5R5X1_UNORM,
+ [PIPE_FORMAT_R10G10B10A2_USCALED] = ISL_FORMAT_R10G10B10A2_USCALED,
+ [PIPE_FORMAT_R11G11B10_FLOAT] = ISL_FORMAT_R11G11B10_FLOAT,
+ [PIPE_FORMAT_R9G9B9E5_FLOAT] = ISL_FORMAT_R9G9B9E5_SHAREDEXP,
+ //[PIPE_FORMAT_Z32_FLOAT_S8X24_UINT] = ISL_FORMAT_R32_FLOAT_S8X24_UINT,
+ [PIPE_FORMAT_R1_UNORM] = ISL_FORMAT_R1_UNORM,
+ [PIPE_FORMAT_R10G10B10X2_USCALED] = ISL_FORMAT_R10G10B10X2_USCALED,
+ //[PIPE_FORMAT_R10G10B10X2_SNORM] = ISL_FORMAT_R10G10B10X2_SNORM,
+ //[PIPE_FORMAT_L4A4_UNORM] = ISL_FORMAT_R4G4_UNORM,
+ [PIPE_FORMAT_B10G10R10A2_UNORM] = ISL_FORMAT_B10G10R10A2_UNORM,
+ //[PIPE_FORMAT_R10SG10SB10SA2U_NORM] = ISL_FORMAT_R10SG10SB10SA2U_NORM,
+ //[PIPE_FORMAT_R8G8Bx_SNORM] = ISL_FORMAT_R8G8Bx_SNORM,
+ [PIPE_FORMAT_R8G8B8X8_UNORM] = ISL_FORMAT_R8G8B8X8_UNORM,
+ //[PIPE_FORMAT_B4G4R4X4_UNORM] = ISL_FORMAT_B4G4R4X4_UNORM,
+
+ /* some stencil samplers formats */
+ //[PIPE_FORMAT_X24S8_UINT] = ISL_FORMAT_X24S8_UINT,
+ //[PIPE_FORMAT_S8X24_UINT] = ISL_FORMAT_S8X24_UINT,
+ //[PIPE_FORMAT_X32_S8X24_UINT] = ISL_FORMAT_X32_S8X24_UINT,
+
+ //[PIPE_FORMAT_B2G3R3_UNORM] = ISL_FORMAT_B2G3R3_UNORM,
+ [PIPE_FORMAT_L16A16_UNORM] = ISL_FORMAT_R16G16_UNORM,
+ [PIPE_FORMAT_A16_UNORM] = ISL_FORMAT_R16_UNORM,
+ [PIPE_FORMAT_I16_UNORM] = ISL_FORMAT_R16_UNORM,
+
+ //[PIPE_FORMAT_LATC1_UNORM] = ISL_FORMAT_LATC1_UNORM,
+ //[PIPE_FORMAT_LATC1_SNORM] = ISL_FORMAT_LATC1_SNORM,
+ //[PIPE_FORMAT_LATC2_UNORM] = ISL_FORMAT_LATC2_UNORM,
+ //[PIPE_FORMAT_LATC2_SNORM] = ISL_FORMAT_LATC2_SNORM,
+
+ [PIPE_FORMAT_A8_SNORM] = ISL_FORMAT_R8_SNORM,
+ [PIPE_FORMAT_L8_SNORM] = ISL_FORMAT_R8_SNORM,
+ [PIPE_FORMAT_L8A8_SNORM] = ISL_FORMAT_R8G8_SNORM,
+ [PIPE_FORMAT_I8_SNORM] = ISL_FORMAT_R8_SNORM,
+ [PIPE_FORMAT_A16_SNORM] = ISL_FORMAT_R16_SNORM,
+ [PIPE_FORMAT_L16_SNORM] = ISL_FORMAT_R16_SNORM,
+ [PIPE_FORMAT_L16A16_SNORM] = ISL_FORMAT_R16G16_SNORM,
+ [PIPE_FORMAT_I16_SNORM] = ISL_FORMAT_R16_SNORM,
+
+ [PIPE_FORMAT_A16_FLOAT] = ISL_FORMAT_R16_FLOAT,
+ [PIPE_FORMAT_L16_FLOAT] = ISL_FORMAT_R16_FLOAT,
+ [PIPE_FORMAT_L16A16_FLOAT] = ISL_FORMAT_R16G16_FLOAT,
+ [PIPE_FORMAT_I16_FLOAT] = ISL_FORMAT_R16_FLOAT,
+ [PIPE_FORMAT_A32_FLOAT] = ISL_FORMAT_R32_FLOAT,
+ [PIPE_FORMAT_L32_FLOAT] = ISL_FORMAT_R32_FLOAT,
+ [PIPE_FORMAT_L32A32_FLOAT] = ISL_FORMAT_R32G32_FLOAT,
+ [PIPE_FORMAT_I32_FLOAT] = ISL_FORMAT_R32_FLOAT,
+
+ //[PIPE_FORMAT_YV12] = ISL_FORMAT_YV12,
+ //[PIPE_FORMAT_YV16] = ISL_FORMAT_YV16,
+ //[PIPE_FORMAT_IYUV] = ISL_FORMAT_IYUV,
+ //[PIPE_FORMAT_NV12] = ISL_FORMAT_NV12,
+ //[PIPE_FORMAT_NV21] = ISL_FORMAT_NV21,
+
+ //[PIPE_FORMAT_A4R4_UNORM] = ISL_FORMAT_A4R4_UNORM,
+ //[PIPE_FORMAT_R4A4_UNORM] = ISL_FORMAT_R4A4_UNORM,
+ //[PIPE_FORMAT_R8A8_UNORM] = ISL_FORMAT_R8A8_UNORM,
+ //[PIPE_FORMAT_A8R8_UNORM] = ISL_FORMAT_A8R8_UNORM,
+
+ [PIPE_FORMAT_R10G10B10A2_SSCALED] = ISL_FORMAT_R10G10B10A2_SSCALED,
+ [PIPE_FORMAT_R10G10B10A2_SNORM] = ISL_FORMAT_R10G10B10A2_SNORM,
+
+ [PIPE_FORMAT_B10G10R10A2_USCALED] = ISL_FORMAT_B10G10R10A2_USCALED,
+ [PIPE_FORMAT_B10G10R10A2_SSCALED] = ISL_FORMAT_B10G10R10A2_SSCALED,
+ [PIPE_FORMAT_B10G10R10A2_SNORM] = ISL_FORMAT_B10G10R10A2_SNORM,
+
+ [PIPE_FORMAT_R8_UINT] = ISL_FORMAT_R8_UINT,
+ [PIPE_FORMAT_R8G8_UINT] = ISL_FORMAT_R8G8_UINT,
+ [PIPE_FORMAT_R8G8B8_UINT] = ISL_FORMAT_R8G8B8_UINT,
+ [PIPE_FORMAT_R8G8B8A8_UINT] = ISL_FORMAT_R8G8B8A8_UINT,
+
+ [PIPE_FORMAT_R8_SINT] = ISL_FORMAT_R8_SINT,
+ [PIPE_FORMAT_R8G8_SINT] = ISL_FORMAT_R8G8_SINT,
+ [PIPE_FORMAT_R8G8B8_SINT] = ISL_FORMAT_R8G8B8_SINT,
+ [PIPE_FORMAT_R8G8B8A8_SINT] = ISL_FORMAT_R8G8B8A8_SINT,
+
+ [PIPE_FORMAT_R16_UINT] = ISL_FORMAT_R16_UINT,
+ [PIPE_FORMAT_R16G16_UINT] = ISL_FORMAT_R16G16_UINT,
+ [PIPE_FORMAT_R16G16B16_UINT] = ISL_FORMAT_R16G16B16_UINT,
+ [PIPE_FORMAT_R16G16B16A16_UINT] = ISL_FORMAT_R16G16B16A16_UINT,
+
+ [PIPE_FORMAT_R16_SINT] = ISL_FORMAT_R16_SINT,
+ [PIPE_FORMAT_R16G16_SINT] = ISL_FORMAT_R16G16_SINT,
+ [PIPE_FORMAT_R16G16B16_SINT] = ISL_FORMAT_R16G16B16_SINT,
+ [PIPE_FORMAT_R16G16B16A16_SINT] = ISL_FORMAT_R16G16B16A16_SINT,
+
+ [PIPE_FORMAT_R32_UINT] = ISL_FORMAT_R32_UINT,
+ [PIPE_FORMAT_R32G32_UINT] = ISL_FORMAT_R32G32_UINT,
+ [PIPE_FORMAT_R32G32B32_UINT] = ISL_FORMAT_R32G32B32_UINT,
+ [PIPE_FORMAT_R32G32B32A32_UINT] = ISL_FORMAT_R32G32B32A32_UINT,
+
+ [PIPE_FORMAT_R32_SINT] = ISL_FORMAT_R32_SINT,
+ [PIPE_FORMAT_R32G32_SINT] = ISL_FORMAT_R32G32_SINT,
+ [PIPE_FORMAT_R32G32B32_SINT] = ISL_FORMAT_R32G32B32_SINT,
+ [PIPE_FORMAT_R32G32B32A32_SINT] = ISL_FORMAT_R32G32B32A32_SINT,
+
+ [PIPE_FORMAT_A8_UINT] = ISL_FORMAT_R8_UINT,
+ [PIPE_FORMAT_I8_UINT] = ISL_FORMAT_R8_UINT,
+ [PIPE_FORMAT_L8_UINT] = ISL_FORMAT_R8_UINT,
+ [PIPE_FORMAT_L8A8_UINT] = ISL_FORMAT_R8G8_UINT,
+
+ [PIPE_FORMAT_A8_SINT] = ISL_FORMAT_R8_SINT,
+ [PIPE_FORMAT_I8_SINT] = ISL_FORMAT_R8_SINT,
+ [PIPE_FORMAT_L8_SINT] = ISL_FORMAT_R8_SINT,
+ [PIPE_FORMAT_L8A8_SINT] = ISL_FORMAT_R8G8_SINT,
+
+ [PIPE_FORMAT_A16_UINT] = ISL_FORMAT_R16_UINT,
+ [PIPE_FORMAT_I16_UINT] = ISL_FORMAT_R16_UINT,
+ [PIPE_FORMAT_L16_UINT] = ISL_FORMAT_R16_UINT,
+ [PIPE_FORMAT_L16A16_UINT] = ISL_FORMAT_R16G16_UINT,
+
+ [PIPE_FORMAT_A16_SINT] = ISL_FORMAT_R16_SINT,
+ [PIPE_FORMAT_I16_SINT] = ISL_FORMAT_R16_SINT,
+ [PIPE_FORMAT_L16_SINT] = ISL_FORMAT_R16_SINT,
+ [PIPE_FORMAT_L16A16_SINT] = ISL_FORMAT_R16G16_SINT,
+
+ [PIPE_FORMAT_A32_UINT] = ISL_FORMAT_R32_UINT,
+ [PIPE_FORMAT_I32_UINT] = ISL_FORMAT_R32_UINT,
+ [PIPE_FORMAT_L32_UINT] = ISL_FORMAT_R32_UINT,
+ [PIPE_FORMAT_L32A32_UINT] = ISL_FORMAT_R32G32_UINT,
+
+ [PIPE_FORMAT_A32_SINT] = ISL_FORMAT_R32_SINT,
+ [PIPE_FORMAT_I32_SINT] = ISL_FORMAT_R32_SINT,
+ [PIPE_FORMAT_L32_SINT] = ISL_FORMAT_R32_SINT,
+ [PIPE_FORMAT_L32A32_SINT] = ISL_FORMAT_R32G32_SINT,
+
+ [PIPE_FORMAT_B10G10R10A2_UINT] = ISL_FORMAT_B10G10R10A2_UINT,
+
+ [PIPE_FORMAT_ETC1_RGB8] = ISL_FORMAT_ETC1_RGB8,
+
+ //[PIPE_FORMAT_R8G8_R8B8_UNORM] = ISL_FORMAT_R8G8_R8B8_UNORM,
+ //[PIPE_FORMAT_G8R8_B8R8_UNORM] = ISL_FORMAT_G8R8_B8R8_UNORM,
+
+ //[PIPE_FORMAT_R8G8B8X8_SNORM] = ISL_FORMAT_R8G8B8X8_SNORM,
+ [PIPE_FORMAT_R8G8B8X8_SRGB] = ISL_FORMAT_R8G8B8X8_UNORM_SRGB,
+ //[PIPE_FORMAT_R8G8B8X8_UINT] = ISL_FORMAT_R8G8B8X8_UINT,
+ //[PIPE_FORMAT_R8G8B8X8_SINT] = ISL_FORMAT_R8G8B8X8_SINT,
+ [PIPE_FORMAT_B10G10R10X2_UNORM] = ISL_FORMAT_B10G10R10X2_UNORM,
+ [PIPE_FORMAT_R16G16B16X16_UNORM] = ISL_FORMAT_R16G16B16X16_UNORM,
+ //[PIPE_FORMAT_R16G16B16X16_SNORM] = ISL_FORMAT_R16G16B16X16_SNORM,
+ [PIPE_FORMAT_R16G16B16X16_FLOAT] = ISL_FORMAT_R16G16B16X16_FLOAT,
+ //[PIPE_FORMAT_R16G16B16X16_UINT] = ISL_FORMAT_R16G16B16X16_UINT,
+ //[PIPE_FORMAT_R16G16B16X16_SINT] = ISL_FORMAT_R16G16B16X16_SINT,
+ [PIPE_FORMAT_R32G32B32X32_FLOAT] = ISL_FORMAT_R32G32B32X32_FLOAT,
+ //[PIPE_FORMAT_R32G32B32X32_UINT] = ISL_FORMAT_R32G32B32X32_UINT,
+ //[PIPE_FORMAT_R32G32B32X32_SINT] = ISL_FORMAT_R32G32B32X32_SINT,
+
+ //[PIPE_FORMAT_R8A8_SNORM] = ISL_FORMAT_R8A8_SNORM,
+ //[PIPE_FORMAT_R16A16_UNORM] = ISL_FORMAT_R16A16_UNORM,
+ //[PIPE_FORMAT_R16A16_SNORM] = ISL_FORMAT_R16A16_SNORM,
+ //[PIPE_FORMAT_R16A16_FLOAT] = ISL_FORMAT_R16A16_FLOAT,
+ //[PIPE_FORMAT_R32A32_FLOAT] = ISL_FORMAT_R32A32_FLOAT,
+ //[PIPE_FORMAT_R8A8_UINT] = ISL_FORMAT_R8A8_UINT,
+ //[PIPE_FORMAT_R8A8_SINT] = ISL_FORMAT_R8A8_SINT,
+ //[PIPE_FORMAT_R16A16_UINT] = ISL_FORMAT_R16A16_UINT,
+ //[PIPE_FORMAT_R16A16_SINT] = ISL_FORMAT_R16A16_SINT,
+ //[PIPE_FORMAT_R32A32_UINT] = ISL_FORMAT_R32A32_UINT,
+ //[PIPE_FORMAT_R32A32_SINT] = ISL_FORMAT_R32A32_SINT,
+ [PIPE_FORMAT_R10G10B10A2_UINT] = ISL_FORMAT_R10G10B10A2_UINT,
+
+ [PIPE_FORMAT_B5G6R5_SRGB] = ISL_FORMAT_B5G6R5_UNORM_SRGB,
+
+ [PIPE_FORMAT_BPTC_RGBA_UNORM] = ISL_FORMAT_BC7_UNORM,
+ [PIPE_FORMAT_BPTC_SRGBA] = ISL_FORMAT_BC7_UNORM_SRGB,
+ [PIPE_FORMAT_BPTC_RGB_FLOAT] = ISL_FORMAT_BC6H_SF16,
+ [PIPE_FORMAT_BPTC_RGB_UFLOAT] = ISL_FORMAT_BC6H_UF16,
+
+ //[PIPE_FORMAT_A8L8_UNORM] = ISL_FORMAT_A8L8_UNORM,
+ //[PIPE_FORMAT_A8L8_SNORM] = ISL_FORMAT_A8L8_SNORM,
+ //[PIPE_FORMAT_A8L8_SRGB] = ISL_FORMAT_A8L8_SRGB,
+ //[PIPE_FORMAT_A16L16_UNORM] = ISL_FORMAT_A16L16_UNORM,
+
+ //[PIPE_FORMAT_G8R8_UNORM] = ISL_FORMAT_G8R8_UNORM,
+ //[PIPE_FORMAT_G8R8_SNORM] = ISL_FORMAT_G8R8_SNORM,
+ //[PIPE_FORMAT_G16R16_UNORM] = ISL_FORMAT_G16R16_UNORM,
+ //[PIPE_FORMAT_G16R16_SNORM] = ISL_FORMAT_G16R16_SNORM,
+
+ //[PIPE_FORMAT_A8B8G8R8_SNORM] = ISL_FORMAT_A8B8G8R8_SNORM,
+ //[PIPE_FORMAT_X8B8G8R8_SNORM] = ISL_FORMAT_X8B8G8R8_SNORM,
+
+ [PIPE_FORMAT_ETC2_RGB8] = ISL_FORMAT_ETC2_RGB8,
+ [PIPE_FORMAT_ETC2_SRGB8] = ISL_FORMAT_ETC2_SRGB8,
+ [PIPE_FORMAT_ETC2_RGB8A1] = ISL_FORMAT_ETC2_RGB8_PTA,
+ [PIPE_FORMAT_ETC2_SRGB8A1] = ISL_FORMAT_ETC2_SRGB8_PTA,
+ [PIPE_FORMAT_ETC2_RGBA8] = ISL_FORMAT_ETC2_EAC_RGBA8,
+ [PIPE_FORMAT_ETC2_SRGBA8] = ISL_FORMAT_ETC2_EAC_SRGB8_A8,
+ [PIPE_FORMAT_ETC2_R11_UNORM] = ISL_FORMAT_EAC_R11,
+ [PIPE_FORMAT_ETC2_R11_SNORM] = ISL_FORMAT_EAC_SIGNED_R11,
+ [PIPE_FORMAT_ETC2_RG11_UNORM] = ISL_FORMAT_EAC_RG11,
+ [PIPE_FORMAT_ETC2_RG11_SNORM] = ISL_FORMAT_EAC_SIGNED_RG11,
+
+
+ [PIPE_FORMAT_ASTC_4x4] = ISL_FORMAT_ASTC_LDR_2D_4X4_FLT16,
+ [PIPE_FORMAT_ASTC_5x4] = ISL_FORMAT_ASTC_LDR_2D_5X4_FLT16,
+ [PIPE_FORMAT_ASTC_5x5] = ISL_FORMAT_ASTC_LDR_2D_5X5_FLT16,
+ [PIPE_FORMAT_ASTC_6x5] = ISL_FORMAT_ASTC_LDR_2D_6X5_FLT16,
+ [PIPE_FORMAT_ASTC_6x6] = ISL_FORMAT_ASTC_LDR_2D_6X6_FLT16,
+ [PIPE_FORMAT_ASTC_8x5] = ISL_FORMAT_ASTC_LDR_2D_8X5_FLT16,
+ [PIPE_FORMAT_ASTC_8x6] = ISL_FORMAT_ASTC_LDR_2D_8X6_FLT16,
+ [PIPE_FORMAT_ASTC_8x8] = ISL_FORMAT_ASTC_LDR_2D_8X8_FLT16,
+ [PIPE_FORMAT_ASTC_10x5] = ISL_FORMAT_ASTC_LDR_2D_10X5_FLT16,
+ [PIPE_FORMAT_ASTC_10x6] = ISL_FORMAT_ASTC_LDR_2D_10X6_FLT16,
+ [PIPE_FORMAT_ASTC_10x8] = ISL_FORMAT_ASTC_LDR_2D_10X8_FLT16,
+ [PIPE_FORMAT_ASTC_10x10] = ISL_FORMAT_ASTC_LDR_2D_10X10_FLT16,
+ [PIPE_FORMAT_ASTC_12x10] = ISL_FORMAT_ASTC_LDR_2D_12X10_FLT16,
+ [PIPE_FORMAT_ASTC_12x12] = ISL_FORMAT_ASTC_LDR_2D_12X12_FLT16,
+
+ [PIPE_FORMAT_ASTC_4x4_SRGB] = ISL_FORMAT_ASTC_LDR_2D_4X4_U8SRGB,
+ [PIPE_FORMAT_ASTC_5x4_SRGB] = ISL_FORMAT_ASTC_LDR_2D_5X4_U8SRGB,
+ [PIPE_FORMAT_ASTC_5x5_SRGB] = ISL_FORMAT_ASTC_LDR_2D_5X5_U8SRGB,
+ [PIPE_FORMAT_ASTC_6x5_SRGB] = ISL_FORMAT_ASTC_LDR_2D_6X5_U8SRGB,
+ [PIPE_FORMAT_ASTC_6x6_SRGB] = ISL_FORMAT_ASTC_LDR_2D_6X6_U8SRGB,
+ [PIPE_FORMAT_ASTC_8x5_SRGB] = ISL_FORMAT_ASTC_LDR_2D_8X5_U8SRGB,
+ [PIPE_FORMAT_ASTC_8x6_SRGB] = ISL_FORMAT_ASTC_LDR_2D_8X6_U8SRGB,
+ [PIPE_FORMAT_ASTC_8x8_SRGB] = ISL_FORMAT_ASTC_LDR_2D_8X8_U8SRGB,
+ [PIPE_FORMAT_ASTC_10x5_SRGB] = ISL_FORMAT_ASTC_LDR_2D_10X5_U8SRGB,
+ [PIPE_FORMAT_ASTC_10x6_SRGB] = ISL_FORMAT_ASTC_LDR_2D_10X6_U8SRGB,
+ [PIPE_FORMAT_ASTC_10x8_SRGB] = ISL_FORMAT_ASTC_LDR_2D_10X8_U8SRGB,
+ [PIPE_FORMAT_ASTC_10x10_SRGB] = ISL_FORMAT_ASTC_LDR_2D_10X10_U8SRGB,
+ [PIPE_FORMAT_ASTC_12x10_SRGB] = ISL_FORMAT_ASTC_LDR_2D_12X10_U8SRGB,
+ [PIPE_FORMAT_ASTC_12x12_SRGB] = ISL_FORMAT_ASTC_LDR_2D_12X12_U8SRGB,
+
+ //[PIPE_FORMAT_P016] = ISL_FORMAT_P016,
+
+ //[PIPE_FORMAT_R10G10B10X2_UNORM] = ISL_FORMAT_R10G10B10X2_UNORM,
+ //[PIPE_FORMAT_A1B5G5R5_UNORM] = ISL_FORMAT_A1B5G5R5_UNORM,
+ //[PIPE_FORMAT_X1B5G5R5_UNORM] = ISL_FORMAT_X1B5G5R5_UNORM,
+ };
+ assert(pf < PIPE_FORMAT_COUNT);
+ return table[pf];
+}
+
+boolean
+iris_is_format_supported(struct pipe_screen *pscreen,
+ enum pipe_format pformat,
+ enum pipe_texture_target target,
+ unsigned sample_count,
+ unsigned storage_sample_count,
+ unsigned usage)
+{
+ struct iris_screen *screen = (struct iris_screen *) pscreen;
+ const struct gen_device_info *devinfo = &screen->devinfo;
+
+ // XXX: msaa max
+ if (sample_count > 1)
+ return false;
+
+ bool supported = true;
+
+ enum isl_format format = iris_isl_format_for_pipe_format(pformat);
+
+ if (sample_count > 1)
+ supported &= isl_format_supports_multisampling(devinfo, format);
+
+ if (usage & PIPE_BIND_DEPTH_STENCIL) {
+ supported &= format == ISL_FORMAT_R32_FLOAT_X8X24_TYPELESS ||
+ format == ISL_FORMAT_R32_FLOAT ||
+ format == ISL_FORMAT_R24_UNORM_X8_TYPELESS ||
+ format == ISL_FORMAT_R16_UNORM;
+ }
+
+ if (usage & PIPE_BIND_RENDER_TARGET)
+ supported &= isl_format_supports_rendering(devinfo, format);
+
+ if (usage & PIPE_BIND_SHADER_IMAGE) {
+ // XXX: allow untyped reads
+ supported &= isl_format_supports_typed_reads(devinfo, format) &&
+ isl_format_supports_typed_writes(devinfo, format);
+ }
+
+ if (usage & PIPE_BIND_SAMPLER_VIEW)
+ supported &= isl_format_supports_sampling(devinfo, format);
+
+ if (usage & PIPE_BIND_VERTEX_BUFFER)
+ supported &= isl_format_supports_vertex_fetch(devinfo, format);
+
+ if (usage & PIPE_BIND_INDEX_BUFFER) {
+ supported &= format == ISL_FORMAT_R8_UINT ||
+ format == ISL_FORMAT_R16_UINT ||
+ format == ISL_FORMAT_R32_UINT;
+ }
+
+ if (usage & PIPE_BIND_CONSTANT_BUFFER) {
+ // XXX:
+ }
+
+ if (usage & PIPE_BIND_STREAM_OUTPUT) {
+ // XXX:
+ }
+
+ if (usage & PIPE_BIND_CURSOR) {
+ // XXX:
+ }
+
+ if (usage & PIPE_BIND_CUSTOM) {
+ // XXX:
+ }
+
+ if (usage & PIPE_BIND_SHADER_BUFFER) {
+ // XXX:
+ }
+
+ if (usage & PIPE_BIND_COMPUTE_RESOURCE) {
+ // XXX:
+ }
+
+ if (usage & PIPE_BIND_COMMAND_ARGS_BUFFER) {
+ // XXX:
+ }
+
+ if (usage & PIPE_BIND_QUERY_BUFFER) {
+ // XXX:
+ }
+
+ return true;
+}
+
diff --git a/src/gallium/drivers/iris/iris_pipe.c b/src/gallium/drivers/iris/iris_pipe.c
new file mode 100644
index 00000000000..a088da83984
--- /dev/null
+++ b/src/gallium/drivers/iris/iris_pipe.c
@@ -0,0 +1,309 @@
+/*
+ * Copyright © 2017 Intel Corporation
+ *
+ * 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
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, 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 (including the next
+ * paragraph) 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 NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHOR(S) AND/OR THEIR SUPPLIERS 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.
+ */
+#include <stdio.h>
+#include <errno.h>
+#include "pipe/p_defines.h"
+#include "pipe/p_state.h"
+#include "pipe/p_context.h"
+#include "pipe/p_screen.h"
+#include "util/u_inlines.h"
+#include "util/u_format.h"
+#include "util/u_upload_mgr.h"
+#include "util/ralloc.h"
+#include "iris_context.h"
+#include "iris_resource.h"
+#include "iris_screen.h"
+#include "intel/compiler/brw_compiler.h"
+
+/**
+ * For debugging purposes, this returns a time in seconds.
+ */
+double
+get_time(void)
+{
+ struct timespec tp;
+
+ clock_gettime(CLOCK_MONOTONIC, &tp);
+
+ return tp.tv_sec + tp.tv_nsec / 1000000000.0;
+}
+
+/*
+ * query
+ */
+struct iris_query {
+ unsigned query;
+};
+static struct pipe_query *
+iris_create_query(struct pipe_context *ctx, unsigned query_type, unsigned index)
+{
+ struct iris_query *query = calloc(1, sizeof(struct iris_query));
+
+ return (struct pipe_query *)query;
+}
+
+static void
+iris_destroy_query(struct pipe_context *ctx, struct pipe_query *query)
+{
+ free(query);
+}
+
+static boolean
+iris_begin_query(struct pipe_context *ctx, struct pipe_query *query)
+{
+ return true;
+}
+
+static bool
+iris_end_query(struct pipe_context *ctx, struct pipe_query *query)
+{
+ return true;
+}
+
+static boolean
+iris_get_query_result(struct pipe_context *ctx,
+ struct pipe_query *query,
+ boolean wait,
+ union pipe_query_result *vresult)
+{
+ uint64_t *result = (uint64_t*)vresult;
+
+ *result = 0;
+ return TRUE;
+}
+
+static void
+iris_set_active_query_state(struct pipe_context *pipe, boolean enable)
+{
+}
+
+
+/*
+ * transfer
+ */
+static void *
+iris_transfer_map(struct pipe_context *pipe,
+ struct pipe_resource *resource,
+ unsigned level,
+ enum pipe_transfer_usage usage,
+ const struct pipe_box *box,
+ struct pipe_transfer **ptransfer)
+{
+ struct pipe_transfer *transfer;
+ struct iris_resource *res = (struct iris_resource *)resource;
+
+ transfer = calloc(1, sizeof(struct pipe_transfer));
+ if (!transfer)
+ return NULL;
+ pipe_resource_reference(&transfer->resource, resource);
+ transfer->level = level;
+ transfer->usage = usage;
+ transfer->box = *box;
+ transfer->stride = 1;
+ transfer->layer_stride = 1;
+ *ptransfer = transfer;
+
+ return NULL;
+}
+
+static void
+iris_transfer_flush_region(struct pipe_context *pipe,
+ struct pipe_transfer *transfer,
+ const struct pipe_box *box)
+{
+}
+
+static void
+iris_transfer_unmap(struct pipe_context *pipe,
+ struct pipe_transfer *transfer)
+{
+ pipe_resource_reference(&transfer->resource, NULL);
+ free(transfer);
+}
+
+static void
+iris_buffer_subdata(struct pipe_context *pipe,
+ struct pipe_resource *resource,
+ unsigned usage, unsigned offset,
+ unsigned size, const void *data)
+{
+}
+
+static void
+iris_texture_subdata(struct pipe_context *pipe,
+ struct pipe_resource *resource,
+ unsigned level,
+ unsigned usage,
+ const struct pipe_box *box,
+ const void *data,
+ unsigned stride,
+ unsigned layer_stride)
+{
+}
+
+
+/*
+ *clear/copy
+ */
+static void
+iris_clear(struct pipe_context *ctx, unsigned buffers,
+ const union pipe_color_union *color, double depth, unsigned stencil)
+{
+}
+
+static void
+iris_clear_render_target(struct pipe_context *ctx,
+ struct pipe_surface *dst,
+ const union pipe_color_union *color,
+ unsigned dstx, unsigned dsty,
+ unsigned width, unsigned height,
+ bool render_condition_enabled)
+{
+}
+
+static void
+iris_clear_depth_stencil(struct pipe_context *ctx,
+ struct pipe_surface *dst,
+ unsigned clear_flags,
+ double depth,
+ unsigned stencil,
+ unsigned dstx, unsigned dsty,
+ unsigned width, unsigned height,
+ bool render_condition_enabled)
+{
+}
+
+static void
+iris_resource_copy_region(struct pipe_context *ctx,
+ struct pipe_resource *dst,
+ unsigned dst_level,
+ unsigned dstx, unsigned dsty, unsigned dstz,
+ struct pipe_resource *src,
+ unsigned src_level,
+ const struct pipe_box *src_box)
+{
+}
+
+static void
+iris_blit(struct pipe_context *ctx, const struct pipe_blit_info *info)
+{
+}
+
+
+static void
+iris_flush_resource(struct pipe_context *ctx, struct pipe_resource *resource)
+{
+}
+
+
+/*
+ * context
+ */
+static void
+iris_flush(struct pipe_context *ctx,
+ struct pipe_fence_handle **fence,
+ unsigned flags)
+{
+ if (fence)
+ *fence = NULL;
+}
+
+static void
+iris_destroy_context(struct pipe_context *ctx)
+{
+ if (ctx->stream_uploader)
+ u_upload_destroy(ctx->stream_uploader);
+
+ free(ctx);
+}
+
+static boolean
+iris_generate_mipmap(struct pipe_context *ctx,
+ struct pipe_resource *resource,
+ enum pipe_format format,
+ unsigned base_level,
+ unsigned last_level,
+ unsigned first_layer,
+ unsigned last_layer)
+{
+ return true;
+}
+
+static void
+iris_set_debug_callback(struct pipe_context *ctx,
+ const struct pipe_debug_callback *cb)
+{
+ struct iris_context *ice = (struct iris_context *)ctx;
+
+ if (cb)
+ ice->dbg = *cb;
+ else
+ memset(&ice->dbg, 0, sizeof(ice->dbg));
+}
+
+struct pipe_context *
+iris_create_context(struct pipe_screen *screen, void *priv, unsigned flags)
+{
+ struct iris_context *ice = calloc(1, sizeof(struct iris_context));
+
+ if (!ice)
+ return NULL;
+
+ struct pipe_context *ctx = &ice->ctx;
+
+ ctx->screen = screen;
+ ctx->priv = priv;
+
+ ctx->stream_uploader = u_upload_create_default(ctx);
+ if (!ctx->stream_uploader) {
+ free(ctx);
+ return NULL;
+ }
+ ctx->const_uploader = ctx->stream_uploader;
+
+ ctx->destroy = iris_destroy_context;
+ ctx->flush = iris_flush;
+ ctx->clear = iris_clear;
+ ctx->clear_render_target = iris_clear_render_target;
+ ctx->clear_depth_stencil = iris_clear_depth_stencil;
+ ctx->resource_copy_region = iris_resource_copy_region;
+ ctx->generate_mipmap = iris_generate_mipmap;
+ ctx->blit = iris_blit;
+ ctx->flush_resource = iris_flush_resource;
+ ctx->create_query = iris_create_query;
+ ctx->destroy_query = iris_destroy_query;
+ ctx->begin_query = iris_begin_query;
+ ctx->end_query = iris_end_query;
+ ctx->get_query_result = iris_get_query_result;
+ ctx->set_active_query_state = iris_set_active_query_state;
+ ctx->transfer_map = iris_transfer_map;
+ ctx->transfer_flush_region = iris_transfer_flush_region;
+ ctx->transfer_unmap = iris_transfer_unmap;
+ ctx->buffer_subdata = iris_buffer_subdata;
+ ctx->texture_subdata = iris_texture_subdata;
+ ctx->set_debug_callback = iris_set_debug_callback;
+ iris_init_program_functions(ctx);
+ iris_init_state_functions(ctx);
+
+ return ctx;
+}
diff --git a/src/gallium/drivers/iris/iris_program.c b/src/gallium/drivers/iris/iris_program.c
new file mode 100644
index 00000000000..cc994310b9e
--- /dev/null
+++ b/src/gallium/drivers/iris/iris_program.c
@@ -0,0 +1,95 @@
+/*
+ * Copyright © 2017 Intel Corporation
+ *
+ * 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
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, 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 (including the next
+ * paragraph) 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 NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHOR(S) AND/OR THEIR SUPPLIERS 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.
+ */
+#include <stdio.h>
+#include <errno.h>
+#include "pipe/p_defines.h"
+#include "pipe/p_state.h"
+#include "pipe/p_context.h"
+#include "pipe/p_screen.h"
+#include "util/u_atomic.h"
+#include "compiler/nir/nir.h"
+#include "compiler/nir/nir_builder.h"
+#include "intel/compiler/brw_compiler.h"
+#include "intel/compiler/brw_nir.h"
+#include "iris_context.h"
+
+static unsigned
+get_new_program_id(struct iris_screen *screen)
+{
+ return p_atomic_inc_return(&screen->program_id);
+}
+
+struct iris_uncompiled_shader {
+ struct pipe_shader_state base;
+ unsigned program_id;
+};
+
+static void *
+iris_create_shader_state(struct pipe_context *ctx,
+ const struct pipe_shader_state *state)
+{
+ struct iris_context *ice = (struct iris_context *)ctx;
+ struct iris_screen *screen = (struct iris_screen *)ctx->screen;
+
+ assert(state->type == PIPE_SHADER_IR_NIR);
+
+ nir_shader *nir = state->ir.nir;
+
+ struct iris_uncompiled_shader *cso =
+ calloc(1, sizeof(struct iris_uncompiled_shader));
+ if (!cso)
+ return NULL;
+
+ nir = brw_preprocess_nir(screen->compiler, nir);
+
+ cso->program_id = get_new_program_id(screen);
+ cso->base.type = PIPE_SHADER_IR_NIR;
+ cso->base.ir.nir = nir;
+
+ return cso;
+}
+
+static void
+iris_delete_shader_state(struct pipe_context *ctx, void *hwcso)
+{
+ struct iris_uncompiled_shader *cso = hwcso;
+
+ ralloc_free(cso->base.ir.nir);
+ free(cso);
+}
+
+void
+iris_init_program_functions(struct pipe_context *ctx)
+{
+ ctx->create_vs_state = iris_create_shader_state;
+ ctx->create_tcs_state = iris_create_shader_state;
+ ctx->create_tes_state = iris_create_shader_state;
+ ctx->create_gs_state = iris_create_shader_state;
+ ctx->create_fs_state = iris_create_shader_state;
+
+ ctx->delete_vs_state = iris_delete_shader_state;
+ ctx->delete_tcs_state = iris_delete_shader_state;
+ ctx->delete_tes_state = iris_delete_shader_state;
+ ctx->delete_gs_state = iris_delete_shader_state;
+ ctx->delete_fs_state = iris_delete_shader_state;
+}
diff --git a/src/gallium/drivers/iris/iris_resource.c b/src/gallium/drivers/iris/iris_resource.c
new file mode 100644
index 00000000000..65985747d00
--- /dev/null
+++ b/src/gallium/drivers/iris/iris_resource.c
@@ -0,0 +1,368 @@
+/*
+ * Copyright © 2017 Intel Corporation
+ *
+ * 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
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, 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 (including the next
+ * paragraph) 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 NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHOR(S) AND/OR THEIR SUPPLIERS 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.
+ */
+#include <stdio.h>
+#include <errno.h>
+#include "pipe/p_defines.h"
+#include "pipe/p_state.h"
+#include "pipe/p_context.h"
+#include "pipe/p_screen.h"
+#include "util/u_inlines.h"
+#include "util/u_format.h"
+#include "util/u_upload_mgr.h"
+#include "util/ralloc.h"
+#include "iris_resource.h"
+#include "iris_screen.h"
+#include "intel/common/gen_debug.h"
+#include "drm-uapi/drm_fourcc.h"
+#include "drm-uapi/i915_drm.h"
+
+enum modifier_priority {
+ MODIFIER_PRIORITY_INVALID = 0,
+ MODIFIER_PRIORITY_LINEAR,
+ MODIFIER_PRIORITY_X,
+ MODIFIER_PRIORITY_Y,
+ MODIFIER_PRIORITY_Y_CCS,
+};
+
+static const uint64_t priority_to_modifier[] = {
+ [MODIFIER_PRIORITY_INVALID] = DRM_FORMAT_MOD_INVALID,
+ [MODIFIER_PRIORITY_LINEAR] = DRM_FORMAT_MOD_LINEAR,
+ [MODIFIER_PRIORITY_X] = I915_FORMAT_MOD_X_TILED,
+ [MODIFIER_PRIORITY_Y] = I915_FORMAT_MOD_Y_TILED,
+ [MODIFIER_PRIORITY_Y_CCS] = I915_FORMAT_MOD_Y_TILED_CCS,
+};
+
+static bool
+modifier_is_supported(const struct gen_device_info *devinfo,
+ uint64_t modifier)
+{
+ /* XXX: do something real */
+ switch (modifier) {
+ case I915_FORMAT_MOD_Y_TILED:
+ case I915_FORMAT_MOD_X_TILED:
+ case DRM_FORMAT_MOD_LINEAR:
+ return true;
+ case I915_FORMAT_MOD_Y_TILED_CCS:
+ case DRM_FORMAT_MOD_INVALID:
+ default:
+ return false;
+ }
+}
+
+static uint64_t
+select_best_modifier(struct gen_device_info *devinfo,
+ const uint64_t *modifiers,
+ int count)
+{
+ enum modifier_priority prio = MODIFIER_PRIORITY_INVALID;
+
+ for (int i = 0; i < count; i++) {
+ if (!modifier_is_supported(devinfo, modifiers[i]))
+ continue;
+
+ switch (modifiers[i]) {
+ case I915_FORMAT_MOD_Y_TILED_CCS:
+ prio = MAX2(prio, MODIFIER_PRIORITY_Y_CCS);
+ break;
+ case I915_FORMAT_MOD_Y_TILED:
+ prio = MAX2(prio, MODIFIER_PRIORITY_Y);
+ break;
+ case I915_FORMAT_MOD_X_TILED:
+ prio = MAX2(prio, MODIFIER_PRIORITY_X);
+ break;
+ case DRM_FORMAT_MOD_LINEAR:
+ prio = MAX2(prio, MODIFIER_PRIORITY_LINEAR);
+ break;
+ case DRM_FORMAT_MOD_INVALID:
+ default:
+ break;
+ }
+ }
+
+ return priority_to_modifier[prio];
+}
+
+static enum isl_surf_dim
+target_to_isl_surf_dim(enum pipe_texture_target target)
+{
+ switch (target) {
+ case PIPE_BUFFER:
+ case PIPE_TEXTURE_1D:
+ case PIPE_TEXTURE_1D_ARRAY:
+ return ISL_SURF_DIM_1D;
+ case PIPE_TEXTURE_2D:
+ case PIPE_TEXTURE_CUBE:
+ case PIPE_TEXTURE_RECT:
+ case PIPE_TEXTURE_2D_ARRAY:
+ case PIPE_TEXTURE_CUBE_ARRAY:
+ return ISL_SURF_DIM_2D;
+ case PIPE_TEXTURE_3D:
+ return ISL_SURF_DIM_3D;
+ case PIPE_MAX_TEXTURE_TYPES:
+ break;
+ }
+ unreachable("invalid texture type");
+}
+
+static isl_surf_usage_flags_t
+pipe_bind_to_isl_usage(unsigned bindings)
+{
+ isl_surf_usage_flags_t usage = 0;
+
+ if (bindings & PIPE_BIND_DEPTH_STENCIL)
+ usage |= ISL_SURF_USAGE_DEPTH_BIT | ISL_SURF_USAGE_STENCIL_BIT;
+
+ if (bindings & PIPE_BIND_RENDER_TARGET)
+ usage |= ISL_SURF_USAGE_RENDER_TARGET_BIT;
+
+ if (bindings & PIPE_BIND_SHADER_IMAGE)
+ usage |= ISL_SURF_USAGE_STORAGE_BIT;
+
+ if (bindings & PIPE_BIND_DISPLAY_TARGET)
+ usage |= ISL_SURF_USAGE_DISPLAY_BIT;
+
+ /* XXX: what to do with these? */
+ if (bindings & PIPE_BIND_BLENDABLE)
+ ;
+ if (bindings & PIPE_BIND_SAMPLER_VIEW)
+ ;
+ if (bindings & PIPE_BIND_VERTEX_BUFFER)
+ ;
+ if (bindings & PIPE_BIND_INDEX_BUFFER)
+ ;
+ if (bindings & PIPE_BIND_CONSTANT_BUFFER)
+ ;
+
+ if (bindings & PIPE_BIND_STREAM_OUTPUT)
+ ;
+ if (bindings & PIPE_BIND_CURSOR)
+ ;
+ if (bindings & PIPE_BIND_CUSTOM)
+ ;
+
+ if (bindings & PIPE_BIND_GLOBAL)
+ ;
+ if (bindings & PIPE_BIND_SHADER_BUFFER)
+ ;
+ if (bindings & PIPE_BIND_COMPUTE_RESOURCE)
+ ;
+ if (bindings & PIPE_BIND_COMMAND_ARGS_BUFFER)
+ ;
+ if (bindings & PIPE_BIND_QUERY_BUFFER)
+ ;
+
+ return usage;
+}
+
+static void
+iris_resource_destroy(struct pipe_screen *screen,
+ struct pipe_resource *resource)
+{
+ struct iris_resource *res = (struct iris_resource *)resource;
+
+ iris_bo_unreference(res->bo);
+}
+
+static struct iris_resource *
+iris_alloc_resource(struct pipe_screen *pscreen,
+ const struct pipe_resource *templ)
+{
+ struct iris_resource *res = calloc(1, sizeof(struct iris_resource));
+ if (!res)
+ return NULL;
+
+ res->base = *templ;
+ res->base.screen = pscreen;
+ pipe_reference_init(&res->base.reference, 1);
+
+ return res;
+}
+
+static struct pipe_resource *
+iris_resource_create_with_modifiers(struct pipe_screen *pscreen,
+ const struct pipe_resource *templ,
+ const uint64_t *modifiers,
+ int modifiers_count)
+{
+ struct iris_screen *screen = (struct iris_screen *)pscreen;
+ struct gen_device_info *devinfo = &screen->devinfo;
+ struct iris_resource *res = iris_alloc_resource(pscreen, templ);
+ if (!res)
+ return NULL;
+
+ uint64_t modifier = DRM_FORMAT_MOD_INVALID;
+
+ if (templ->target == PIPE_BUFFER)
+ modifier = DRM_FORMAT_MOD_LINEAR;
+
+ if (templ->bind & (PIPE_BIND_LINEAR | PIPE_BIND_CURSOR))
+ modifier = DRM_FORMAT_MOD_LINEAR;
+
+ if (modifiers_count == 0) {
+ /* Display is X-tiled for historical reasons. */
+ modifier = (templ->bind & PIPE_BIND_DISPLAY_TARGET) ?
+ I915_FORMAT_MOD_X_TILED : I915_FORMAT_MOD_Y_TILED;
+ /* XXX: make sure this doesn't do stupid things for internal textures */
+ }
+
+ if (modifier == DRM_FORMAT_MOD_INVALID) {
+ /* User requested specific modifiers */
+ modifier = select_best_modifier(devinfo, modifiers, modifiers_count);
+ if (modifier == DRM_FORMAT_MOD_INVALID)
+ return NULL;
+ }
+
+ const struct isl_drm_modifier_info *mod_info =
+ isl_drm_modifier_get_info(modifier);
+
+ isl_surf_usage_flags_t usage = pipe_bind_to_isl_usage(templ->bind);
+
+ if (templ->target == PIPE_TEXTURE_CUBE)
+ usage |= ISL_SURF_USAGE_CUBE_BIT;
+
+ isl_surf_init(&screen->isl_dev, &res->surf,
+ .dim = target_to_isl_surf_dim(templ->target),
+ .format = iris_isl_format_for_pipe_format(templ->format),
+ .width = templ->width0,
+ .height = templ->height0,
+ .depth = templ->depth0,
+ .levels = templ->last_level + 1,
+ .array_len = templ->array_size,
+ .samples = MAX2(templ->nr_samples, 1),
+ .min_alignment_B = 0,
+ .row_pitch_B = 0,
+ .usage = usage,
+ .tiling_flags = 1 << mod_info->tiling);
+
+ res->bo = iris_bo_alloc_tiled(screen->bufmgr, "resource", res->surf.size_B,
+ isl_tiling_to_i915_tiling(res->surf.tiling),
+ res->surf.row_pitch_B, 0);
+ if (!res->bo)
+ goto fail;
+
+ return &res->base;
+
+fail:
+ iris_resource_destroy(pscreen, &res->base);
+ return NULL;
+}
+
+static struct pipe_resource *
+iris_resource_create(struct pipe_screen *pscreen,
+ const struct pipe_resource *templ)
+{
+ return iris_resource_create_with_modifiers(pscreen, templ, NULL, 0);
+}
+
+static struct pipe_resource *
+iris_resource_from_handle(struct pipe_screen *pscreen,
+ const struct pipe_resource *templ,
+ struct winsys_handle *whandle,
+ unsigned usage)
+{
+ struct iris_screen *screen = (struct iris_screen *)pscreen;
+ struct iris_bufmgr *bufmgr = screen->bufmgr;
+ struct iris_resource *res = iris_alloc_resource(pscreen, templ);
+ if (!res)
+ return NULL;
+
+ if (whandle->offset != 0) {
+ dbg_printf("Attempt to import unsupported winsys offset %u\n",
+ whandle->offset);
+ goto fail;
+ }
+
+ switch (whandle->type) {
+ case WINSYS_HANDLE_TYPE_SHARED:
+ res->bo = iris_bo_import_dmabuf(bufmgr, whandle->handle);
+ break;
+ case WINSYS_HANDLE_TYPE_FD:
+ res->bo = iris_bo_gem_create_from_name(bufmgr, "winsys image",
+ whandle->handle);
+ break;
+ default:
+ unreachable("invalid winsys handle type");
+ }
+
+ const struct isl_drm_modifier_info *mod_info =
+ isl_drm_modifier_get_info(whandle->modifier);
+
+ // XXX: usage...
+ isl_surf_usage_flags_t isl_usage = ISL_SURF_USAGE_DISPLAY_BIT;
+
+ isl_surf_init(&screen->isl_dev, &res->surf,
+ .dim = target_to_isl_surf_dim(templ->target),
+ .format = iris_isl_format_for_pipe_format(templ->format),
+ .width = templ->width0,
+ .height = templ->height0,
+ .depth = templ->depth0,
+ .levels = templ->last_level + 1,
+ .array_len = templ->array_size,
+ .samples = MAX2(templ->nr_samples, 1),
+ .min_alignment_B = 0,
+ .row_pitch_B = 0,
+ .usage = isl_usage,
+ .tiling_flags = 1 << mod_info->tiling);
+
+ assert(res->bo->tiling_mode == isl_tiling_to_i915_tiling(res->surf.tiling));
+
+ return &res->base;
+
+fail:
+ iris_resource_destroy(pscreen, &res->base);
+ return NULL;
+}
+
+static boolean
+iris_resource_get_handle(struct pipe_screen *pscreen,
+ struct pipe_context *ctx,
+ struct pipe_resource *resource,
+ struct winsys_handle *whandle,
+ unsigned usage)
+{
+ struct iris_resource *res = (struct iris_resource *)resource;
+
+ whandle->stride = res->surf.row_pitch_B;
+
+ switch (whandle->type) {
+ case WINSYS_HANDLE_TYPE_SHARED:
+ return iris_bo_flink(res->bo, &whandle->handle) > 0;
+ case WINSYS_HANDLE_TYPE_KMS:
+ return iris_bo_export_gem_handle(res->bo);
+ case WINSYS_HANDLE_TYPE_FD:
+ return iris_bo_export_dmabuf(res->bo, (int *) &whandle->handle) > 0;
+ }
+
+ return false;
+}
+
+void
+iris_init_screen_resource_functions(struct pipe_screen *pscreen)
+{
+ pscreen->resource_create_with_modifiers =
+ iris_resource_create_with_modifiers;
+ pscreen->resource_create = iris_resource_create;
+ pscreen->resource_from_handle = iris_resource_from_handle;
+ pscreen->resource_get_handle = iris_resource_get_handle;
+ pscreen->resource_destroy = iris_resource_destroy;
+}
diff --git a/src/gallium/drivers/iris/iris_resource.h b/src/gallium/drivers/iris/iris_resource.h
new file mode 100644
index 00000000000..8e4d8d413a9
--- /dev/null
+++ b/src/gallium/drivers/iris/iris_resource.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2017 Intel Corporation
+ *
+ * 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
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, 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 (including the next
+ * paragraph) 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 NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHOR(S) AND/OR THEIR SUPPLIERS 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.
+ */
+#ifndef IRIS_RESOURCE_H
+#define IRIS_RESOURCE_H
+
+#include "pipe/p_state.h"
+#include "intel/isl/isl.h"
+
+struct iris_resource {
+ struct pipe_resource base;
+ struct isl_surf surf;
+ struct iris_bo *bo;
+};
+
+enum isl_format iris_isl_format_for_pipe_format(enum pipe_format pf);
+
+void iris_init_screen_resource_functions(struct pipe_screen *pscreen);
+
+#endif
diff --git a/src/gallium/drivers/iris/iris_screen.c b/src/gallium/drivers/iris/iris_screen.c
new file mode 100644
index 00000000000..9d679848364
--- /dev/null
+++ b/src/gallium/drivers/iris/iris_screen.c
@@ -0,0 +1,524 @@
+/*
+ * Copyright © 2017 Intel Corporation
+ *
+ * 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
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, 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 (including the next
+ * paragraph) 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 NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHOR(S) AND/OR THEIR SUPPLIERS 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.
+ */
+#include <stdio.h>
+#include <errno.h>
+#include <sys/ioctl.h>
+#include "pipe/p_defines.h"
+#include "pipe/p_state.h"
+#include "pipe/p_context.h"
+#include "pipe/p_screen.h"
+#include "util/u_inlines.h"
+#include "util/u_format.h"
+#include "util/u_upload_mgr.h"
+#include "util/ralloc.h"
+#include "drm-uapi/i915_drm.h"
+#include "iris_context.h"
+#include "iris_resource.h"
+#include "iris_screen.h"
+#include "intel/compiler/brw_compiler.h"
+
+static void
+iris_flush_frontbuffer(struct pipe_screen *_screen,
+ struct pipe_resource *resource,
+ unsigned level, unsigned layer,
+ void *context_private, struct pipe_box *box)
+{
+}
+
+static const char *
+iris_get_vendor(struct pipe_screen *pscreen)
+{
+ return "Mesa Project";
+}
+
+static const char *
+iris_get_device_vendor(struct pipe_screen *pscreen)
+{
+ return "Intel";
+}
+
+static const char *
+iris_get_name(struct pipe_screen *pscreen)
+{
+ struct iris_screen *screen = (struct iris_screen *)pscreen;
+ const char *chipset;
+
+ switch (screen->pci_id) {
+#undef CHIPSET
+#define CHIPSET(id, symbol, str) case id: chipset = str; break;
+#include "pci_ids/i965_pci_ids.h"
+ default:
+ chipset = "Unknown Intel Chipset";
+ break;
+ }
+ return &chipset[9];
+}
+
+static int
+iris_get_param(struct pipe_screen *pscreen, enum pipe_cap param)
+{
+ struct iris_screen *screen = (struct iris_screen *)pscreen;
+
+ switch (param) {
+ case PIPE_CAP_NPOT_TEXTURES:
+ case PIPE_CAP_ANISOTROPIC_FILTER:
+ case PIPE_CAP_POINT_SPRITE:
+ case PIPE_CAP_OCCLUSION_QUERY:
+ case PIPE_CAP_QUERY_TIME_ELAPSED:
+ case PIPE_CAP_TEXTURE_SWIZZLE:
+ case PIPE_CAP_TEXTURE_MIRROR_CLAMP:
+ case PIPE_CAP_BLEND_EQUATION_SEPARATE:
+ case PIPE_CAP_SM3:
+ case PIPE_CAP_PRIMITIVE_RESTART:
+ case PIPE_CAP_INDEP_BLEND_ENABLE:
+ case PIPE_CAP_INDEP_BLEND_FUNC:
+ case PIPE_CAP_RGB_OVERRIDE_DST_ALPHA_BLEND:
+ case PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT:
+ case PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT:
+ case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER:
+ case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER:
+ case PIPE_CAP_DEPTH_CLIP_DISABLE:
+ case PIPE_CAP_SHADER_STENCIL_EXPORT:
+ case PIPE_CAP_TGSI_INSTANCEID:
+ case PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR:
+ case PIPE_CAP_MIXED_COLORBUFFER_FORMATS:
+ case PIPE_CAP_SEAMLESS_CUBE_MAP:
+ case PIPE_CAP_SEAMLESS_CUBE_MAP_PER_TEXTURE:
+ case PIPE_CAP_CONDITIONAL_RENDER:
+ case PIPE_CAP_TEXTURE_BARRIER:
+ case PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME:
+ case PIPE_CAP_VERTEX_COLOR_UNCLAMPED:
+ case PIPE_CAP_COMPUTE:
+ case PIPE_CAP_START_INSTANCE:
+ case PIPE_CAP_QUERY_TIMESTAMP:
+ case PIPE_CAP_TEXTURE_MULTISAMPLE:
+ case PIPE_CAP_CUBE_MAP_ARRAY:
+ case PIPE_CAP_TEXTURE_BUFFER_OBJECTS:
+ case PIPE_CAP_QUERY_PIPELINE_STATISTICS:
+ case PIPE_CAP_BUFFER_MAP_PERSISTENT_COHERENT:
+ case PIPE_CAP_TEXTURE_QUERY_LOD:
+ case PIPE_CAP_SAMPLE_SHADING:
+ case PIPE_CAP_TEXTURE_GATHER_OFFSETS:
+ case PIPE_CAP_DRAW_INDIRECT:
+ case PIPE_CAP_MIXED_FRAMEBUFFER_SIZES:
+ case PIPE_CAP_TGSI_VS_LAYER_VIEWPORT:
+ case PIPE_CAP_TGSI_FS_FINE_DERIVATIVE:
+ case PIPE_CAP_ACCELERATED:
+ case PIPE_CAP_UMA:
+ case PIPE_CAP_CONDITIONAL_RENDER_INVERTED:
+ case PIPE_CAP_CLIP_HALFZ:
+ return true;
+
+ case PIPE_CAP_FRAGMENT_COLOR_CLAMPED:
+ case PIPE_CAP_TGSI_CAN_COMPACT_CONSTANTS:
+ case PIPE_CAP_VERTEX_COLOR_CLAMPED:
+ case PIPE_CAP_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION:
+ case PIPE_CAP_USER_VERTEX_BUFFERS:
+ case PIPE_CAP_VERTEX_BUFFER_OFFSET_4BYTE_ALIGNED_ONLY:
+ case PIPE_CAP_VERTEX_BUFFER_STRIDE_4BYTE_ALIGNED_ONLY:
+ case PIPE_CAP_VERTEX_ELEMENT_SRC_OFFSET_4BYTE_ALIGNED_ONLY:
+ case PIPE_CAP_BUFFER_SAMPLER_VIEW_RGBA_ONLY:
+ case PIPE_CAP_TGSI_TEXCOORD:
+ case PIPE_CAP_TEXTURE_BORDER_COLOR_QUIRK:
+ case PIPE_CAP_FAKE_SW_MSAA:
+ case PIPE_CAP_VERTEXID_NOBASE:
+ return false;
+
+ case PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS:
+ return 1;
+ case PIPE_CAP_MAX_RENDER_TARGETS:
+ return BRW_MAX_DRAW_BUFFERS;
+ case PIPE_CAP_MAX_TEXTURE_2D_LEVELS:
+ case PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS:
+ return 15; /* 16384x16384 */
+ case PIPE_CAP_MAX_TEXTURE_3D_LEVELS:
+ return 12; /* 2048x2048 */
+ case PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS:
+ return 4;
+ case PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS:
+ return 2048;
+ case PIPE_CAP_MIN_TEXEL_OFFSET:
+ return -8;
+ case PIPE_CAP_MAX_TEXEL_OFFSET:
+ return 7;
+ case PIPE_CAP_MAX_STREAM_OUTPUT_SEPARATE_COMPONENTS:
+ return BRW_MAX_SOL_BINDINGS / IRIS_MAX_SOL_BUFFERS;
+ case PIPE_CAP_MAX_STREAM_OUTPUT_INTERLEAVED_COMPONENTS:
+ return BRW_MAX_SOL_BINDINGS;
+ case PIPE_CAP_GLSL_FEATURE_LEVEL:
+ return 460;
+ case PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT:
+ /* 3DSTATE_CONSTANT_XS requires the start of UBOs to be 32B aligned */
+ return 32;
+ case PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT:
+ return 64; // XXX: ?
+ case PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT:
+ return 1;
+ case PIPE_CAP_PREFER_BLIT_BASED_TEXTURE_TRANSFER:
+ return true; // XXX: ?????
+ case PIPE_CAP_MAX_TEXTURE_BUFFER_SIZE:
+ return 1 << 27; /* 128MB */
+ case PIPE_CAP_MAX_VIEWPORTS:
+ return 16;
+ case PIPE_CAP_ENDIANNESS:
+ return PIPE_ENDIAN_LITTLE;
+ case PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES:
+ return 256;
+ case PIPE_CAP_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS:
+ return 128;
+ case PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS:
+ case PIPE_CAP_TEXTURE_GATHER_SM5:
+ return 0; // XXX:
+ case PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET:
+ return -32;
+ case PIPE_CAP_MAX_TEXTURE_GATHER_OFFSET:
+ return 31;
+ case PIPE_CAP_TGSI_VS_WINDOW_SPACE_POSITION:
+ case PIPE_CAP_MAX_VERTEX_STREAMS:
+ return 4;
+ case PIPE_CAP_VENDOR_ID:
+ return 0x8086;
+ case PIPE_CAP_DEVICE_ID:
+ return screen->pci_id;
+ case PIPE_CAP_VIDEO_MEMORY:
+ return 0xffffffff; // XXX: bogus
+ case PIPE_CAP_MAX_VERTEX_ATTRIB_STRIDE:
+ return 2048;
+ case PIPE_CAP_SAMPLER_VIEW_TARGET:
+ return false; // XXX: what is this?
+ case PIPE_CAP_POLYGON_OFFSET_CLAMP:
+ case PIPE_CAP_MULTISAMPLE_Z_RESOLVE:
+ case PIPE_CAP_RESOURCE_FROM_USER_MEMORY:
+ case PIPE_CAP_DEVICE_RESET_STATUS_QUERY:
+ case PIPE_CAP_MAX_SHADER_PATCH_VARYINGS:
+ case PIPE_CAP_TEXTURE_FLOAT_LINEAR:
+ case PIPE_CAP_TEXTURE_HALF_FLOAT_LINEAR:
+ case PIPE_CAP_DEPTH_BOUNDS_TEST:
+ case PIPE_CAP_TGSI_TXQS:
+ case PIPE_CAP_FORCE_PERSAMPLE_INTERP:
+ case PIPE_CAP_SHAREABLE_SHADERS:
+ case PIPE_CAP_COPY_BETWEEN_COMPRESSED_AND_PLAIN_FORMATS:
+ case PIPE_CAP_CLEAR_TEXTURE:
+ case PIPE_CAP_DRAW_PARAMETERS:
+ case PIPE_CAP_TGSI_PACK_HALF_FLOAT:
+ case PIPE_CAP_MULTI_DRAW_INDIRECT:
+ case PIPE_CAP_MULTI_DRAW_INDIRECT_PARAMS:
+ case PIPE_CAP_TGSI_FS_POSITION_IS_SYSVAL:
+ case PIPE_CAP_TGSI_FS_FACE_IS_INTEGER_SYSVAL:
+ case PIPE_CAP_SHADER_BUFFER_OFFSET_ALIGNMENT:
+ case PIPE_CAP_INVALIDATE_BUFFER:
+ case PIPE_CAP_GENERATE_MIPMAP:
+ case PIPE_CAP_STRING_MARKER:
+ case PIPE_CAP_SURFACE_REINTERPRET_BLOCKS:
+ case PIPE_CAP_QUERY_BUFFER_OBJECT:
+ case PIPE_CAP_QUERY_MEMORY_INFO:
+ case PIPE_CAP_PCI_GROUP:
+ case PIPE_CAP_PCI_BUS:
+ case PIPE_CAP_PCI_DEVICE:
+ case PIPE_CAP_PCI_FUNCTION:
+ case PIPE_CAP_FRAMEBUFFER_NO_ATTACHMENT:
+ case PIPE_CAP_ROBUST_BUFFER_ACCESS_BEHAVIOR:
+ case PIPE_CAP_CULL_DISTANCE:
+ case PIPE_CAP_PRIMITIVE_RESTART_FOR_PATCHES:
+ case PIPE_CAP_TGSI_VOTE:
+ case PIPE_CAP_MAX_WINDOW_RECTANGLES:
+ case PIPE_CAP_POLYGON_OFFSET_UNITS_UNSCALED:
+ case PIPE_CAP_VIEWPORT_SUBPIXEL_BITS:
+ case PIPE_CAP_MIXED_COLOR_DEPTH_BITS:
+ case PIPE_CAP_TGSI_ARRAY_COMPONENTS:
+ case PIPE_CAP_STREAM_OUTPUT_INTERLEAVE_BUFFERS:
+ case PIPE_CAP_TGSI_CAN_READ_OUTPUTS:
+ case PIPE_CAP_NATIVE_FENCE_FD:
+ case PIPE_CAP_GLSL_OPTIMIZE_CONSERVATIVELY:
+ case PIPE_CAP_TGSI_FS_FBFETCH:
+ case PIPE_CAP_TGSI_MUL_ZERO_WINS:
+ case PIPE_CAP_DOUBLES:
+ case PIPE_CAP_INT64:
+ case PIPE_CAP_INT64_DIVMOD:
+ case PIPE_CAP_TGSI_TEX_TXF_LZ:
+ case PIPE_CAP_TGSI_CLOCK:
+ case PIPE_CAP_POLYGON_MODE_FILL_RECTANGLE:
+ case PIPE_CAP_SPARSE_BUFFER_PAGE_SIZE:
+ case PIPE_CAP_TGSI_BALLOT:
+ case PIPE_CAP_TGSI_TES_LAYER_VIEWPORT:
+ case PIPE_CAP_CAN_BIND_CONST_BUFFER_AS_VERTEX:
+ case PIPE_CAP_ALLOW_MAPPED_BUFFERS_DURING_EXECUTION:
+ case PIPE_CAP_POST_DEPTH_COVERAGE:
+ case PIPE_CAP_BINDLESS_TEXTURE:
+ case PIPE_CAP_NIR_SAMPLERS_AS_DEREF:
+ case PIPE_CAP_QUERY_SO_OVERFLOW:
+ case PIPE_CAP_MEMOBJ:
+ case PIPE_CAP_LOAD_CONSTBUF:
+ case PIPE_CAP_TGSI_ANY_REG_AS_ADDRESS:
+ case PIPE_CAP_TILE_RASTER_ORDER:
+ case PIPE_CAP_MAX_COMBINED_SHADER_OUTPUT_RESOURCES:
+ case PIPE_CAP_SIGNED_VERTEX_BUFFER_OFFSET:
+ case PIPE_CAP_CONTEXT_PRIORITY_MASK:
+ // XXX: TODO: fill these out
+ break;
+ }
+ return 0;
+}
+
+static float
+iris_get_paramf(struct pipe_screen *pscreen, enum pipe_capf param)
+{
+ switch (param) {
+ case PIPE_CAPF_MAX_LINE_WIDTH:
+ case PIPE_CAPF_MAX_LINE_WIDTH_AA:
+ return 7.375f;
+
+ case PIPE_CAPF_MAX_POINT_WIDTH:
+ case PIPE_CAPF_MAX_POINT_WIDTH_AA:
+ return 255.0f;
+
+ case PIPE_CAPF_MAX_TEXTURE_ANISOTROPY:
+ return 16.0f;
+ case PIPE_CAPF_MAX_TEXTURE_LOD_BIAS:
+ return 15.0f;
+ default:
+ unreachable("unknown param");
+ }
+}
+
+static int
+iris_get_shader_param(struct pipe_screen *pscreen,
+ enum pipe_shader_type shader,
+ enum pipe_shader_cap param)
+{
+ struct iris_screen *screen = (struct iris_screen *)pscreen;
+ struct brw_compiler *compiler = screen->compiler;
+
+ /* this is probably not totally correct.. but it's a start: */
+ switch (param) {
+ case PIPE_SHADER_CAP_MAX_INSTRUCTIONS:
+ return shader == PIPE_SHADER_FRAGMENT ? 1024 : 16384;
+ case PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS:
+ case PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS:
+ case PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS:
+ return shader == PIPE_SHADER_FRAGMENT ? 1024 : 0;
+
+ case PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH:
+ return UINT_MAX;
+
+ case PIPE_SHADER_CAP_MAX_INPUTS:
+ return shader == PIPE_SHADER_VERTEX ? 16 : 32;
+ case PIPE_SHADER_CAP_MAX_OUTPUTS:
+ return 32;
+ case PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE:
+ return 16 * 1024 * sizeof(float);
+ case PIPE_SHADER_CAP_MAX_CONST_BUFFERS:
+ return 16;
+ case PIPE_SHADER_CAP_MAX_TEMPS:
+ return 256; /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
+ case PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED:
+ return 0;
+ case PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR:
+ return !compiler->glsl_compiler_options[shader].EmitNoIndirectInput;
+ case PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR:
+ return !compiler->glsl_compiler_options[shader].EmitNoIndirectOutput;
+ case PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR:
+ return !compiler->glsl_compiler_options[shader].EmitNoIndirectTemp;
+ case PIPE_SHADER_CAP_INDIRECT_CONST_ADDR:
+ return 1;
+ case PIPE_SHADER_CAP_SUBROUTINES:
+ return 0;
+ case PIPE_SHADER_CAP_INTEGERS:
+ case PIPE_SHADER_CAP_SCALAR_ISA:
+ return 1;
+ case PIPE_SHADER_CAP_INT64_ATOMICS:
+ case PIPE_SHADER_CAP_FP16:
+ return 0;
+ case PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS:
+ case PIPE_SHADER_CAP_MAX_SAMPLER_VIEWS:
+ case PIPE_SHADER_CAP_MAX_SHADER_IMAGES:
+ case PIPE_SHADER_CAP_MAX_SHADER_BUFFERS:
+ return IRIS_MAX_TEXTURE_SAMPLERS;
+ case PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTERS:
+ case PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTER_BUFFERS:
+ return 0;
+ case PIPE_SHADER_CAP_PREFERRED_IR:
+ return PIPE_SHADER_IR_NIR;
+ case PIPE_SHADER_CAP_SUPPORTED_IRS:
+ return 0;
+ case PIPE_SHADER_CAP_MAX_UNROLL_ITERATIONS_HINT:
+ return 32;
+ case PIPE_SHADER_CAP_LOWER_IF_THRESHOLD:
+ case PIPE_SHADER_CAP_TGSI_SKIP_MERGE_REGISTERS:
+ case PIPE_SHADER_CAP_TGSI_DROUND_SUPPORTED:
+ case PIPE_SHADER_CAP_TGSI_DFRACEXP_DLDEXP_SUPPORTED:
+ case PIPE_SHADER_CAP_TGSI_LDEXP_SUPPORTED:
+ case PIPE_SHADER_CAP_TGSI_FMA_SUPPORTED:
+ case PIPE_SHADER_CAP_TGSI_ANY_INOUT_DECL_RANGE:
+ case PIPE_SHADER_CAP_TGSI_SQRT_SUPPORTED:
+ return 0;
+ default:
+ unreachable("unknown shader param");
+ }
+}
+
+static int
+iris_get_compute_param(struct pipe_screen *pscreen,
+ enum pipe_shader_ir ir_type,
+ enum pipe_compute_cap param,
+ void *ret)
+{
+ /* TODO: compute shaders */
+ return 0;
+}
+
+static uint64_t
+iris_get_timestamp(struct pipe_screen *pscreen)
+{
+ return 0;
+}
+
+static void
+iris_destroy_screen(struct pipe_screen *pscreen)
+{
+ struct iris_screen *screen = (struct iris_screen *) pscreen;
+ ralloc_free(screen);
+}
+
+static void
+iris_fence_reference(struct pipe_screen *screen,
+ struct pipe_fence_handle **ptr,
+ struct pipe_fence_handle *fence)
+{
+}
+
+static boolean
+iris_fence_finish(struct pipe_screen *screen,
+ struct pipe_context *ctx,
+ struct pipe_fence_handle *fence,
+ uint64_t timeout)
+{
+ return true;
+}
+
+static void
+iris_query_memory_info(struct pipe_screen *pscreen,
+ struct pipe_memory_info *info)
+{
+}
+
+static gl_shader_stage
+stage_from_pipe(enum pipe_shader_type pstage)
+{
+ static const gl_shader_stage stages[PIPE_SHADER_TYPES] = {
+ [PIPE_SHADER_VERTEX] = MESA_SHADER_VERTEX,
+ [PIPE_SHADER_TESS_CTRL] = MESA_SHADER_TESS_CTRL,
+ [PIPE_SHADER_TESS_EVAL] = MESA_SHADER_TESS_EVAL,
+ [PIPE_SHADER_GEOMETRY] = MESA_SHADER_GEOMETRY,
+ [PIPE_SHADER_FRAGMENT] = MESA_SHADER_FRAGMENT,
+ [PIPE_SHADER_COMPUTE] = MESA_SHADER_COMPUTE,
+ };
+ return stages[pstage];
+}
+
+static const void *
+iris_get_compiler_options(struct pipe_screen *pscreen,
+ enum pipe_shader_ir ir,
+ enum pipe_shader_type pstage)
+{
+ struct iris_screen *screen = (struct iris_screen *) pscreen;
+ gl_shader_stage stage = stage_from_pipe(pstage);
+ assert(ir == PIPE_SHADER_IR_NIR);
+
+ return screen->compiler->glsl_compiler_options[stage].NirOptions;
+}
+
+static int
+iris_getparam(struct iris_screen *screen, int param, int *value)
+{
+ struct drm_i915_getparam gp = { .param = param, .value = value };
+
+ if (ioctl(screen->fd, DRM_IOCTL_I915_GETPARAM, &gp) == -1)
+ return -errno;
+
+ return 0;
+}
+
+static bool
+iris_getparam_boolean(struct iris_screen *screen, int param)
+{
+ int value = 0;
+ return (iris_getparam(screen, param, &value) == 0) && value;
+}
+
+static int
+iris_getparam_integer(struct iris_screen *screen, int param)
+{
+ int value = -1;
+
+ if (iris_getparam(screen, param, &value) == 0)
+ return value;
+
+ return -1;
+}
+
+struct pipe_screen *
+iris_screen_create(int fd)
+{
+ struct iris_screen *screen = rzalloc(NULL, struct iris_screen);
+ if (!screen)
+ return NULL;
+
+ screen->fd = fd;
+ screen->pci_id = iris_getparam_integer(screen, I915_PARAM_CHIPSET_ID);
+
+ if (!gen_get_device_info(screen->pci_id, &screen->devinfo))
+ return NULL;
+
+ screen->bufmgr = iris_bufmgr_init(&screen->devinfo, fd);
+ if (!screen->bufmgr)
+ return NULL;
+
+ bool hw_has_swizzling = false; // XXX: detect?
+ isl_device_init(&screen->isl_dev, &screen->devinfo, hw_has_swizzling);
+
+ screen->compiler = brw_compiler_create(screen, &screen->devinfo);
+
+ struct pipe_screen *pscreen = &screen->base;
+
+ iris_init_screen_resource_functions(pscreen);
+
+ pscreen->destroy = iris_destroy_screen;
+ pscreen->get_name = iris_get_name;
+ pscreen->get_vendor = iris_get_vendor;
+ pscreen->get_device_vendor = iris_get_device_vendor;
+ pscreen->get_param = iris_get_param;
+ pscreen->get_shader_param = iris_get_shader_param;
+ pscreen->get_compute_param = iris_get_compute_param;
+ pscreen->get_paramf = iris_get_paramf;
+ pscreen->get_compiler_options = iris_get_compiler_options;
+ pscreen->is_format_supported = iris_is_format_supported;
+ pscreen->context_create = iris_create_context;
+ pscreen->flush_frontbuffer = iris_flush_frontbuffer;
+ pscreen->get_timestamp = iris_get_timestamp;
+ pscreen->fence_reference = iris_fence_reference;
+ pscreen->fence_finish = iris_fence_finish;
+ pscreen->query_memory_info = iris_query_memory_info;
+
+ return pscreen;
+}
diff --git a/src/gallium/drivers/iris/iris_screen.h b/src/gallium/drivers/iris/iris_screen.h
new file mode 100644
index 00000000000..5484e535ac9
--- /dev/null
+++ b/src/gallium/drivers/iris/iris_screen.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright © 2017 Intel Corporation
+ *
+ * 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
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, 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 (including the next
+ * paragraph) 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 NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHOR(S) AND/OR THEIR SUPPLIERS 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.
+ */
+#ifndef IRIS_SCREEN_H
+#define IRIS_SCREEN_H
+
+#include "pipe/p_screen.h"
+#include "state_tracker/drm_driver.h"
+#include "util/slab.h"
+#include "util/u_screen.h"
+#include "intel/dev/gen_device_info.h"
+#include "intel/isl/isl.h"
+#include "iris_bufmgr.h"
+
+struct iris_bo;
+
+#define IRIS_MAX_TEXTURE_SAMPLERS 32
+#define IRIS_MAX_SOL_BUFFERS 4
+
+struct iris_screen {
+ struct pipe_screen base;
+ int fd;
+ int pci_id;
+
+ unsigned program_id;
+
+ struct gen_device_info devinfo;
+ struct isl_device isl_dev;
+ struct iris_bufmgr *bufmgr;
+ struct brw_compiler *compiler;
+};
+
+struct pipe_screen *iris_screen_create(int fd);
+
+boolean
+iris_is_format_supported(struct pipe_screen *pscreen,
+ enum pipe_format format,
+ enum pipe_texture_target target,
+ unsigned sample_count,
+ unsigned storage_sample_count,
+ unsigned usage);
+
+#endif
diff --git a/src/gallium/drivers/iris/iris_state.c b/src/gallium/drivers/iris/iris_state.c
new file mode 100644
index 00000000000..cfd08267ac5
--- /dev/null
+++ b/src/gallium/drivers/iris/iris_state.c
@@ -0,0 +1,920 @@
+/*
+ * Copyright © 2017 Intel Corporation
+ *
+ * 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
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, 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 (including the next
+ * paragraph) 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 NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHOR(S) AND/OR THEIR SUPPLIERS 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.
+ */
+#include <stdio.h>
+#include <errno.h>
+#include "pipe/p_defines.h"
+#include "pipe/p_state.h"
+#include "pipe/p_context.h"
+#include "pipe/p_screen.h"
+#include "util/u_inlines.h"
+#include "util/u_transfer.h"
+#include "intel/compiler/brw_compiler.h"
+#include "iris_context.h"
+#include "iris_resource.h"
+
+#define __gen_address_type unsigned
+#define __gen_user_data void
+
+static uint64_t
+__gen_combine_address(void *user_data, void *location,
+ unsigned address, uint32_t delta)
+{
+ return delta;
+}
+
+#define __genxml_cmd_length(cmd) cmd ## _length
+#define __genxml_cmd_length_bias(cmd) cmd ## _length_bias
+#define __genxml_cmd_header(cmd) cmd ## _header
+#define __genxml_cmd_pack(cmd) cmd ## _pack
+
+#define iris_pack_command(cmd, dst, name) \
+ for (struct cmd name = { __genxml_cmd_header(cmd) }, \
+ *_dst = (void *)(dst); __builtin_expect(_dst != NULL, 1); \
+ __genxml_cmd_pack(cmd)(NULL, (void *)dst, &name), \
+ _dst = NULL)
+
+#define iris_pack_state(cmd, dst, name) \
+ for (struct cmd name = {}, \
+ *_dst = (void *)(dst); __builtin_expect(_dst != NULL, 1); \
+ __genxml_cmd_pack(cmd)(NULL, (void *)_dst, &name), \
+ _dst = NULL)
+
+#include "genxml/genX_pack.h"
+#include "genxml/gen_macros.h"
+
+#define MOCS_WB (2 << 1)
+
+UNUSED static void pipe_asserts()
+{
+#define PIPE_ASSERT(x) STATIC_ASSERT((int)x)
+
+ /* pipe_logicop happens to match the hardware. */
+ PIPE_ASSERT(PIPE_LOGICOP_CLEAR == LOGICOP_CLEAR);
+ PIPE_ASSERT(PIPE_LOGICOP_NOR == LOGICOP_NOR);
+ PIPE_ASSERT(PIPE_LOGICOP_AND_INVERTED == LOGICOP_AND_INVERTED);
+ PIPE_ASSERT(PIPE_LOGICOP_COPY_INVERTED == LOGICOP_COPY_INVERTED);
+ PIPE_ASSERT(PIPE_LOGICOP_AND_REVERSE == LOGICOP_AND_REVERSE);
+ PIPE_ASSERT(PIPE_LOGICOP_INVERT == LOGICOP_INVERT);
+ PIPE_ASSERT(PIPE_LOGICOP_XOR == LOGICOP_XOR);
+ PIPE_ASSERT(PIPE_LOGICOP_NAND == LOGICOP_NAND);
+ PIPE_ASSERT(PIPE_LOGICOP_AND == LOGICOP_AND);
+ PIPE_ASSERT(PIPE_LOGICOP_EQUIV == LOGICOP_EQUIV);
+ PIPE_ASSERT(PIPE_LOGICOP_NOOP == LOGICOP_NOOP);
+ PIPE_ASSERT(PIPE_LOGICOP_OR_INVERTED == LOGICOP_OR_INVERTED);
+ PIPE_ASSERT(PIPE_LOGICOP_COPY == LOGICOP_COPY);
+ PIPE_ASSERT(PIPE_LOGICOP_OR_REVERSE == LOGICOP_OR_REVERSE);
+ PIPE_ASSERT(PIPE_LOGICOP_OR == LOGICOP_OR);
+ PIPE_ASSERT(PIPE_LOGICOP_SET == LOGICOP_SET);
+
+ /* pipe_blend_func happens to match the hardware. */
+ PIPE_ASSERT(PIPE_BLENDFACTOR_ONE == BLENDFACTOR_ONE);
+ PIPE_ASSERT(PIPE_BLENDFACTOR_SRC_COLOR == BLENDFACTOR_SRC_COLOR);
+ PIPE_ASSERT(PIPE_BLENDFACTOR_SRC_ALPHA == BLENDFACTOR_SRC_ALPHA);
+ PIPE_ASSERT(PIPE_BLENDFACTOR_DST_ALPHA == BLENDFACTOR_DST_ALPHA);
+ PIPE_ASSERT(PIPE_BLENDFACTOR_DST_COLOR == BLENDFACTOR_DST_COLOR);
+ PIPE_ASSERT(PIPE_BLENDFACTOR_SRC_ALPHA_SATURATE == BLENDFACTOR_SRC_ALPHA_SATURATE);
+ PIPE_ASSERT(PIPE_BLENDFACTOR_CONST_COLOR == BLENDFACTOR_CONST_COLOR);
+ PIPE_ASSERT(PIPE_BLENDFACTOR_CONST_ALPHA == BLENDFACTOR_CONST_ALPHA);
+ PIPE_ASSERT(PIPE_BLENDFACTOR_SRC1_COLOR == BLENDFACTOR_SRC1_COLOR);
+ PIPE_ASSERT(PIPE_BLENDFACTOR_SRC1_ALPHA == BLENDFACTOR_SRC1_ALPHA);
+ PIPE_ASSERT(PIPE_BLENDFACTOR_ZERO == BLENDFACTOR_ZERO);
+ PIPE_ASSERT(PIPE_BLENDFACTOR_INV_SRC_COLOR == BLENDFACTOR_INV_SRC_COLOR);
+ PIPE_ASSERT(PIPE_BLENDFACTOR_INV_SRC_ALPHA == BLENDFACTOR_INV_SRC_ALPHA);
+ PIPE_ASSERT(PIPE_BLENDFACTOR_INV_DST_ALPHA == BLENDFACTOR_INV_DST_ALPHA);
+ PIPE_ASSERT(PIPE_BLENDFACTOR_INV_DST_COLOR == BLENDFACTOR_INV_DST_COLOR);
+ PIPE_ASSERT(PIPE_BLENDFACTOR_INV_CONST_COLOR == BLENDFACTOR_INV_CONST_COLOR);
+ PIPE_ASSERT(PIPE_BLENDFACTOR_INV_CONST_ALPHA == BLENDFACTOR_INV_CONST_ALPHA);
+ PIPE_ASSERT(PIPE_BLENDFACTOR_INV_SRC1_COLOR == BLENDFACTOR_INV_SRC1_COLOR);
+ PIPE_ASSERT(PIPE_BLENDFACTOR_INV_SRC1_ALPHA == BLENDFACTOR_INV_SRC1_ALPHA);
+
+ /* pipe_blend_func happens to match the hardware. */
+ PIPE_ASSERT(PIPE_BLEND_ADD == BLENDFUNCTION_ADD);
+ PIPE_ASSERT(PIPE_BLEND_SUBTRACT == BLENDFUNCTION_SUBTRACT);
+ PIPE_ASSERT(PIPE_BLEND_REVERSE_SUBTRACT == BLENDFUNCTION_REVERSE_SUBTRACT);
+ PIPE_ASSERT(PIPE_BLEND_MIN == BLENDFUNCTION_MIN);
+ PIPE_ASSERT(PIPE_BLEND_MAX == BLENDFUNCTION_MAX);
+
+ /* pipe_stencil_op happens to match the hardware. */
+ PIPE_ASSERT(PIPE_STENCIL_OP_KEEP == STENCILOP_KEEP);
+ PIPE_ASSERT(PIPE_STENCIL_OP_ZERO == STENCILOP_ZERO);
+ PIPE_ASSERT(PIPE_STENCIL_OP_REPLACE == STENCILOP_REPLACE);
+ PIPE_ASSERT(PIPE_STENCIL_OP_INCR == STENCILOP_INCRSAT);
+ PIPE_ASSERT(PIPE_STENCIL_OP_DECR == STENCILOP_DECRSAT);
+ PIPE_ASSERT(PIPE_STENCIL_OP_INCR_WRAP == STENCILOP_INCR);
+ PIPE_ASSERT(PIPE_STENCIL_OP_DECR_WRAP == STENCILOP_DECR);
+ PIPE_ASSERT(PIPE_STENCIL_OP_INVERT == STENCILOP_INVERT);
+#undef PIPE_ASSERT
+}
+
+static unsigned
+translate_compare_func(enum pipe_compare_func pipe_func)
+{
+ static const unsigned map[] = {
+ [PIPE_FUNC_NEVER] = COMPAREFUNCTION_NEVER,
+ [PIPE_FUNC_LESS] = COMPAREFUNCTION_LESS,
+ [PIPE_FUNC_EQUAL] = COMPAREFUNCTION_EQUAL,
+ [PIPE_FUNC_LEQUAL] = COMPAREFUNCTION_LEQUAL,
+ [PIPE_FUNC_GREATER] = COMPAREFUNCTION_GREATER,
+ [PIPE_FUNC_NOTEQUAL] = COMPAREFUNCTION_NOTEQUAL,
+ [PIPE_FUNC_GEQUAL] = COMPAREFUNCTION_GEQUAL,
+ [PIPE_FUNC_ALWAYS] = COMPAREFUNCTION_ALWAYS,
+ };
+ return map[pipe_func];
+}
+
+static unsigned
+translate_shadow_func(enum pipe_compare_func pipe_func)
+{
+ /* Gallium specifies the result of shadow comparisons as:
+ *
+ * 1 if ref <op> texel,
+ * 0 otherwise.
+ *
+ * The hardware does:
+ *
+ * 0 if texel <op> ref,
+ * 1 otherwise.
+ *
+ * So we need to flip the operator and also negate.
+ */
+ static const unsigned map[] = {
+ [PIPE_FUNC_NEVER] = PREFILTEROPALWAYS,
+ [PIPE_FUNC_LESS] = PREFILTEROPLEQUAL,
+ [PIPE_FUNC_EQUAL] = PREFILTEROPNOTEQUAL,
+ [PIPE_FUNC_LEQUAL] = PREFILTEROPLESS,
+ [PIPE_FUNC_GREATER] = PREFILTEROPGEQUAL,
+ [PIPE_FUNC_NOTEQUAL] = PREFILTEROPEQUAL,
+ [PIPE_FUNC_GEQUAL] = PREFILTEROPGREATER,
+ [PIPE_FUNC_ALWAYS] = PREFILTEROPNEVER,
+ };
+ return map[pipe_func];
+}
+
+static unsigned
+translate_cull_mode(unsigned pipe_face)
+{
+ static const unsigned map[4] = {
+ [PIPE_FACE_NONE] = CULLMODE_NONE,
+ [PIPE_FACE_FRONT] = CULLMODE_FRONT,
+ [PIPE_FACE_BACK] = CULLMODE_BACK,
+ [PIPE_FACE_FRONT_AND_BACK] = CULLMODE_BOTH,
+ };
+ return map[pipe_face];
+}
+
+static unsigned
+translate_fill_mode(unsigned pipe_polymode)
+{
+ static const unsigned map[4] = {
+ [PIPE_POLYGON_MODE_FILL] = FILL_MODE_SOLID,
+ [PIPE_POLYGON_MODE_LINE] = FILL_MODE_WIREFRAME,
+ [PIPE_POLYGON_MODE_POINT] = FILL_MODE_POINT,
+ [PIPE_POLYGON_MODE_FILL_RECTANGLE] = FILL_MODE_SOLID,
+ };
+ return map[pipe_polymode];
+}
+
+static void
+iris_draw_vbo(struct pipe_context *ctx, const struct pipe_draw_info *info)
+{
+}
+
+static void
+iris_launch_grid(struct pipe_context *ctx, const struct pipe_grid_info *info)
+{
+}
+
+static void
+iris_set_blend_color(struct pipe_context *ctx,
+ const struct pipe_blend_color *state)
+{
+ struct iris_context *ice = (struct iris_context *) ctx;
+
+ memcpy(&ice->state.blend_color, state, sizeof(struct pipe_blend_color));
+ ice->state.dirty |= IRIS_DIRTY_COLOR_CALC_STATE;
+}
+
+struct iris_blend_state {
+ uint32_t ps_blend[GENX(3DSTATE_PS_BLEND_length)];
+ uint32_t blend_state[GENX(BLEND_STATE_length)];
+ uint32_t blend_entries[BRW_MAX_DRAW_BUFFERS *
+ GENX(BLEND_STATE_ENTRY_length)];
+};
+
+static void *
+iris_create_blend_state(struct pipe_context *ctx,
+ const struct pipe_blend_state *state)
+{
+ struct iris_blend_state *cso = malloc(sizeof(struct iris_blend_state));
+
+ iris_pack_state(GENX(BLEND_STATE), cso->blend_state, bs) {
+ bs.AlphaToCoverageEnable = state->alpha_to_coverage;
+ bs.IndependentAlphaBlendEnable = state->independent_blend_enable;
+ bs.AlphaToOneEnable = state->alpha_to_one;
+ bs.AlphaToCoverageDitherEnable = state->alpha_to_coverage;
+ bs.ColorDitherEnable = state->dither;
+ //bs.AlphaTestEnable = <comes from alpha state> :(
+ //bs.AlphaTestFunction = <comes from alpha state> :(
+ }
+
+ iris_pack_command(GENX(3DSTATE_PS_BLEND), cso->ps_blend, pb) {
+ //pb.HasWriteableRT = <comes from somewhere> :(
+ //pb.AlphaTestEnable = <comes from alpha state> :(
+ pb.AlphaToCoverageEnable = state->alpha_to_coverage;
+ pb.IndependentAlphaBlendEnable = state->independent_blend_enable;
+
+ pb.ColorBufferBlendEnable = state->rt[0].blend_enable;
+
+ pb.SourceBlendFactor = state->rt[0].rgb_src_factor;
+ pb.SourceAlphaBlendFactor = state->rt[0].alpha_func;
+ pb.DestinationBlendFactor = state->rt[0].rgb_dst_factor;
+ pb.DestinationAlphaBlendFactor = state->rt[0].alpha_dst_factor;
+ }
+
+ for (int i = 0; i < BRW_MAX_DRAW_BUFFERS; i++) {
+ iris_pack_state(GENX(BLEND_STATE_ENTRY), &cso->blend_entries[i], be) {
+ be.LogicOpEnable = state->logicop_enable;
+ be.LogicOpFunction = state->logicop_func;
+
+ be.PreBlendSourceOnlyClampEnable = false;
+ be.ColorClampRange = COLORCLAMP_RTFORMAT;
+ be.PreBlendColorClampEnable = true;
+ be.PostBlendColorClampEnable = true;
+
+ be.ColorBufferBlendEnable = state->rt[i].blend_enable;
+
+ be.ColorBlendFunction = state->rt[i].rgb_func;
+ be.AlphaBlendFunction = state->rt[i].alpha_func;
+ be.SourceBlendFactor = state->rt[i].rgb_src_factor;
+ be.SourceAlphaBlendFactor = state->rt[i].alpha_func;
+ be.DestinationBlendFactor = state->rt[i].rgb_dst_factor;
+ be.DestinationAlphaBlendFactor = state->rt[i].alpha_dst_factor;
+
+ be.WriteDisableRed = state->rt[i].colormask & PIPE_MASK_R;
+ be.WriteDisableGreen = state->rt[i].colormask & PIPE_MASK_G;
+ be.WriteDisableBlue = state->rt[i].colormask & PIPE_MASK_B;
+ be.WriteDisableAlpha = state->rt[i].colormask & PIPE_MASK_A;
+ }
+ }
+
+ return cso;
+}
+
+struct iris_depth_stencil_alpha_state {
+ uint32_t wmds[GENX(3DSTATE_WM_DEPTH_STENCIL_length)];
+ uint32_t cc_vp[GENX(CC_VIEWPORT_length)];
+
+ struct pipe_alpha_state alpha; /* to BLEND_STATE, 3DSTATE_PS_BLEND */
+};
+
+static void *
+iris_create_dsa_state(struct pipe_context *ctx,
+ const struct pipe_depth_stencil_alpha_state *state)
+{
+ struct iris_depth_stencil_alpha_state *cso =
+ malloc(sizeof(struct iris_depth_stencil_alpha_state));
+
+ cso->alpha = state->alpha;
+
+ bool two_sided_stencil = state->stencil[1].enabled;
+
+ /* The state tracker needs to optimize away EQUAL writes for us. */
+ assert(!(state->depth.func == PIPE_FUNC_EQUAL && state->depth.writemask));
+
+ iris_pack_command(GENX(3DSTATE_WM_DEPTH_STENCIL), cso->wmds, wmds) {
+ wmds.StencilFailOp = state->stencil[0].fail_op;
+ wmds.StencilPassDepthFailOp = state->stencil[0].zfail_op;
+ wmds.StencilPassDepthPassOp = state->stencil[0].zpass_op;
+ wmds.StencilTestFunction =
+ translate_compare_func(state->stencil[0].func);
+ wmds.BackfaceStencilFailOp = state->stencil[1].fail_op;
+ wmds.BackfaceStencilPassDepthFailOp = state->stencil[1].zfail_op;
+ wmds.BackfaceStencilPassDepthPassOp = state->stencil[1].zpass_op;
+ wmds.BackfaceStencilTestFunction =
+ translate_compare_func(state->stencil[1].func);
+ wmds.DepthTestFunction = translate_compare_func(state->depth.func);
+ wmds.DoubleSidedStencilEnable = two_sided_stencil;
+ wmds.StencilTestEnable = state->stencil[0].enabled;
+ wmds.StencilBufferWriteEnable =
+ state->stencil[0].writemask != 0 ||
+ (two_sided_stencil && state->stencil[1].writemask != 0);
+ wmds.DepthTestEnable = state->depth.enabled;
+ wmds.DepthBufferWriteEnable = state->depth.writemask;
+ wmds.StencilTestMask = state->stencil[0].valuemask;
+ wmds.StencilWriteMask = state->stencil[0].writemask;
+ wmds.BackfaceStencilTestMask = state->stencil[1].valuemask;
+ wmds.BackfaceStencilWriteMask = state->stencil[1].writemask;
+ //wmds.StencilReferenceValue = <comes from elsewhere>
+ //wmds.BackfaceStencilReferenceValue = <comes from elsewhere>
+ }
+
+ iris_pack_state(GENX(CC_VIEWPORT), cso->cc_vp, ccvp) {
+ ccvp.MinimumDepth = state->depth.bounds_min;
+ ccvp.MaximumDepth = state->depth.bounds_max;
+ }
+
+ return cso;
+}
+
+struct iris_rasterizer_state {
+ uint32_t sf[GENX(3DSTATE_SF_length)];
+ uint32_t clip[GENX(3DSTATE_CLIP_length)];
+ uint32_t raster[GENX(3DSTATE_RASTER_length)];
+ uint32_t wm[GENX(3DSTATE_WM_length)];
+
+ bool flatshade; /* for shader state */
+ bool light_twoside; /* for shader state */
+ bool rasterizer_discard; /* for 3DSTATE_STREAMOUT */
+ enum pipe_sprite_coord_mode sprite_coord_mode; /* PIPE_SPRITE_* */
+
+ uint8_t line_stipple_factor;
+ uint16_t line_stipple_pattern;
+};
+
+static void *
+iris_create_rasterizer_state(struct pipe_context *ctx,
+ const struct pipe_rasterizer_state *state)
+{
+ struct iris_rasterizer_state *cso =
+ malloc(sizeof(struct iris_rasterizer_state));
+
+#if 0
+ sprite_coord_mode -> SBE PointSpriteTextureCoordinateOrigin
+ sprite_coord_enable -> SBE PointSpriteTextureCoordinateEnable
+ point_quad_rasterization -> SBE?
+
+ not necessary?
+ {
+ poly_smooth
+ force_persample_interp - ?
+ bottom_edge_rule
+
+ offset_units_unscaled - cap not exposed
+ }
+
+ unsigned line_stipple_factor:8; /**< [1..256] actually */
+ unsigned line_stipple_pattern:16;
+ #endif
+
+ cso->flatshade = state->flatshade;
+ cso->light_twoside = state->light_twoside;
+ cso->rasterizer_discard = state->rasterizer_discard;
+ cso->line_stipple_factor = state->line_stipple_factor;
+ cso->line_stipple_pattern = state->line_stipple_pattern;
+ // for 3DSTATE_MULTISAMPLE, if we want it.
+ //cso->half_pixel_center = state->half_pixel_center;
+
+ iris_pack_command(GENX(3DSTATE_SF), cso->sf, sf) {
+ sf.StatisticsEnable = true;
+ sf.ViewportTransformEnable = true;
+ sf.AALineDistanceMode = AALINEDISTANCE_TRUE;
+ sf.LineEndCapAntialiasingRegionWidth =
+ state->line_smooth ? _10pixels : _05pixels;
+ sf.LastPixelEnable = state->line_last_pixel;
+ sf.LineWidth = state->line_width;
+ sf.SmoothPointEnable = state->point_smooth;
+ sf.PointWidthSource = state->point_size_per_vertex ? Vertex : State;
+ sf.PointWidth = state->point_size;
+
+ if (state->flatshade_first) {
+ sf.TriangleStripListProvokingVertexSelect = 2;
+ sf.TriangleFanProvokingVertexSelect = 2;
+ sf.LineStripListProvokingVertexSelect = 1;
+ } else {
+ sf.TriangleFanProvokingVertexSelect = 1;
+ }
+ }
+
+ /* COMPLETE! */
+ iris_pack_command(GENX(3DSTATE_RASTER), cso->raster, rr) {
+ rr.FrontWinding = state->front_ccw ? CounterClockwise : Clockwise;
+ rr.CullMode = translate_cull_mode(state->cull_face);
+ rr.FrontFaceFillMode = translate_fill_mode(state->fill_front);
+ rr.BackFaceFillMode = translate_fill_mode(state->fill_back);
+ rr.DXMultisampleRasterizationEnable = state->multisample;
+ rr.GlobalDepthOffsetEnableSolid = state->offset_tri;
+ rr.GlobalDepthOffsetEnableWireframe = state->offset_line;
+ rr.GlobalDepthOffsetEnablePoint = state->offset_point;
+ rr.GlobalDepthOffsetConstant = state->offset_units;
+ rr.GlobalDepthOffsetScale = state->offset_scale;
+ rr.GlobalDepthOffsetClamp = state->offset_clamp;
+ rr.SmoothPointEnable = state->point_smooth;
+ rr.AntialiasingEnable = state->line_smooth;
+ rr.ScissorRectangleEnable = state->scissor;
+ rr.ViewportZNearClipTestEnable = state->depth_clip_near;
+ rr.ViewportZFarClipTestEnable = state->depth_clip_far;
+ //rr.ConservativeRasterizationEnable = not yet supported by Gallium...
+ }
+
+ iris_pack_command(GENX(3DSTATE_CLIP), cso->clip, cl) {
+ cl.StatisticsEnable = true;
+ cl.EarlyCullEnable = true;
+ cl.UserClipDistanceClipTestEnableBitmask = state->clip_plane_enable;
+ cl.ForceUserClipDistanceClipTestEnableBitmask = true;
+ cl.APIMode = state->clip_halfz ? APIMODE_D3D : APIMODE_OGL;
+ cl.GuardbandClipTestEnable = true;
+ cl.ClipMode = CLIPMODE_NORMAL;
+ cl.ClipEnable = true;
+ cl.ViewportXYClipTestEnable = state->point_tri_clip;
+ cl.MinimumPointWidth = 0.125;
+ cl.MaximumPointWidth = 255.875;
+ //.NonPerspectiveBarycentricEnable = <comes from FS prog> :(
+ //.ForceZeroRTAIndexEnable = <comes from FB layers being 0>
+
+ if (state->flatshade_first) {
+ cl.TriangleStripListProvokingVertexSelect = 2;
+ cl.TriangleFanProvokingVertexSelect = 2;
+ cl.LineStripListProvokingVertexSelect = 1;
+ } else {
+ cl.TriangleFanProvokingVertexSelect = 1;
+ }
+ }
+
+ iris_pack_command(GENX(3DSTATE_WM), cso->wm, wm) {
+ wm.LineAntialiasingRegionWidth = _10pixels;
+ wm.LineEndCapAntialiasingRegionWidth = _05pixels;
+ wm.PointRasterizationRule = RASTRULE_UPPER_RIGHT;
+ wm.StatisticsEnable = true;
+ wm.LineStippleEnable = state->line_stipple_enable;
+ wm.PolygonStippleEnable = state->poly_stipple_enable;
+ // wm.BarycentricInterpolationMode = <comes from FS program> :(
+ // wm.EarlyDepthStencilControl = <comes from FS program> :(
+ }
+
+ return cso;
+}
+
+static uint32_t
+translate_wrap(unsigned pipe_wrap)
+{
+ static const unsigned map[] = {
+ [PIPE_TEX_WRAP_REPEAT] = TCM_WRAP,
+ [PIPE_TEX_WRAP_CLAMP] = TCM_HALF_BORDER,
+ [PIPE_TEX_WRAP_CLAMP_TO_EDGE] = TCM_CLAMP,
+ [PIPE_TEX_WRAP_CLAMP_TO_BORDER] = TCM_CLAMP_BORDER,
+ [PIPE_TEX_WRAP_MIRROR_REPEAT] = TCM_MIRROR,
+ [PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE] = TCM_MIRROR_ONCE,
+ [PIPE_TEX_WRAP_MIRROR_CLAMP] = -1, // XXX: ???
+ [PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER] = -1, // XXX: ???
+ };
+ return map[pipe_wrap];
+}
+
+/**
+ * Return true if the given wrap mode requires the border color to exist.
+ */
+static bool
+wrap_mode_needs_border_color(unsigned wrap_mode)
+{
+ return wrap_mode == TCM_CLAMP_BORDER || wrap_mode == TCM_HALF_BORDER;
+}
+
+static unsigned
+translate_mip_filter(enum pipe_tex_mipfilter pipe_mip)
+{
+ static const unsigned map[] = {
+ [PIPE_TEX_MIPFILTER_NEAREST] = MIPFILTER_NEAREST,
+ [PIPE_TEX_MIPFILTER_LINEAR] = MIPFILTER_LINEAR,
+ [PIPE_TEX_MIPFILTER_NONE] = MIPFILTER_NONE,
+ };
+ return map[pipe_mip];
+}
+
+struct iris_sampler_state {
+ struct pipe_sampler_state base;
+
+ bool needs_border_color;
+
+ uint32_t sampler_state[GENX(SAMPLER_STATE_length)];
+};
+
+static void *
+iris_create_sampler_state(struct pipe_context *pctx,
+ const struct pipe_sampler_state *state)
+{
+ struct iris_sampler_state *cso = CALLOC_STRUCT(iris_sampler_state);
+
+ if (!cso)
+ return NULL;
+
+ STATIC_ASSERT(PIPE_TEX_FILTER_NEAREST == MAPFILTER_NEAREST);
+ STATIC_ASSERT(PIPE_TEX_FILTER_LINEAR == MAPFILTER_LINEAR);
+
+ unsigned wrap_s = translate_wrap(state->wrap_s);
+ unsigned wrap_t = translate_wrap(state->wrap_t);
+ unsigned wrap_r = translate_wrap(state->wrap_r);
+
+ cso->needs_border_color = wrap_mode_needs_border_color(wrap_s) ||
+ wrap_mode_needs_border_color(wrap_t) ||
+ wrap_mode_needs_border_color(wrap_r);
+
+ iris_pack_state(GENX(SAMPLER_STATE), cso->sampler_state, samp) {
+ samp.TCXAddressControlMode = wrap_s;
+ samp.TCYAddressControlMode = wrap_t;
+ samp.TCZAddressControlMode = wrap_r;
+ samp.CubeSurfaceControlMode = state->seamless_cube_map;
+ samp.NonnormalizedCoordinateEnable = !state->normalized_coords;
+ samp.MinModeFilter = state->min_img_filter;
+ samp.MagModeFilter = state->mag_img_filter;
+ samp.MipModeFilter = translate_mip_filter(state->min_mip_filter);
+ samp.MaximumAnisotropy = RATIO21;
+
+ if (state->max_anisotropy >= 2) {
+ if (state->min_img_filter == PIPE_TEX_FILTER_LINEAR) {
+ samp.MinModeFilter = MAPFILTER_ANISOTROPIC;
+ samp.AnisotropicAlgorithm = EWAApproximation;
+ }
+
+ if (state->mag_img_filter == PIPE_TEX_FILTER_LINEAR)
+ samp.MagModeFilter = MAPFILTER_ANISOTROPIC;
+
+ samp.MaximumAnisotropy =
+ MIN2((state->max_anisotropy - 2) / 2, RATIO161);
+ }
+
+ /* Set address rounding bits if not using nearest filtering. */
+ if (state->min_img_filter != PIPE_TEX_FILTER_NEAREST) {
+ samp.UAddressMinFilterRoundingEnable = true;
+ samp.VAddressMinFilterRoundingEnable = true;
+ samp.RAddressMinFilterRoundingEnable = true;
+ }
+
+ if (state->mag_img_filter != PIPE_TEX_FILTER_NEAREST) {
+ samp.UAddressMagFilterRoundingEnable = true;
+ samp.VAddressMagFilterRoundingEnable = true;
+ samp.RAddressMagFilterRoundingEnable = true;
+ }
+
+ if (state->compare_mode == PIPE_TEX_COMPARE_R_TO_TEXTURE)
+ samp.ShadowFunction = translate_shadow_func(state->compare_func);
+
+ const float hw_max_lod = GEN_GEN >= 7 ? 14 : 13;
+
+ samp.LODPreClampMode = CLAMP_MODE_OGL;
+ samp.MinLOD = CLAMP(state->min_lod, 0, hw_max_lod);
+ samp.MaxLOD = CLAMP(state->max_lod, 0, hw_max_lod);
+ samp.TextureLODBias = CLAMP(state->lod_bias, -16, 15);
+
+ //samp.BorderColorPointer = <<comes from elsewhere>>
+ }
+
+ return cso;
+}
+
+static struct pipe_sampler_view *
+iris_create_sampler_view(struct pipe_context *ctx,
+ struct pipe_resource *texture,
+ const struct pipe_sampler_view *state)
+{
+ struct pipe_sampler_view *sampler_view = CALLOC_STRUCT(pipe_sampler_view);
+
+ if (!sampler_view)
+ return NULL;
+
+ /* initialize base object */
+ *sampler_view = *state;
+ sampler_view->texture = NULL;
+ pipe_resource_reference(&sampler_view->texture, texture);
+ pipe_reference_init(&sampler_view->reference, 1);
+ sampler_view->context = ctx;
+ return sampler_view;
+}
+
+static struct pipe_surface *
+iris_create_surface(struct pipe_context *ctx,
+ struct pipe_resource *tex,
+ const struct pipe_surface *surf_tmpl)
+{
+ struct pipe_surface *surface = CALLOC_STRUCT(pipe_surface);
+
+ if (!surface)
+ return NULL;
+
+ pipe_reference_init(&surface->reference, 1);
+ pipe_resource_reference(&surface->texture, tex);
+ surface->context = ctx;
+ surface->format = surf_tmpl->format;
+ surface->width = tex->width0;
+ surface->height = tex->height0;
+ surface->texture = tex;
+ surface->u.tex.first_layer = surf_tmpl->u.tex.first_layer;
+ surface->u.tex.last_layer = surf_tmpl->u.tex.last_layer;
+ surface->u.tex.level = surf_tmpl->u.tex.level;
+
+ return surface;
+}
+
+static void
+iris_set_sampler_views(struct pipe_context *ctx,
+ enum pipe_shader_type shader,
+ unsigned start, unsigned count,
+ struct pipe_sampler_view **views)
+{
+}
+
+static void
+iris_bind_sampler_states(struct pipe_context *ctx,
+ enum pipe_shader_type shader,
+ unsigned start, unsigned count,
+ void **states)
+{
+}
+
+static void
+iris_set_clip_state(struct pipe_context *ctx,
+ const struct pipe_clip_state *state)
+{
+}
+
+static void
+iris_set_polygon_stipple(struct pipe_context *ctx,
+ const struct pipe_poly_stipple *state)
+{
+ struct iris_context *ice = (struct iris_context *) ctx;
+ memcpy(&ice->state.poly_stipple, state, sizeof(*state));
+ ice->state.dirty |= IRIS_DIRTY_POLYGON_STIPPLE;
+}
+
+static void
+iris_set_sample_mask(struct pipe_context *pipe, unsigned sample_mask)
+{
+}
+
+static void
+iris_set_scissor_states(struct pipe_context *ctx,
+ unsigned start_slot,
+ unsigned num_scissors,
+ const struct pipe_scissor_state *state)
+{
+ struct iris_context *ice = (struct iris_context *) ctx;
+
+ for (unsigned i = start_slot; i < start_slot + num_scissors; i++) {
+ ice->state.scissors[i] = *state;
+ }
+
+ ice->state.dirty |= IRIS_DIRTY_SCISSOR_RECT;
+}
+
+static void
+iris_set_stencil_ref(struct pipe_context *ctx,
+ const struct pipe_stencil_ref *state)
+{
+ struct iris_context *ice = (struct iris_context *) ctx;
+ memcpy(&ice->state.stencil_ref, state, sizeof(*state));
+ ice->state.dirty |= IRIS_DIRTY_WM_DEPTH_STENCIL;
+}
+
+static void
+iris_set_viewport_states(struct pipe_context *ctx,
+ unsigned start_slot,
+ unsigned num_viewports,
+ const struct pipe_viewport_state *state)
+{
+}
+
+static void
+iris_set_framebuffer_state(struct pipe_context *ctx,
+ const struct pipe_framebuffer_state *state)
+{
+}
+
+static void
+iris_set_constant_buffer(struct pipe_context *ctx,
+ enum pipe_shader_type shader, uint index,
+ const struct pipe_constant_buffer *cb)
+{
+}
+
+
+static void
+iris_sampler_view_destroy(struct pipe_context *ctx,
+ struct pipe_sampler_view *state)
+{
+ pipe_resource_reference(&state->texture, NULL);
+ free(state);
+}
+
+
+static void
+iris_surface_destroy(struct pipe_context *ctx, struct pipe_surface *surface)
+{
+ pipe_resource_reference(&surface->texture, NULL);
+ free(surface);
+}
+
+static void
+iris_bind_state(struct pipe_context *ctx, void *state)
+{
+}
+
+static void
+iris_delete_state(struct pipe_context *ctx, void *state)
+{
+ free(state);
+}
+
+struct iris_vertex_buffer_state {
+ uint32_t vertex_buffers[1 + 33 * GENX(VERTEX_BUFFER_STATE_length)];
+ unsigned length; /* length of 3DSTATE_VERTEX_BUFFERS in DWords */
+};
+
+static void
+iris_set_vertex_buffers(struct pipe_context *ctx,
+ unsigned start_slot, unsigned count,
+ const struct pipe_vertex_buffer *buffers)
+{
+ struct iris_vertex_buffer_state *cso =
+ malloc(sizeof(struct iris_vertex_buffer_state));
+
+ cso->length = 4 * count - 1;
+
+ iris_pack_state(GENX(3DSTATE_VERTEX_BUFFERS), cso->vertex_buffers, vb) {
+ vb.DWordLength = cso->length;
+ }
+
+ /* If there are no buffers, do nothing. We can leave the stale
+ * 3DSTATE_VERTEX_BUFFERS in place - as long as there are no vertex
+ * elements that point to them, it should be fine.
+ */
+ if (!buffers)
+ return;
+
+ uint32_t *vb_pack_dest = &cso->vertex_buffers[1];
+
+ for (unsigned i = 0; i < count; i++) {
+ assert(!buffers[i].is_user_buffer);
+
+ iris_pack_state(GENX(VERTEX_BUFFER_STATE), vb_pack_dest, vb) {
+ vb.VertexBufferIndex = start_slot + i;
+ vb.MOCS = MOCS_WB;
+ vb.AddressModifyEnable = true;
+ vb.BufferPitch = buffers[i].stride;
+ //vb.BufferStartingAddress = ro_bo(bo, buffers[i].buffer_offset);
+ //vb.BufferSize = bo->size;
+ }
+
+ vb_pack_dest += GENX(VERTEX_BUFFER_STATE_length);
+ }
+
+ /* XXX: actually do something with this! */
+}
+
+struct iris_vertex_element_state {
+ uint32_t vertex_elements[1 + 33 * GENX(VERTEX_ELEMENT_STATE_length)];
+ uint32_t vf_instancing[GENX(3DSTATE_VF_INSTANCING_length)];
+ unsigned count;
+};
+
+static void *
+iris_create_vertex_elements(struct pipe_context *ctx,
+ unsigned count,
+ const struct pipe_vertex_element *state)
+{
+ struct iris_vertex_element_state *cso =
+ malloc(sizeof(struct iris_vertex_element_state));
+
+ cso->count = count;
+
+ /* TODO:
+ * - create edge flag one
+ * - create SGV ones
+ * - if those are necessary, use count + 1/2/3... OR in the length
+ */
+ iris_pack_state(GENX(3DSTATE_VERTEX_ELEMENTS), cso->vertex_elements, ve);
+
+ uint32_t *ve_pack_dest = &cso->vertex_elements[1];
+
+ for (int i = 0; i < count; i++) {
+ iris_pack_state(GENX(VERTEX_ELEMENT_STATE), ve_pack_dest, ve) {
+ ve.VertexBufferIndex = state[i].vertex_buffer_index;
+ ve.Valid = true;
+ ve.SourceElementOffset = state[i].src_offset;
+ ve.SourceElementFormat =
+ iris_isl_format_for_pipe_format(state[i].src_format);
+ }
+
+ iris_pack_state(GENX(3DSTATE_VF_INSTANCING), cso->vf_instancing, vi) {
+ vi.VertexElementIndex = i;
+ vi.InstancingEnable = state[i].instance_divisor > 0;
+ vi.InstanceDataStepRate = state[i].instance_divisor;
+ }
+
+ ve_pack_dest += GENX(VERTEX_ELEMENT_STATE_length);
+ }
+
+ return cso;
+}
+
+static void *
+iris_create_compute_state(struct pipe_context *ctx,
+ const struct pipe_compute_state *state)
+{
+ return malloc(1);
+}
+
+static struct pipe_stream_output_target *
+iris_create_stream_output_target(struct pipe_context *ctx,
+ struct pipe_resource *res,
+ unsigned buffer_offset,
+ unsigned buffer_size)
+{
+ struct pipe_stream_output_target *t =
+ CALLOC_STRUCT(pipe_stream_output_target);
+ if (!t)
+ return NULL;
+
+ pipe_reference_init(&t->reference, 1);
+ pipe_resource_reference(&t->buffer, res);
+ t->buffer_offset = buffer_offset;
+ t->buffer_size = buffer_size;
+ return t;
+}
+
+static void
+iris_stream_output_target_destroy(struct pipe_context *ctx,
+ struct pipe_stream_output_target *t)
+{
+ pipe_resource_reference(&t->buffer, NULL);
+ free(t);
+}
+
+static void
+iris_set_stream_output_targets(struct pipe_context *ctx,
+ unsigned num_targets,
+ struct pipe_stream_output_target **targets,
+ const unsigned *offsets)
+{
+}
+
+void
+iris_init_state_functions(struct pipe_context *ctx)
+{
+ ctx->create_blend_state = iris_create_blend_state;
+ ctx->create_depth_stencil_alpha_state = iris_create_dsa_state;
+ ctx->create_rasterizer_state = iris_create_rasterizer_state;
+ ctx->create_sampler_state = iris_create_sampler_state;
+ ctx->create_sampler_view = iris_create_sampler_view;
+ ctx->create_surface = iris_create_surface;
+ ctx->create_vertex_elements_state = iris_create_vertex_elements;
+ ctx->create_compute_state = iris_create_compute_state;
+ ctx->bind_blend_state = iris_bind_state;
+ ctx->bind_depth_stencil_alpha_state = iris_bind_state;
+ ctx->bind_sampler_states = iris_bind_sampler_states;
+ ctx->bind_fs_state = iris_bind_state;
+ ctx->bind_rasterizer_state = iris_bind_state;
+ ctx->bind_vertex_elements_state = iris_bind_state;
+ ctx->bind_compute_state = iris_bind_state;
+ ctx->bind_tcs_state = iris_bind_state;
+ ctx->bind_tes_state = iris_bind_state;
+ ctx->bind_gs_state = iris_bind_state;
+ ctx->bind_vs_state = iris_bind_state;
+ ctx->delete_blend_state = iris_delete_state;
+ ctx->delete_depth_stencil_alpha_state = iris_delete_state;
+ ctx->delete_fs_state = iris_delete_state;
+ ctx->delete_rasterizer_state = iris_delete_state;
+ ctx->delete_sampler_state = iris_delete_state;
+ ctx->delete_vertex_elements_state = iris_delete_state;
+ ctx->delete_compute_state = iris_delete_state;
+ ctx->delete_tcs_state = iris_delete_state;
+ ctx->delete_tes_state = iris_delete_state;
+ ctx->delete_gs_state = iris_delete_state;
+ ctx->delete_vs_state = iris_delete_state;
+ ctx->set_blend_color = iris_set_blend_color;
+ ctx->set_clip_state = iris_set_clip_state;
+ ctx->set_constant_buffer = iris_set_constant_buffer;
+ ctx->set_sampler_views = iris_set_sampler_views;
+ ctx->set_framebuffer_state = iris_set_framebuffer_state;
+ ctx->set_polygon_stipple = iris_set_polygon_stipple;
+ ctx->set_sample_mask = iris_set_sample_mask;
+ ctx->set_scissor_states = iris_set_scissor_states;
+ ctx->set_stencil_ref = iris_set_stencil_ref;
+ ctx->set_vertex_buffers = iris_set_vertex_buffers;
+ ctx->set_viewport_states = iris_set_viewport_states;
+ ctx->sampler_view_destroy = iris_sampler_view_destroy;
+ ctx->surface_destroy = iris_surface_destroy;
+ ctx->draw_vbo = iris_draw_vbo;
+ ctx->launch_grid = iris_launch_grid;
+ ctx->create_stream_output_target = iris_create_stream_output_target;
+ ctx->stream_output_target_destroy = iris_stream_output_target_destroy;
+ ctx->set_stream_output_targets = iris_set_stream_output_targets;
+}
diff --git a/src/gallium/drivers/iris/meson.build b/src/gallium/drivers/iris/meson.build
new file mode 100644
index 00000000000..4728badd54b
--- /dev/null
+++ b/src/gallium/drivers/iris/meson.build
@@ -0,0 +1,68 @@
+# Copyright © 2017 Intel Corporation
+#
+# 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.
+
+files_libiris = files(
+ 'iris_batch.c',
+ 'iris_batch.h',
+ 'iris_bufmgr.c',
+ 'iris_bufmgr.h',
+ 'iris_context.h',
+ 'iris_formats.c',
+ 'iris_pipe.c',
+ 'iris_program.c',
+ 'iris_resource.c',
+ 'iris_resource.h',
+ 'iris_screen.c',
+ 'iris_screen.h',
+)
+
+iris_gen_libs = []
+foreach v : ['90', '100']
+ _lib = static_library(
+ 'libiris_gen@0@'.format(v),
+ ['iris_state.c', gen_xml_pack],
+ include_directories : [inc_common, inc_intel],
+ c_args : [c_vis_args, no_override_init_args,
+ '-DGEN_VERSIONx10=@0@'.format(v)],
+ dependencies : [dep_libdrm],
+ )
+ iris_gen_libs += _lib
+endforeach
+
+libiris = static_library(
+ 'iris',
+ [files_libiris, gen_xml_pack, nir_opcodes_h, nir_builder_opcodes_h],
+ include_directories : [
+ inc_src, inc_include, inc_gallium, inc_gallium_aux, inc_intel, inc_nir,
+ inc_gallium_drivers,
+ # these should not be necessary, but main/macros.h...
+ inc_mesa, inc_mapi
+ ],
+ c_args : [c_vis_args],
+ cpp_args : [cpp_vis_args],
+ dependencies : [dep_libdrm, dep_valgrind],
+ link_with : [iris_gen_libs, libintel_common, libintel_compiler, libintel_dev,
+ libisl, libblorp],
+)
+
+driver_iris = declare_dependency(
+ compile_args : '-DGALLIUM_IRIS',
+ link_with : [libiris, libiriswinsys],
+)
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-01 19:39:48 +0000