aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--.gitignore1
-rw-r--r--CMakeLists.txt8
-rw-r--r--icd/CMakeLists.txt20
-rw-r--r--icd/README.md1
-rw-r--r--icd/common/CMakeLists.txt4
-rw-r--r--icd/common/icd-alloc.c6
-rw-r--r--icd/common/icd-format.h6
-rw-r--r--icd/common/icd-utils.h22
-rw-r--r--icd/common/icd.h10
-rw-r--r--icd/nulldrv/CMakeLists.txt33
-rw-r--r--icd/nulldrv/README.md3
-rw-r--r--icd/nulldrv/XGL_nulldrv.def32
-rw-r--r--icd/nulldrv/nulldrv.c1873
-rw-r--r--icd/nulldrv/nulldrv.h213
-rw-r--r--include/xglWsiWinExt.h9
15 files changed, 2224 insertions, 17 deletions
diff --git a/.gitignore b/.gitignore
index 9389c831..cc557d24 100644
--- a/.gitignore
+++ b/.gitignore
@@ -20,3 +20,4 @@ layers/xgl_generic_intercept_proc_helper.h
layers/xgl_struct_string_helper.h
layers/xgl_struct_wrappers.cpp
layers/xgl_struct_wrappers.h
+_out64
diff --git a/CMakeLists.txt b/CMakeLists.txt
index fdfe3c9a..9f84d18d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -41,10 +41,10 @@ endif()
# icd: Device dependent (DD) XGL components
# tests: XGL tests
add_subdirectory(loader)
+add_subdirectory(icd)
if (NOT WIN32)
- add_subdirectory(icd)
add_subdirectory(tests)
endif()
- add_subdirectory(layers)
- add_subdirectory(demos)
- add_subdirectory(tools/glave)
+add_subdirectory(layers)
+add_subdirectory(demos)
+add_subdirectory(tools/glave)
diff --git a/icd/CMakeLists.txt b/icd/CMakeLists.txt
index 9124ae3c..74d24144 100644
--- a/icd/CMakeLists.txt
+++ b/icd/CMakeLists.txt
@@ -1,2 +1,20 @@
+function(add_compiler_flag flag)
+ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}" PARENT_SCOPE)
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}" PARENT_SCOPE)
+endfunction()
+
+if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+ add_compiler_flag("-DPLATFORM_LINUX=1")
+ add_compiler_flag("-DPLATFORM_POSIX=1")
+elseif (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+ add_compiler_flag("-DPLATFORM_WINDOWS=1")
+else()
+ message(FATAL_ERROR "Platform unset, build will fail--stopping at CMake time.")
+endif()
+
add_subdirectory(common)
-add_subdirectory(intel)
+if (WIN32)
+ add_subdirectory(nulldrv)
+else()
+ add_subdirectory(intel)
+endif()
diff --git a/icd/README.md b/icd/README.md
index 0edaa05d..2c0b009a 100644
--- a/icd/README.md
+++ b/icd/README.md
@@ -1,6 +1,7 @@
This sample driver implementation provide multiple subcomponents required to build and test an Installable Client Driver (ICD):
- [Common Infrastructure](common)
- [Implementation for Intel GPUs](intel)
+- [Null driver](nulldrv)
- [*Sample Driver Tests*](../tests)
- Now includes Golden images to verify xgl_render_tests rendering.
diff --git a/icd/common/CMakeLists.txt b/icd/common/CMakeLists.txt
index e1946cf3..235601d1 100644
--- a/icd/common/CMakeLists.txt
+++ b/icd/common/CMakeLists.txt
@@ -1,3 +1,7 @@
+if (WIN32)
+ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_CRT_SECURE_NO_WARNINGS")
+endif()
+
set(sources
icd-alloc.c
icd-format.c
diff --git a/icd/common/icd-alloc.c b/icd/common/icd-alloc.c
index 30aad783..bbe27819 100644
--- a/icd/common/icd-alloc.c
+++ b/icd/common/icd-alloc.c
@@ -42,7 +42,7 @@ static void *default_alloc(void *user_data, size_t size, size_t alignment,
{
if (alignment <= 1) {
return malloc(size);
- } else if (u_is_pow2(alignment)) {
+ } else if (u_is_pow2((uint32_t) alignment)) {
if (alignment < sizeof(void *)) {
assert(u_is_pow2(sizeof(void*)));
alignment = sizeof(void *);
@@ -50,7 +50,11 @@ static void *default_alloc(void *user_data, size_t size, size_t alignment,
size = (size + alignment - 1) & ~(alignment - 1);
+#if defined(PLATFORM_LINUX)
return aligned_alloc(alignment, size);
+#else
+ return _aligned_malloc(size, alignment);
+#endif
}
else {
return NULL;
diff --git a/icd/common/icd-format.h b/icd/common/icd-format.h
index 3ab9be8e..7aa50019 100644
--- a/icd/common/icd-format.h
+++ b/icd/common/icd-format.h
@@ -31,14 +31,14 @@
#include <stdbool.h>
#include "icd.h"
-static inline bool icd_format_is_undef(XGL_FORMAT format)
+STATIC_INLINE bool icd_format_is_undef(XGL_FORMAT format)
{
return (format == XGL_FMT_UNDEFINED);
}
bool icd_format_is_ds(XGL_FORMAT format);
-static inline bool icd_format_is_color(XGL_FORMAT format)
+STATIC_INLINE bool icd_format_is_color(XGL_FORMAT format)
{
return !(icd_format_is_undef(format) || icd_format_is_ds(format));
}
@@ -53,7 +53,7 @@ bool icd_format_is_srgb(XGL_FORMAT format);
bool icd_format_is_compressed(XGL_FORMAT format);
-static inline int icd_format_get_block_width(XGL_FORMAT format)
+STATIC_INLINE int icd_format_get_block_width(XGL_FORMAT format)
{
/* all compressed formats use 4x4 blocks */
return (icd_format_is_compressed(format)) ? 4 : 1;
diff --git a/icd/common/icd-utils.h b/icd/common/icd-utils.h
index 5304d158..aad6c3e5 100644
--- a/icd/common/icd-utils.h
+++ b/icd/common/icd-utils.h
@@ -31,7 +31,9 @@
#include <stdbool.h>
#include <stdint.h>
#include <assert.h>
+#if defined(PLATFORM_LINUX)
#include <strings.h> /* for ffs() */
+#endif
#include "icd.h"
#if defined(NDEBUG) && defined(__GNUC__)
@@ -63,28 +65,32 @@
/**
* Return true if val is power of two, or zero.
*/
-static inline bool u_is_pow2(unsigned int val)
+STATIC_INLINE bool u_is_pow2(unsigned int val)
{
return ((val & (val - 1)) == 0);
}
-static inline int u_ffs(int val)
+STATIC_INLINE int u_ffs(int val)
{
- return ffs(val);
+#if defined(PLATFORM_LINUX)
+ return ffs(val);
+#else
+ return __lzcnt(val) + 1;
+#endif
}
-static inline unsigned int u_align(unsigned int val, unsigned alignment)
+STATIC_INLINE unsigned int u_align(unsigned int val, unsigned alignment)
{
assert(alignment && u_is_pow2(alignment));
return (val + alignment - 1) & ~(alignment - 1);
}
-static inline unsigned int u_minify(unsigned int val, unsigned level)
+STATIC_INLINE unsigned int u_minify(unsigned int val, unsigned level)
{
return (val >> level) ? val >> level : 1;
}
-static inline uint32_t u_fui(float f)
+STATIC_INLINE uint32_t u_fui(float f)
{
union {
float f;
@@ -94,7 +100,7 @@ static inline uint32_t u_fui(float f)
return u.ui;
}
-static inline float u_uif(uint32_t ui)
+STATIC_INLINE float u_uif(uint32_t ui)
{
union {
float f;
@@ -104,7 +110,7 @@ static inline float u_uif(uint32_t ui)
return u.f;
}
-static inline int u_iround(float f)
+STATIC_INLINE int u_iround(float f)
{
if (f >= 0.0f)
return (int) (f + 0.5f);
diff --git a/icd/common/icd.h b/icd/common/icd.h
index 1e053c8a..da5e0079 100644
--- a/icd/common/icd.h
+++ b/icd/common/icd.h
@@ -29,9 +29,19 @@
#define ICD_H
#include <xgl.h>
+#include <xglPlatform.h>
#include <xglDbg.h>
+
+#if defined(PLATFORM_LINUX)
+
#include <xglWsiX11Ext.h>
+#else
+
+#include <xglWsiWinExt.h>
+
+#endif
+
#if defined(__GNUC__) && __GNUC__ >= 4
# define ICD_EXPORT __attribute__((visibility("default")))
#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
diff --git a/icd/nulldrv/CMakeLists.txt b/icd/nulldrv/CMakeLists.txt
new file mode 100644
index 00000000..b11840b6
--- /dev/null
+++ b/icd/nulldrv/CMakeLists.txt
@@ -0,0 +1,33 @@
+# Create the nulldrv XGL DRI library
+
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DXGL_PROTOTYPES")
+
+add_custom_command(OUTPUT nulldrv_gpa.c
+ COMMAND ${PROJECT_SOURCE_DIR}/xgl-generate.py icd-get-proc-addr > nulldrv_gpa.c
+ DEPENDS ${PROJECT_SOURCE_DIR}/xgl-generate.py ${PROJECT_SOURCE_DIR}/xgl.py)
+
+set(sources
+ nulldrv.c
+ nulldrv_gpa.c
+ )
+
+set(definitions "")
+
+set(libraries
+ icd)
+
+if (WIN32)
+ list(APPEND definitions -DENABLE_WSI_WINDOWS)
+endif()
+
+add_library(XGL_nulldrv SHARED ${sources})
+target_compile_definitions(XGL_nulldrv PRIVATE ${definitions})
+target_include_directories(XGL_nulldrv PRIVATE ${include_dirs})
+target_link_libraries(XGL_nulldrv ${libraries})
+
+if (WIN32)
+ # Add in the DLL "map" file for xglGetProcAddr()
+ set_target_properties(XGL_nulldrv PROPERTIES
+ LINK_FLAGS "/DEF:${PROJECT_SOURCE_DIR}/icd/nulldrv/XGL_nulldrv.def")
+endif()
+
diff --git a/icd/nulldrv/README.md b/icd/nulldrv/README.md
new file mode 100644
index 00000000..0772b7bd
--- /dev/null
+++ b/icd/nulldrv/README.md
@@ -0,0 +1,3 @@
+# Null XGL Driver
+
+This directory provides a null XGL driver
diff --git a/icd/nulldrv/XGL_nulldrv.def b/icd/nulldrv/XGL_nulldrv.def
new file mode 100644
index 00000000..bd4b499e
--- /dev/null
+++ b/icd/nulldrv/XGL_nulldrv.def
@@ -0,0 +1,32 @@
+;;;; Begin Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; XGL
+;
+; Copyright (C) 2015 LunarG, Inc.
+;
+; Permission is hereby granted, free of charge, to any person obtaining a
+; copy of this software and associated documentation files (the "Software"),
+; to deal in the Software without restriction, including without limitation
+; the rights to use, copy, modify, merge, publish, distribute, sublicense,
+; and/or sell copies of the Software, and to permit persons to whom the
+; Software is furnished to do so, subject to the following conditions:
+;
+; The above copyright notice and this permission notice shall be included
+; in all copies or substantial portions of the Software.
+;
+; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+; THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+; LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+; FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+; DEALINGS IN THE SOFTWARE.
+;;;; End Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; The following is required on Windows, for exporting symbols from the DLL
+
+LIBRARY XGL_nulldrv
+EXPORTS
+ xglGetProcAddr
+ xglCreateInstance
+ xglEnumerateGpus
+ xglDestroyInstance
diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c
new file mode 100644
index 00000000..cfada537
--- /dev/null
+++ b/icd/nulldrv/nulldrv.c
@@ -0,0 +1,1873 @@
+/*
+ * XGL null driver
+ *
+ * Copyright (C) 2015 LunarG, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include "nulldrv.h"
+
+static const char * const nulldrv_gpu_exts[NULLDRV_EXT_COUNT] = {
+#ifdef ENABLE_WSI_X11
+ [NULLDRV_EXT_WSI_X11] = "XGL_WSI_X11",
+#endif
+#ifdef ENABLE_WSI_WINDOWS
+ [NULLDRV_EXT_WSI_WINDOWS] = "XGL_WSI_WINDOWS",
+#endif
+};
+
+static struct nulldrv_base *nulldrv_base(XGL_BASE_OBJECT base)
+{
+ return (struct nulldrv_base *) base;
+}
+
+static XGL_RESULT nulldrv_base_get_info(struct nulldrv_base *base, int type,
+ size_t *size, void *data)
+{
+ XGL_RESULT ret = XGL_SUCCESS;
+ size_t s;
+ uint32_t *count;
+
+ switch (type) {
+ case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+ {
+ XGL_MEMORY_REQUIREMENTS *mem_req = data;
+ s = sizeof(XGL_MEMORY_REQUIREMENTS);
+ *size = s;
+ if (data == NULL)
+ return ret;
+ memset(data, 0, s);
+ mem_req->memType = XGL_MEMORY_TYPE_OTHER;
+ break;
+ }
+ case XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
+ *size = sizeof(uint32_t);
+ if (data == NULL)
+ return ret;
+ count = (uint32_t *) data;
+ *count = 1;
+ break;
+ case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
+ s = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
+ *size = s;
+ if (data == NULL)
+ return ret;
+ memset(data, 0, s);
+ break;
+ case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+ s = sizeof(XGL_BUFFER_MEMORY_REQUIREMENTS);
+ *size = s;
+ if (data == NULL)
+ return ret;
+ memset(data, 0, s);
+ break;
+ default:
+ ret = XGL_ERROR_INVALID_VALUE;
+ break;
+ }
+
+ return ret;
+}
+
+static struct nulldrv_base *nulldrv_base_create(struct nulldrv_dev *dev,
+ size_t obj_size,
+ XGL_DBG_OBJECT_TYPE type)
+{
+ struct nulldrv_base *base;
+
+ if (!obj_size)
+ obj_size = sizeof(*base);
+
+ assert(obj_size >= sizeof(*base));
+
+ base = (struct nulldrv_base*)icd_alloc(obj_size, 0, XGL_SYSTEM_ALLOC_API_OBJECT);
+ if (!base)
+ return NULL;
+
+ memset(base, 0, obj_size);
+
+ // Initialize pointer to loader's dispatch table with ICD_LOADER_MAGIC
+ set_loader_magic_value(base);
+
+ if (dev == NULL) {
+ /*
+ * dev is NULL when we are creating the base device object
+ * Set dev now so that debug setup happens correctly
+ */
+ dev = (struct nulldrv_dev *) base;
+ }
+
+
+ base->get_info = NULL;
+
+ return base;
+}
+
+static XGL_RESULT nulldrv_gpu_add(int devid, const char *primary_node,
+ const char *render_node, struct nulldrv_gpu **gpu_ret)
+{
+ struct nulldrv_gpu *gpu;
+
+ gpu = icd_alloc(sizeof(*gpu), 0, XGL_SYSTEM_ALLOC_API_OBJECT);
+ if (!gpu)
+ return XGL_ERROR_OUT_OF_MEMORY;
+ memset(gpu, 0, sizeof(*gpu));
+
+ // Initialize pointer to loader's dispatch table with ICD_LOADER_MAGIC
+ set_loader_magic_value(gpu);
+
+ *gpu_ret = gpu;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT nulldrv_queue_create(struct nulldrv_dev *dev,
+ enum nulldrv_gpu_engine_type engine,
+ struct nulldrv_queue **queue_ret)
+{
+ struct nulldrv_queue *queue;
+
+ queue = (struct nulldrv_queue *) nulldrv_base_create(dev, sizeof(*queue),
+ XGL_DBG_OBJECT_QUEUE);
+ if (!queue)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ queue->dev = dev;
+
+ *queue_ret = queue;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT dev_create_queues(struct nulldrv_dev *dev,
+ const XGL_DEVICE_QUEUE_CREATE_INFO *queues,
+ uint32_t count)
+{
+ uint32_t i;
+
+ if (!count)
+ return XGL_ERROR_INVALID_POINTER;
+
+ for (i = 0; i < count; i++) {
+ const XGL_DEVICE_QUEUE_CREATE_INFO *q = &queues[i];
+ XGL_RESULT ret = XGL_SUCCESS;
+
+ if (q->queueCount == 1 && !dev->queues[q->queueNodeIndex]) {
+ ret = nulldrv_queue_create(dev, q->queueNodeIndex,
+ &dev->queues[q->queueNodeIndex]);
+ }
+ else {
+ ret = XGL_ERROR_INVALID_POINTER;
+ }
+
+ if (ret != XGL_SUCCESS) {
+ return ret;
+ }
+ }
+
+ return XGL_SUCCESS;
+}
+
+static enum nulldrv_ext_type nulldrv_gpu_lookup_extension(const struct nulldrv_gpu *gpu,
+ const char *ext)
+{
+ enum nulldrv_ext_type type;
+
+ for (type = 0; type < ARRAY_SIZE(nulldrv_gpu_exts); type++) {
+ if (nulldrv_gpu_exts[type] && strcmp(nulldrv_gpu_exts[type], ext) == 0)
+ break;
+ }
+
+ assert(type < NULLDRV_EXT_COUNT || type == NULLDRV_EXT_INVALID);
+
+ return type;
+}
+
+static XGL_RESULT nulldrv_desc_pool_create(struct nulldrv_dev *dev,
+ struct nulldrv_desc_pool **pool_ret)
+{
+ const uint32_t surface_count = 1;
+ const uint32_t sampler_count = 1;
+ struct nulldrv_desc_pool *pool;
+
+ pool = malloc(sizeof(*pool));
+ if (!pool)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ memset(pool, 0, sizeof(*pool));
+
+ pool->surface_desc_size = 0;
+ pool->sampler_desc_size = 0;
+
+ *pool_ret = pool;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT nulldrv_dev_create(struct nulldrv_gpu *gpu,
+ const XGL_DEVICE_CREATE_INFO *info,
+ struct nulldrv_dev **dev_ret)
+{
+ struct nulldrv_dev *dev;
+ uint32_t i;
+ XGL_RESULT ret;
+
+ dev = (struct nulldrv_dev *) nulldrv_base_create(NULL, sizeof(*dev),
+ XGL_DBG_OBJECT_DEVICE);
+ if (!dev)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ for (i = 0; i < info->extensionCount; i++) {
+ const enum nulldrv_ext_type ext = nulldrv_gpu_lookup_extension(gpu,
+ info->ppEnabledExtensionNames[i]);
+
+ if (ext == NULLDRV_EXT_INVALID)
+ return XGL_ERROR_INVALID_EXTENSION;
+
+ dev->exts[ext] = true;
+ }
+
+ ret = nulldrv_desc_pool_create(dev, &dev->desc_pool);
+ if (ret != XGL_SUCCESS) {
+ return ret;
+ }
+
+ ret = dev_create_queues(dev, info->pRequestedQueues,
+ info->queueRecordCount);
+ if (ret != XGL_SUCCESS) {
+ return ret;
+ }
+
+ *dev_ret = dev;
+
+ return XGL_SUCCESS;
+}
+
+static struct nulldrv_gpu *nulldrv_gpu(XGL_PHYSICAL_GPU gpu)
+{
+ return (struct nulldrv_gpu *) gpu;
+}
+
+static XGL_RESULT nulldrv_rt_view_create(struct nulldrv_dev *dev,
+ const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO *info,
+ struct nulldrv_rt_view **view_ret)
+{
+ struct nulldrv_rt_view *view;
+
+ view = (struct nulldrv_rt_view *) nulldrv_base_create(dev, sizeof(*view),
+ XGL_DBG_OBJECT_COLOR_TARGET_VIEW);
+ if (!view)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ *view_ret = view;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT nulldrv_fence_create(struct nulldrv_dev *dev,
+ const XGL_FENCE_CREATE_INFO *info,
+ struct nulldrv_fence **fence_ret)
+{
+ struct nulldrv_fence *fence;
+
+ fence = (struct nulldrv_fence *) nulldrv_base_create(dev, sizeof(*fence),
+ XGL_DBG_OBJECT_FENCE);
+ if (!fence)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ *fence_ret = fence;
+
+ return XGL_SUCCESS;
+}
+
+static struct nulldrv_dev *nulldrv_dev(XGL_DEVICE dev)
+{
+ return (struct nulldrv_dev *) dev;
+}
+
+static struct nulldrv_img *nulldrv_img_from_base(struct nulldrv_base *base)
+{
+ return (struct nulldrv_img *) base;
+}
+
+
+static XGL_RESULT img_get_info(struct nulldrv_base *base, int type,
+ size_t *size, void *data)
+{
+ struct nulldrv_img *img = nulldrv_img_from_base(base);
+ XGL_RESULT ret = XGL_SUCCESS;
+
+ switch (type) {
+ case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+ {
+ XGL_MEMORY_REQUIREMENTS *mem_req = data;
+
+ *size = sizeof(XGL_MEMORY_REQUIREMENTS);
+ if (data == NULL)
+ return ret;
+ mem_req->size = img->total_size;
+ mem_req->alignment = 4096;
+ mem_req->memType = XGL_MEMORY_TYPE_IMAGE;
+ }
+ break;
+ case XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS:
+ {
+ XGL_IMAGE_MEMORY_REQUIREMENTS *img_req = data;
+
+ *size = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
+ if (data == NULL)
+ return ret;
+ img_req->usage = img->usage;
+ img_req->formatClass = img->format_class;
+ img_req->samples = img->samples;
+ }
+ break;
+ case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+ {
+ XGL_BUFFER_MEMORY_REQUIREMENTS *buf_req = data;
+
+ *size = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
+ if (data == NULL)
+ return ret;
+ buf_req->usage = img->usage;
+ }
+ break;
+ default:
+ ret = nulldrv_base_get_info(base, type, size, data);
+ break;
+ }
+
+ return ret;
+}
+
+static XGL_RESULT nulldrv_img_create(struct nulldrv_dev *dev,
+ const XGL_IMAGE_CREATE_INFO *info,
+ bool scanout,
+ struct nulldrv_img **img_ret)
+{
+ struct nulldrv_img *img;
+
+ img = (struct nulldrv_img *) nulldrv_base_create(dev, sizeof(*img),
+ XGL_DBG_OBJECT_IMAGE);
+ if (!img)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ img->type = info->imageType;
+ img->depth = info->extent.depth;
+ img->mip_levels = info->mipLevels;
+ img->array_size = info->arraySize;
+ img->usage = info->usage;
+ if (info->tiling == XGL_LINEAR_TILING)
+ img->format_class = XGL_IMAGE_FORMAT_CLASS_LINEAR;
+ else
+ img->format_class = icd_format_get_class(info->format);
+ img->samples = info->samples;
+
+ img->obj.base.get_info = img_get_info;
+
+ *img_ret = img;
+
+ return XGL_SUCCESS;
+}
+
+static struct nulldrv_img *nulldrv_img(XGL_IMAGE image)
+{
+ return (struct nulldrv_img *) image;
+}
+
+static XGL_RESULT nulldrv_mem_alloc(struct nulldrv_dev *dev,
+ const XGL_MEMORY_ALLOC_INFO *info,
+ struct nulldrv_mem **mem_ret)
+{
+ struct nulldrv_mem *mem;
+
+ mem = (struct nulldrv_mem *) nulldrv_base_create(dev, sizeof(*mem),
+ XGL_DBG_OBJECT_GPU_MEMORY);
+ if (!mem)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ mem->bo = _aligned_malloc(info->allocationSize, 4096);
+ if (!mem->bo) {
+ return XGL_ERROR_OUT_OF_MEMORY;
+ }
+
+ mem->size = info->allocationSize;
+
+ *mem_ret = mem;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT nulldrv_ds_view_create(struct nulldrv_dev *dev,
+ const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO *info,
+ struct nulldrv_ds_view **view_ret)
+{
+ struct nulldrv_img *img = nulldrv_img(info->image);
+ struct nulldrv_ds_view *view;
+
+ view = (struct nulldrv_ds_view *) nulldrv_base_create(dev, sizeof(*view),
+ XGL_DBG_OBJECT_DEPTH_STENCIL_VIEW);
+ if (!view)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ view->img = img;
+
+ view->array_size = info->arraySize;
+
+ *view_ret = view;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT nulldrv_sampler_create(struct nulldrv_dev *dev,
+ const XGL_SAMPLER_CREATE_INFO *info,
+ struct nulldrv_sampler **sampler_ret)
+{
+ struct nulldrv_sampler *sampler;
+
+ sampler = (struct nulldrv_sampler *) nulldrv_base_create(dev,
+ sizeof(*sampler), XGL_DBG_OBJECT_SAMPLER);
+ if (!sampler)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ *sampler_ret = sampler;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT nulldrv_img_view_create(struct nulldrv_dev *dev,
+ const XGL_IMAGE_VIEW_CREATE_INFO *info,
+ struct nulldrv_img_view **view_ret)
+{
+ struct nulldrv_img *img = nulldrv_img(info->image);
+ struct nulldrv_img_view *view;
+ uint32_t mip_levels, array_size;
+ XGL_CHANNEL_MAPPING state_swizzles;
+
+ mip_levels = info->subresourceRange.mipLevels;
+
+ array_size = info->subresourceRange.arraySize;
+
+ view = (struct nulldrv_img_view *) nulldrv_base_create(dev, sizeof(*view),
+ XGL_DBG_OBJECT_IMAGE_VIEW);
+ if (!view)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ view->img = img;
+ view->min_lod = info->minLod;
+
+ state_swizzles = info->channels;
+
+ view->cmd_len = 8;
+
+ *view_ret = view;
+
+ return XGL_SUCCESS;
+}
+
+static void *nulldrv_mem_map(struct nulldrv_mem *mem, XGL_FLAGS flags)
+{
+ return mem->bo;
+}
+
+static struct nulldrv_mem *nulldrv_mem(XGL_GPU_MEMORY mem)
+{
+ return (struct nulldrv_mem *) mem;
+}
+
+static struct nulldrv_buf *nulldrv_buf_from_base(struct nulldrv_base *base)
+{
+ return (struct nulldrv_buf *) base;
+}
+
+static XGL_RESULT buf_get_info(struct nulldrv_base *base, int type,
+ size_t *size, void *data)
+{
+ struct nulldrv_buf *buf = nulldrv_buf_from_base(base);
+ XGL_RESULT ret = XGL_SUCCESS;
+
+ switch (type) {
+ case XGL_INFO_TYPE_MEMORY_REQUIREMENTS:
+ {
+ XGL_MEMORY_REQUIREMENTS *mem_req = data;
+
+ *size = sizeof(XGL_MEMORY_REQUIREMENTS);
+ if (data == NULL)
+ return ret;
+
+ mem_req->size = buf->size;
+ mem_req->alignment = 4096;
+ mem_req->memType = XGL_MEMORY_TYPE_BUFFER;
+
+ }
+ break;
+ case XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS:
+ {
+ XGL_BUFFER_MEMORY_REQUIREMENTS *buf_req = data;
+
+ *size = sizeof(XGL_BUFFER_MEMORY_REQUIREMENTS);
+ if (data == NULL)
+ return ret;
+ buf_req->usage = buf->usage;
+ }
+ break;
+ default:
+ ret = nulldrv_base_get_info(base, type, size, data);
+ break;
+ }
+
+ return ret;
+}
+
+static XGL_RESULT nulldrv_buf_create(struct nulldrv_dev *dev,
+ const XGL_BUFFER_CREATE_INFO *info,
+ struct nulldrv_buf **buf_ret)
+{
+ struct nulldrv_buf *buf;
+
+ buf = (struct nulldrv_buf *) nulldrv_base_create(dev, sizeof(*buf),
+ XGL_DBG_OBJECT_BUFFER);
+ if (!buf)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ buf->size = info->size;
+ buf->usage = info->usage;
+
+ buf->obj.base.get_info = buf_get_info;
+
+ *buf_ret = buf;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT nulldrv_desc_layout_create(struct nulldrv_dev *dev,
+ XGL_FLAGS stage_flags,
+ const uint32_t *bind_points,
+ const struct nulldrv_desc_layout *prior_layout,
+ const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO *info,
+ struct nulldrv_desc_layout **layout_ret)
+{
+ struct nulldrv_desc_layout *layout;
+
+ layout = (struct nulldrv_desc_layout *)
+ nulldrv_base_create(dev, sizeof(*layout),
+ XGL_DBG_OBJECT_DESCRIPTOR_SET_LAYOUT);
+ if (!layout)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ *layout_ret = layout;
+
+ return XGL_SUCCESS;
+}
+
+static struct nulldrv_desc_layout *nulldrv_desc_layout(XGL_DESCRIPTOR_SET_LAYOUT layout)
+{
+ return (struct nulldrv_desc_layout *) layout;
+}
+
+static XGL_RESULT shader_create(struct nulldrv_dev *dev,
+ const XGL_SHADER_CREATE_INFO *info,
+ struct nulldrv_shader **sh_ret)
+{
+ const struct icd_bil_header *bil =
+ (const struct icd_bil_header *) info->pCode;
+ struct nulldrv_shader *sh;
+
+ sh = (struct nulldrv_shader *) nulldrv_base_create(dev, sizeof(*sh),
+ XGL_DBG_OBJECT_SHADER);
+ if (!sh)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ *sh_ret = sh;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT graphics_pipeline_create(struct nulldrv_dev *dev,
+ const XGL_GRAPHICS_PIPELINE_CREATE_INFO *info_,
+ struct nulldrv_pipeline **pipeline_ret)
+{
+ struct nulldrv_pipeline *pipeline;
+
+ pipeline = (struct nulldrv_pipeline *)
+ nulldrv_base_create(dev, sizeof(*pipeline),
+ XGL_DBG_OBJECT_GRAPHICS_PIPELINE);
+ if (!pipeline)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ *pipeline_ret = pipeline;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT nulldrv_viewport_state_create(struct nulldrv_dev *dev,
+ const XGL_DYNAMIC_VP_STATE_CREATE_INFO *info,
+ struct nulldrv_dynamic_vp **state_ret)
+{
+ struct nulldrv_dynamic_vp *state;
+
+ state = (struct nulldrv_dynamic_vp *) nulldrv_base_create(dev,
+ sizeof(*state), XGL_DBG_OBJECT_VIEWPORT_STATE);
+ if (!state)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ *state_ret = state;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT nulldrv_raster_state_create(struct nulldrv_dev *dev,
+ const XGL_DYNAMIC_RS_STATE_CREATE_INFO *info,
+ struct nulldrv_dynamic_rs **state_ret)
+{
+ struct nulldrv_dynamic_rs *state;
+
+ state = (struct nulldrv_dynamic_rs *) nulldrv_base_create(dev,
+ sizeof(*state), XGL_DBG_OBJECT_RASTER_STATE);
+ if (!state)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ *state_ret = state;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT nulldrv_blend_state_create(struct nulldrv_dev *dev,
+ const XGL_DYNAMIC_CB_STATE_CREATE_INFO *info,
+ struct nulldrv_dynamic_cb **state_ret)
+{
+ struct nulldrv_dynamic_cb *state;
+
+ state = (struct nulldrv_dynamic_cb *) nulldrv_base_create(dev,
+ sizeof(*state), XGL_DBG_OBJECT_COLOR_BLEND_STATE);
+ if (!state)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ *state_ret = state;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT nulldrv_ds_state_create(struct nulldrv_dev *dev,
+ const XGL_DYNAMIC_DS_STATE_CREATE_INFO *info,
+ struct nulldrv_dynamic_ds **state_ret)
+{
+ struct nulldrv_dynamic_ds *state;
+
+ state = (struct nulldrv_dynamic_ds *) nulldrv_base_create(dev,
+ sizeof(*state), XGL_DBG_OBJECT_DEPTH_STENCIL_STATE);
+ if (!state)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ *state_ret = state;
+
+ return XGL_SUCCESS;
+}
+
+
+static XGL_RESULT nulldrv_cmd_create(struct nulldrv_dev *dev,
+ const XGL_CMD_BUFFER_CREATE_INFO *info,
+ struct nulldrv_cmd **cmd_ret)
+{
+ int pipeline_select;
+ struct nulldrv_cmd *cmd;
+
+ pipeline_select = 0;
+
+ cmd = (struct nulldrv_cmd *) nulldrv_base_create(dev, sizeof(*cmd),
+ XGL_DBG_OBJECT_CMD_BUFFER);
+ if (!cmd)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ *cmd_ret = cmd;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT nulldrv_desc_region_create(struct nulldrv_dev *dev,
+ XGL_DESCRIPTOR_REGION_USAGE usage,
+ uint32_t max_sets,
+ const XGL_DESCRIPTOR_REGION_CREATE_INFO *info,
+ struct nulldrv_desc_region **region_ret)
+{
+ struct nulldrv_desc_region *region;
+
+ region = (struct nulldrv_desc_region *)
+ nulldrv_base_create(dev, sizeof(*region),
+ XGL_DBG_OBJECT_DESCRIPTOR_REGION);
+ if (!region)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ region->dev = dev;
+
+ *region_ret = region;
+
+ return XGL_SUCCESS;
+}
+
+static XGL_RESULT nulldrv_desc_set_create(struct nulldrv_dev *dev,
+ struct nulldrv_desc_region *region,
+ XGL_DESCRIPTOR_SET_USAGE usage,
+ const struct nulldrv_desc_layout *layout,
+ struct nulldrv_desc_set **set_ret)
+{
+ struct nulldrv_desc_set *set;
+
+ set = (struct nulldrv_desc_set *)
+ nulldrv_base_create(dev, sizeof(*set),
+ XGL_DBG_OBJECT_DESCRIPTOR_SET);
+ if (!set)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ set->pool = dev->desc_pool;
+ set->layout = layout;
+ *set_ret = set;
+
+ return XGL_SUCCESS;
+}
+
+static struct nulldrv_desc_region *nulldrv_desc_region(XGL_DESCRIPTOR_REGION region)
+{
+ return (struct nulldrv_desc_region *) region;
+}
+
+static XGL_RESULT nulldrv_fb_create(struct nulldrv_dev *dev,
+ const XGL_FRAMEBUFFER_CREATE_INFO* info,
+ struct nulldrv_framebuffer ** fb_ret)
+{
+
+ struct nulldrv_framebuffer *fb;
+ fb = (struct nulldrv_framebuffer *) nulldrv_base_create(dev, sizeof(*fb),
+ XGL_DBG_OBJECT_FRAMEBUFFER);
+ if (!fb)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ *fb_ret = fb;
+
+ return XGL_SUCCESS;
+
+}
+
+static XGL_RESULT nulldrv_render_pass_create(struct nulldrv_dev *dev,
+ const XGL_RENDER_PASS_CREATE_INFO* info,
+ struct nulldrv_render_pass** rp_ret)
+{
+ struct nulldrv_render_pass *rp;
+ rp = (struct nulldrv_render_pass *) nulldrv_base_create(dev, sizeof(*rp),
+ XGL_DBG_OBJECT_RENDER_PASS);
+ if (!rp)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ *rp_ret = rp;
+
+ return XGL_SUCCESS;
+}
+
+
+//*********************************************
+// Driver entry points
+//*********************************************
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateBuffer(
+ XGL_DEVICE device,
+ const XGL_BUFFER_CREATE_INFO* pCreateInfo,
+ XGL_BUFFER* pBuffer)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_buf_create(dev, pCreateInfo, (struct nulldrv_buf **) pBuffer);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateCommandBuffer(
+ XGL_DEVICE device,
+ const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo,
+ XGL_CMD_BUFFER* pCmdBuffer)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_cmd_create(dev, pCreateInfo,
+ (struct nulldrv_cmd **) pCmdBuffer);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglBeginCommandBuffer(
+ XGL_CMD_BUFFER cmdBuffer,
+ const XGL_CMD_BUFFER_BEGIN_INFO *info)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglEndCommandBuffer(
+ XGL_CMD_BUFFER cmdBuffer)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglResetCommandBuffer(
+ XGL_CMD_BUFFER cmdBuffer)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT void XGLAPI xglCmdInitAtomicCounters(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ uint32_t startCounter,
+ uint32_t counterCount,
+ const uint32_t* pData)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdLoadAtomicCounters(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ uint32_t startCounter,
+ uint32_t counterCount,
+ XGL_BUFFER srcBuffer,
+ XGL_GPU_SIZE srcOffset)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdSaveAtomicCounters(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ uint32_t startCounter,
+ uint32_t counterCount,
+ XGL_BUFFER destBuffer,
+ XGL_GPU_SIZE destOffset)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdDbgMarkerBegin(
+ XGL_CMD_BUFFER cmdBuffer,
+ const char* pMarker)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdDbgMarkerEnd(
+ XGL_CMD_BUFFER cmdBuffer)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdCopyBuffer(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_BUFFER srcBuffer,
+ XGL_BUFFER destBuffer,
+ uint32_t regionCount,
+ const XGL_BUFFER_COPY* pRegions)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdCopyImage(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE srcImage,
+ XGL_IMAGE destImage,
+ uint32_t regionCount,
+ const XGL_IMAGE_COPY* pRegions)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdCopyBufferToImage(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_BUFFER srcBuffer,
+ XGL_IMAGE destImage,
+ uint32_t regionCount,
+ const XGL_BUFFER_IMAGE_COPY* pRegions)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdCopyImageToBuffer(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE srcImage,
+ XGL_BUFFER destBuffer,
+ uint32_t regionCount,
+ const XGL_BUFFER_IMAGE_COPY* pRegions)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdCloneImageData(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE srcImage,
+ XGL_IMAGE_LAYOUT srcImageLayout,
+ XGL_IMAGE destImage,
+ XGL_IMAGE_LAYOUT destImageLayout)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdUpdateBuffer(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_BUFFER destBuffer,
+ XGL_GPU_SIZE destOffset,
+ XGL_GPU_SIZE dataSize,
+ const uint32_t* pData)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdFillBuffer(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_BUFFER destBuffer,
+ XGL_GPU_SIZE destOffset,
+ XGL_GPU_SIZE fillSize,
+ uint32_t data)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdClearColorImage(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE image,
+ const float color[4],
+ uint32_t rangeCount,
+ const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdClearColorImageRaw(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE image,
+ const uint32_t color[4],
+ uint32_t rangeCount,
+ const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdClearDepthStencil(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE image,
+ float depth,
+ uint32_t stencil,
+ uint32_t rangeCount,
+ const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdResolveImage(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_IMAGE srcImage,
+ XGL_IMAGE destImage,
+ uint32_t rectCount,
+ const XGL_IMAGE_RESOLVE* pRects)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdBeginQuery(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_QUERY_POOL queryPool,
+ uint32_t slot,
+ XGL_FLAGS flags)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdEndQuery(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_QUERY_POOL queryPool,
+ uint32_t slot)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdResetQueryPool(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_QUERY_POOL queryPool,
+ uint32_t startQuery,
+ uint32_t queryCount)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdSetEvent(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_EVENT event_,
+ XGL_SET_EVENT pipeEvent)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdResetEvent(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_EVENT event_)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdWriteTimestamp(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_TIMESTAMP_TYPE timestampType,
+ XGL_BUFFER destBuffer,
+ XGL_GPU_SIZE destOffset)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdBindPipeline(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_PIPELINE pipeline)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdBindPipelineDelta(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_PIPELINE_DELTA delta)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdBindDynamicStateObject(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_STATE_BIND_POINT stateBindPoint,
+ XGL_DYNAMIC_STATE_OBJECT state)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdBindDescriptorSet(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_PIPELINE_BIND_POINT pipelineBindPoint,
+ XGL_DESCRIPTOR_SET descriptorSet,
+ const uint32_t* pUserData)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdBindVertexBuffer(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_BUFFER buffer,
+ XGL_GPU_SIZE offset,
+ uint32_t binding)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdBindIndexBuffer(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_BUFFER buffer,
+ XGL_GPU_SIZE offset,
+ XGL_INDEX_TYPE indexType)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdDraw(
+ XGL_CMD_BUFFER cmdBuffer,
+ uint32_t firstVertex,
+ uint32_t vertexCount,
+ uint32_t firstInstance,
+ uint32_t instanceCount)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdDrawIndexed(
+ XGL_CMD_BUFFER cmdBuffer,
+ uint32_t firstIndex,
+ uint32_t indexCount,
+ int32_t vertexOffset,
+ uint32_t firstInstance,
+ uint32_t instanceCount)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdDrawIndirect(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_BUFFER buffer,
+ XGL_GPU_SIZE offset,
+ uint32_t count,
+ uint32_t stride)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdDrawIndexedIndirect(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_BUFFER buffer,
+ XGL_GPU_SIZE offset,
+ uint32_t count,
+ uint32_t stride)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdDispatch(
+ XGL_CMD_BUFFER cmdBuffer,
+ uint32_t x,
+ uint32_t y,
+ uint32_t z)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdDispatchIndirect(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_BUFFER buffer,
+ XGL_GPU_SIZE offset)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdWaitEvents(
+ XGL_CMD_BUFFER cmdBuffer,
+ const XGL_EVENT_WAIT_INFO* pWaitInfo)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdPipelineBarrier(
+ XGL_CMD_BUFFER cmdBuffer,
+ const XGL_PIPELINE_BARRIER* pBarrier)
+{
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateDevice(
+ XGL_PHYSICAL_GPU gpu_,
+ const XGL_DEVICE_CREATE_INFO* pCreateInfo,
+ XGL_DEVICE* pDevice)
+{
+ struct nulldrv_gpu *gpu = nulldrv_gpu(gpu_);
+ return nulldrv_dev_create(gpu, pCreateInfo, (struct nulldrv_dev**)pDevice);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglDestroyDevice(
+ XGL_DEVICE device)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglGetDeviceQueue(
+ XGL_DEVICE device,
+ XGL_QUEUE_TYPE queueType,
+ uint32_t queueIndex,
+ XGL_QUEUE* pQueue)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+ *pQueue = dev->queues[0];
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglDeviceWaitIdle(
+ XGL_DEVICE device)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglDbgSetValidationLevel(
+ XGL_DEVICE device,
+ XGL_VALIDATION_LEVEL validationLevel)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglDbgSetMessageFilter(
+ XGL_DEVICE device,
+ int32_t msgCode,
+ XGL_DBG_MSG_FILTER filter)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglDbgSetDeviceOption(
+ XGL_DEVICE device,
+ XGL_DBG_DEVICE_OPTION dbgOption,
+ size_t dataSize,
+ const void* pData)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateEvent(
+ XGL_DEVICE device,
+ const XGL_EVENT_CREATE_INFO* pCreateInfo,
+ XGL_EVENT* pEvent)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglGetEventStatus(
+ XGL_EVENT event_)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglSetEvent(
+ XGL_EVENT event_)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglResetEvent(
+ XGL_EVENT event_)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateFence(
+ XGL_DEVICE device,
+ const XGL_FENCE_CREATE_INFO* pCreateInfo,
+ XGL_FENCE* pFence)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_fence_create(dev, pCreateInfo,
+ (struct nulldrv_fence **) pFence);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglGetFenceStatus(
+ XGL_FENCE fence_)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglWaitForFences(
+ XGL_DEVICE device,
+ uint32_t fenceCount,
+ const XGL_FENCE* pFences,
+ bool32_t waitAll,
+ uint64_t timeout)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglGetFormatInfo(
+ XGL_DEVICE device,
+ XGL_FORMAT format,
+ XGL_FORMAT_INFO_TYPE infoType,
+ size_t* pDataSize,
+ void* pData)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglGetGpuInfo(
+ XGL_PHYSICAL_GPU gpu_,
+ XGL_PHYSICAL_GPU_INFO_TYPE infoType,
+ size_t* pDataSize,
+ void* pData)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglGetExtensionSupport(
+ XGL_PHYSICAL_GPU gpu_,
+ const char* pExtName)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglGetMultiGpuCompatibility(
+ XGL_PHYSICAL_GPU gpu0_,
+ XGL_PHYSICAL_GPU gpu1_,
+ XGL_GPU_COMPATIBILITY_INFO* pInfo)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglOpenPeerImage(
+ XGL_DEVICE device,
+ const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo,
+ XGL_IMAGE* pImage,
+ XGL_GPU_MEMORY* pMem)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateImage(
+ XGL_DEVICE device,
+ const XGL_IMAGE_CREATE_INFO* pCreateInfo,
+ XGL_IMAGE* pImage)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_img_create(dev, pCreateInfo, false,
+ (struct nulldrv_img **) pImage);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglGetImageSubresourceInfo(
+ XGL_IMAGE image,
+ const XGL_IMAGE_SUBRESOURCE* pSubresource,
+ XGL_SUBRESOURCE_INFO_TYPE infoType,
+ size_t* pDataSize,
+ void* pData)
+{
+ const struct nulldrv_img *img = nulldrv_img(image);
+ XGL_RESULT ret = XGL_SUCCESS;
+
+ switch (infoType) {
+ case XGL_INFO_TYPE_SUBRESOURCE_LAYOUT:
+ {
+ XGL_SUBRESOURCE_LAYOUT *layout = (XGL_SUBRESOURCE_LAYOUT *) pData;
+
+ *pDataSize = sizeof(XGL_SUBRESOURCE_LAYOUT);
+
+ if (pData == NULL)
+ return ret;
+ layout->offset = 0;
+ layout->size = 1;
+ layout->rowPitch = 4;
+ layout->depthPitch = 4;
+ }
+ break;
+ default:
+ ret = XGL_ERROR_INVALID_VALUE;
+ break;
+ }
+
+ return ret;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglSetFastClearColor(
+ XGL_IMAGE image,
+ const float color[4])
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglSetFastClearDepth(
+ XGL_IMAGE image,
+ float depth)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglAllocMemory(
+ XGL_DEVICE device,
+ const XGL_MEMORY_ALLOC_INFO* pAllocInfo,
+ XGL_GPU_MEMORY* pMem)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_mem_alloc(dev, pAllocInfo, (struct nulldrv_mem **) pMem);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglFreeMemory(
+ XGL_GPU_MEMORY mem_)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglSetMemoryPriority(
+ XGL_GPU_MEMORY mem_,
+ XGL_MEMORY_PRIORITY priority)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglMapMemory(
+ XGL_GPU_MEMORY mem_,
+ XGL_FLAGS flags,
+ void** ppData)
+{
+ struct nulldrv_mem *mem = nulldrv_mem(mem_);
+ void *ptr = nulldrv_mem_map(mem, flags);
+
+ *ppData = ptr;
+
+ return (ptr) ? XGL_SUCCESS : XGL_ERROR_UNKNOWN;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglUnmapMemory(
+ XGL_GPU_MEMORY mem_)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglPinSystemMemory(
+ XGL_DEVICE device,
+ const void* pSysMem,
+ size_t memSize,
+ XGL_GPU_MEMORY* pMem)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglOpenSharedMemory(
+ XGL_DEVICE device,
+ const XGL_MEMORY_OPEN_INFO* pOpenInfo,
+ XGL_GPU_MEMORY* pMem)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglOpenPeerMemory(
+ XGL_DEVICE device,
+ const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo,
+ XGL_GPU_MEMORY* pMem)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateInstance(
+ const XGL_APPLICATION_INFO* pAppInfo,
+ const XGL_ALLOC_CALLBACKS* pAllocCb,
+ XGL_INSTANCE* pInstance)
+{
+ struct nulldrv_instance *inst;
+
+ inst = (struct nulldrv_instance *) nulldrv_base_create(NULL, sizeof(*inst),
+ XGL_DBG_OBJECT_INSTANCE);
+ if (!inst)
+ return XGL_ERROR_OUT_OF_MEMORY;
+
+ inst->obj.base.get_info = NULL;
+
+ *pInstance = (XGL_INSTANCE*)inst;
+
+ return icd_allocator_init(pAllocCb);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglDestroyInstance(
+ XGL_INSTANCE pInstance)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglEnumerateGpus(
+ XGL_INSTANCE instance,
+ uint32_t maxGpus,
+ uint32_t* pGpuCount,
+ XGL_PHYSICAL_GPU* pGpus)
+{
+ XGL_RESULT ret;
+ struct nulldrv_gpu *gpu;
+ *pGpuCount = 1;
+ ret = nulldrv_gpu_add(0, 0, 0, &gpu);
+ if (ret == XGL_SUCCESS)
+ pGpus[0] = (XGL_PHYSICAL_GPU) gpu;
+ return ret;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(
+ XGL_PHYSICAL_GPU gpu,
+ size_t maxLayerCount,
+ size_t maxStringSize,
+ size_t* pOutLayerCount,
+ char* const* pOutLayers,
+ void* pReserved)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(
+ XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback,
+ void* pUserData)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(
+ XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglDbgSetGlobalOption(
+ XGL_DBG_GLOBAL_OPTION dbgOption,
+ size_t dataSize,
+ const void* pData)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglDestroyObject(
+ XGL_OBJECT object)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglGetObjectInfo(
+ XGL_BASE_OBJECT object,
+ XGL_OBJECT_INFO_TYPE infoType,
+ size_t* pDataSize,
+ void* pData)
+{
+ struct nulldrv_base *base = nulldrv_base(object);
+
+ return base->get_info(base, infoType, pDataSize, pData);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglBindObjectMemory(
+ XGL_OBJECT object,
+ uint32_t allocationIdx,
+ XGL_GPU_MEMORY mem_,
+ XGL_GPU_SIZE memOffset)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglBindObjectMemoryRange(
+ XGL_OBJECT object,
+ uint32_t allocationIdx,
+ XGL_GPU_SIZE rangeOffset,
+ XGL_GPU_SIZE rangeSize,
+ XGL_GPU_MEMORY mem,
+ XGL_GPU_SIZE memOffset)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglBindImageMemoryRange(
+ XGL_IMAGE image,
+ uint32_t allocationIdx,
+ const XGL_IMAGE_MEMORY_BIND_INFO* bindInfo,
+ XGL_GPU_MEMORY mem,
+ XGL_GPU_SIZE memOffset)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglDbgSetObjectTag(
+ XGL_BASE_OBJECT object,
+ size_t tagSize,
+ const void* pTag)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipeline(
+ XGL_DEVICE device,
+ const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
+ XGL_PIPELINE* pPipeline)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return graphics_pipeline_create(dev, pCreateInfo,
+ (struct nulldrv_pipeline **) pPipeline);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateComputePipeline(
+ XGL_DEVICE device,
+ const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo,
+ XGL_PIPELINE* pPipeline)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglStorePipeline(
+ XGL_PIPELINE pipeline,
+ size_t* pDataSize,
+ void* pData)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglLoadPipeline(
+ XGL_DEVICE device,
+ size_t dataSize,
+ const void* pData,
+ XGL_PIPELINE* pPipeline)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreatePipelineDelta(
+ XGL_DEVICE device,
+ XGL_PIPELINE p1,
+ XGL_PIPELINE p2,
+ XGL_PIPELINE_DELTA* delta)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateQueryPool(
+ XGL_DEVICE device,
+ const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo,
+ XGL_QUERY_POOL* pQueryPool)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglGetQueryPoolResults(
+ XGL_QUERY_POOL queryPool,
+ uint32_t startQuery,
+ uint32_t queryCount,
+ size_t* pDataSize,
+ void* pData)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglQueueSetGlobalMemReferences(
+ XGL_QUEUE queue,
+ uint32_t memRefCount,
+ const XGL_MEMORY_REF* pMemRefs)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglQueueWaitIdle(
+ XGL_QUEUE queue_)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglQueueSubmit(
+ XGL_QUEUE queue_,
+ uint32_t cmdBufferCount,
+ const XGL_CMD_BUFFER* pCmdBuffers,
+ uint32_t memRefCount,
+ const XGL_MEMORY_REF* pMemRefs,
+ XGL_FENCE fence_)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglOpenSharedQueueSemaphore(
+ XGL_DEVICE device,
+ const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pOpenInfo,
+ XGL_QUEUE_SEMAPHORE* pSemaphore)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateQueueSemaphore(
+ XGL_DEVICE device,
+ const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pCreateInfo,
+ XGL_QUEUE_SEMAPHORE* pSemaphore)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglSignalQueueSemaphore(
+ XGL_QUEUE queue,
+ XGL_QUEUE_SEMAPHORE semaphore)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglWaitQueueSemaphore(
+ XGL_QUEUE queue,
+ XGL_QUEUE_SEMAPHORE semaphore)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateSampler(
+ XGL_DEVICE device,
+ const XGL_SAMPLER_CREATE_INFO* pCreateInfo,
+ XGL_SAMPLER* pSampler)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_sampler_create(dev, pCreateInfo,
+ (struct nulldrv_sampler **) pSampler);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateShader(
+ XGL_DEVICE device,
+ const XGL_SHADER_CREATE_INFO* pCreateInfo,
+ XGL_SHADER* pShader)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return shader_create(dev, pCreateInfo, (struct nulldrv_shader **) pShader);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateDynamicViewportState(
+ XGL_DEVICE device,
+ const XGL_DYNAMIC_VP_STATE_CREATE_INFO* pCreateInfo,
+ XGL_DYNAMIC_VP_STATE_OBJECT* pState)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_viewport_state_create(dev, pCreateInfo,
+ (struct nulldrv_dynamic_vp **) pState);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateDynamicRasterState(
+ XGL_DEVICE device,
+ const XGL_DYNAMIC_RS_STATE_CREATE_INFO* pCreateInfo,
+ XGL_DYNAMIC_RS_STATE_OBJECT* pState)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_raster_state_create(dev, pCreateInfo,
+ (struct nulldrv_dynamic_rs **) pState);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateDynamicColorBlendState(
+ XGL_DEVICE device,
+ const XGL_DYNAMIC_CB_STATE_CREATE_INFO* pCreateInfo,
+ XGL_DYNAMIC_CB_STATE_OBJECT* pState)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_blend_state_create(dev, pCreateInfo,
+ (struct nulldrv_dynamic_cb **) pState);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateDynamicDepthStencilState(
+ XGL_DEVICE device,
+ const XGL_DYNAMIC_DS_STATE_CREATE_INFO* pCreateInfo,
+ XGL_DYNAMIC_DS_STATE_OBJECT* pState)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_ds_state_create(dev, pCreateInfo,
+ (struct nulldrv_dynamic_ds **) pState);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateBufferView(
+ XGL_DEVICE device,
+ const XGL_BUFFER_VIEW_CREATE_INFO* pCreateInfo,
+ XGL_BUFFER_VIEW* pView)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateImageView(
+ XGL_DEVICE device,
+ const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo,
+ XGL_IMAGE_VIEW* pView)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_img_view_create(dev, pCreateInfo,
+ (struct nulldrv_img_view **) pView);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateColorAttachmentView(
+ XGL_DEVICE device,
+ const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo,
+ XGL_COLOR_ATTACHMENT_VIEW* pView)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_rt_view_create(dev, pCreateInfo,
+ (struct nulldrv_rt_view **) pView);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateDepthStencilView(
+ XGL_DEVICE device,
+ const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo,
+ XGL_DEPTH_STENCIL_VIEW* pView)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_ds_view_create(dev, pCreateInfo,
+ (struct nulldrv_ds_view **) pView);
+
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorSetLayout(
+ XGL_DEVICE device,
+ XGL_FLAGS stageFlags,
+ const uint32_t* pSetBindPoints,
+ XGL_DESCRIPTOR_SET_LAYOUT priorSetLayout,
+ const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pSetLayoutInfoList,
+ XGL_DESCRIPTOR_SET_LAYOUT* pSetLayout)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+ struct nulldrv_desc_layout *prior_layout = nulldrv_desc_layout(priorSetLayout);
+
+ return nulldrv_desc_layout_create(dev, stageFlags, pSetBindPoints,
+ prior_layout, pSetLayoutInfoList,
+ (struct nulldrv_desc_layout **) pSetLayout);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglBeginDescriptorRegionUpdate(
+ XGL_DEVICE device,
+ XGL_DESCRIPTOR_UPDATE_MODE updateMode)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglEndDescriptorRegionUpdate(
+ XGL_DEVICE device,
+ XGL_CMD_BUFFER cmd_)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateDescriptorRegion(
+ XGL_DEVICE device,
+ XGL_DESCRIPTOR_REGION_USAGE regionUsage,
+ uint32_t maxSets,
+ const XGL_DESCRIPTOR_REGION_CREATE_INFO* pCreateInfo,
+ XGL_DESCRIPTOR_REGION* pDescriptorRegion)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_desc_region_create(dev, regionUsage, maxSets, pCreateInfo,
+ (struct nulldrv_desc_region **) pDescriptorRegion);
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglClearDescriptorRegion(
+ XGL_DESCRIPTOR_REGION descriptorRegion)
+{
+ return XGL_SUCCESS;
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglAllocDescriptorSets(
+ XGL_DESCRIPTOR_REGION descriptorRegion,
+ XGL_DESCRIPTOR_SET_USAGE setUsage,
+ uint32_t count,
+ const XGL_DESCRIPTOR_SET_LAYOUT* pSetLayouts,
+ XGL_DESCRIPTOR_SET* pDescriptorSets,
+ uint32_t* pCount)
+{
+ struct nulldrv_desc_region *region = nulldrv_desc_region(descriptorRegion);
+ struct nulldrv_dev *dev = region->dev;
+ XGL_RESULT ret = XGL_SUCCESS;
+ uint32_t i;
+
+ for (i = 0; i < count; i++) {
+ const struct nulldrv_desc_layout *layout =
+ nulldrv_desc_layout((XGL_DESCRIPTOR_SET_LAYOUT) pSetLayouts[i]);
+
+ ret = nulldrv_desc_set_create(dev, region, setUsage, layout,
+ (struct nulldrv_desc_set **) &pDescriptorSets[i]);
+ if (ret != XGL_SUCCESS)
+ break;
+ }
+
+ if (pCount)
+ *pCount = i;
+
+ return ret;
+}
+
+ICD_EXPORT void XGLAPI xglClearDescriptorSets(
+ XGL_DESCRIPTOR_REGION descriptorRegion,
+ uint32_t count,
+ const XGL_DESCRIPTOR_SET* pDescriptorSets)
+{
+}
+
+ICD_EXPORT void XGLAPI xglUpdateDescriptors(
+ XGL_DESCRIPTOR_SET descriptorSet,
+ const void* pUpdateChain)
+{
+}
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateFramebuffer(
+ XGL_DEVICE device,
+ const XGL_FRAMEBUFFER_CREATE_INFO* info,
+ XGL_FRAMEBUFFER* fb_ret)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_fb_create(dev, info, (struct nulldrv_framebuffer **) fb_ret);
+}
+
+
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateRenderPass(
+ XGL_DEVICE device,
+ const XGL_RENDER_PASS_CREATE_INFO* info,
+ XGL_RENDER_PASS* rp_ret)
+{
+ struct nulldrv_dev *dev = nulldrv_dev(device);
+
+ return nulldrv_render_pass_create(dev, info, (struct nulldrv_render_pass **) rp_ret);
+}
+
+ICD_EXPORT void XGLAPI xglCmdBeginRenderPass(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_RENDER_PASS renderPass)
+{
+}
+
+ICD_EXPORT void XGLAPI xglCmdEndRenderPass(
+ XGL_CMD_BUFFER cmdBuffer,
+ XGL_RENDER_PASS renderPass)
+{
+}
diff --git a/icd/nulldrv/nulldrv.h b/icd/nulldrv/nulldrv.h
new file mode 100644
index 00000000..20fdd727
--- /dev/null
+++ b/icd/nulldrv/nulldrv.h
@@ -0,0 +1,213 @@
+/*
+ * XGL
+ *
+ * Copyright (C) 2014 LunarG, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef NULLDRV_H
+#define NULLDRV_H
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+#include <assert.h>
+
+#include <xgl.h>
+#include <xglDbg.h>
+#include <xglIcd.h>
+
+#if defined(PLATFORM_LINUX)
+#include <xglWsiX11Ext.h>
+#else
+#include <xglWsiWinExt.h>
+#endif
+
+#ifndef STATIC_INLINE
+#if defined(PLATFORM_LINUX)
+#define STATIC_INLINE static inline
+#else
+#define STATIC_INLINE static
+#endif
+#endif
+
+#include "icd.h"
+#include "icd-alloc.h"
+
+#include "icd-format.h"
+#include "icd-utils.h"
+
+struct nulldrv_base {
+ void *loader_data;
+ uint32_t magic;
+ XGL_RESULT (*get_info)(struct nulldrv_base *base, int type1,
+ size_t *size, void *data);
+};
+
+struct nulldrv_obj {
+ struct nulldrv_base base;
+};
+
+struct nulldrv_base *nulldrv_base_create(struct nulldrv_dev *dev,
+ size_t obj_size,
+ XGL_DBG_OBJECT_TYPE type1);
+
+enum nulldrv_ext_type {
+ NULLDRV_EXT_WSI_X11,
+ NULLDRV_EXT_WSI_WINDOWS,
+ NULLDRV_EXT_COUNT,
+ NULLDRV_EXT_INVALID = NULLDRV_EXT_COUNT,
+};
+
+
+struct nulldrv_instance {
+ struct nulldrv_obj obj;
+};
+
+struct nulldrv_gpu {
+ void *loader_data;
+};
+
+struct nulldrv_dev {
+ struct nulldrv_base base;
+ bool exts[NULLDRV_EXT_COUNT];
+ struct nulldrv_desc_pool *desc_pool;
+ struct nulldrv_queue *queues[1];
+};
+
+struct nulldrv_layout {
+ enum nulldrv_layout_aux_type aux;
+};
+
+struct nulldrv_desc_pool {
+ uint32_t surface_desc_size;
+ uint32_t sampler_desc_size;
+};
+
+
+struct nulldrv_queue {
+ struct nulldrv_base base;
+ struct nulldrv_dev *dev;
+};
+
+struct nulldrv_rt_view {
+ struct nulldrv_obj obj;
+};
+
+struct nulldrv_fence {
+ struct nulldrv_obj obj;
+};
+
+struct nulldrv_img {
+ struct nulldrv_obj obj;
+ XGL_IMAGE_TYPE type;
+ int32_t depth;
+ uint32_t mip_levels;
+ uint32_t array_size;
+ XGL_FLAGS usage;
+ XGL_IMAGE_FORMAT_CLASS format_class;
+ uint32_t samples;
+ size_t total_size;
+};
+
+struct nulldrv_mem {
+ struct nulldrv_base base;
+ struct nulldrv_bo *bo;
+ XGL_GPU_SIZE size;
+};
+
+struct nulldrv_ds_view {
+ struct nulldrv_obj obj;
+ struct nulldrv_img *img;
+ uint32_t array_size;
+};
+
+struct nulldrv_sampler {
+ struct nulldrv_obj obj;
+};
+
+struct nulldrv_img_view {
+ struct nulldrv_obj obj;
+ struct nulldrv_img *img;
+ float min_lod;
+ uint32_t cmd_len;
+};
+
+struct nulldrv_buf {
+ struct nulldrv_obj obj;
+ XGL_GPU_SIZE size;
+ XGL_FLAGS usage;
+};
+
+struct nulldrv_desc_layout {
+ struct nulldrv_obj obj;
+};
+
+struct nulldrv_shader {
+ struct nulldrv_obj obj;
+
+};
+
+
+struct nulldrv_pipeline {
+ struct nulldrv_obj obj;
+ struct nulldrv_dev *dev;
+};
+
+struct nulldrv_dynamic_vp {
+ struct nulldrv_obj obj;
+};
+
+struct nulldrv_dynamic_rs {
+ struct nulldrv_obj obj;
+};
+
+struct nulldrv_dynamic_cb {
+ struct nulldrv_obj obj;
+};
+
+struct nulldrv_dynamic_ds {
+ struct nulldrv_obj obj;
+};
+
+struct nulldrv_cmd {
+ struct nulldrv_obj obj;
+};
+
+struct nulldrv_desc_region {
+ struct nulldrv_obj obj;
+ struct nulldrv_dev *dev;
+};
+
+struct nulldrv_desc_set {
+ struct nulldrv_obj obj;
+ struct nulldrv_desc_pool *pool;
+ const struct nulldrv_desc_layout *layout;
+};
+
+struct nulldrv_framebuffer {
+ struct nulldrv_obj obj;
+};
+
+struct nulldrv_render_pass {
+ struct nulldrv_obj obj;
+};
+
+#endif /* NULLDRV_H */
diff --git a/include/xglWsiWinExt.h b/include/xglWsiWinExt.h
new file mode 100644
index 00000000..73b52fb9
--- /dev/null
+++ b/include/xglWsiWinExt.h
@@ -0,0 +1,9 @@
+/* IN DEVELOPMENT. DO NOT SHIP. */
+
+#ifndef __XGLWSIWINEXT_H__
+#define __XGLWSIWINEXT_H__
+
+
+// TODO: create the contents of this file
+
+#endif // __XGLWSIWINEXT_H__
generated by cgit v1.2.3 (git 2.39.1) at 2026-09-01 11:53:04 +0000