Add reserved parameter to xglEnumerateLayers for layer usage

This parameter can be used by layer for getting GPA and gpu info queries.
Also add xglEnumerateLayers() to Basic layer, to show example of only
supporting a particular GPU.

7 files changed, 55 insertions, 20 deletions

diff --git a/include/xgl.h b/include/xgl.h
index 2ceb5665..efc972a0 100644
--- a/include/xgl.h
+++ b/include/xgl.h
@@ -880,7 +880,7 @@ typedef enum _XGL_STRUCTURE_TYPE
 // IMG CHANGE BEGIN - support for vertex input description
     XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO    = 34,
 // IMG CHANGE END
-    XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO                   = 35,
+    XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO                    = 35,
     XGL_MAX_ENUM(_XGL_STRUCTURE_TYPE)
 } XGL_STRUCTURE_TYPE;
 
@@ -1133,7 +1133,7 @@ typedef struct _XGL_LAYER_CREATE_INFO
     XGL_STRUCTURE_TYPE                      sType;                      // Should be XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO
     XGL_VOID*                               pNext;                      // Pointer to next structure
     XGL_UINT                                layerCount;
-    const XGL_CHAR *const*                  ppActiveLayerNames;         // layer library name of form libXGLLayer<Name>.so
+    const XGL_CHAR *const*                  ppActiveLayerNames;         // layer name from the layer's xglEnumerateLayers())
 } XGL_LAYER_CREATE_INFO;
 
 typedef struct _XGL_PHYSICAL_GPU_QUEUE_PROPERTIES
@@ -1756,10 +1756,6 @@ typedef struct _XGL_DISPATCH_INDIRECT_CMD
 // ------------------------------------------------------------------------------------------------
 // API functions
 
-XGL_VOID * XGLAPI xglGetProcAddr(
-    XGL_PHYSICAL_GPU gpu,
-    const XGL_CHAR * pName);
-
 // GPU initialization
 
 XGL_RESULT XGLAPI xglInitAndEnumerateGpus(
@@ -1775,6 +1771,10 @@ XGL_RESULT XGLAPI xglGetGpuInfo(
     XGL_SIZE*                                   pDataSize,
     XGL_VOID*                                   pData);
 
+XGL_VOID * XGLAPI xglGetProcAddr(
+    XGL_PHYSICAL_GPU                            gpu,
+    const XGL_CHAR*                             pName);
+
 // Device functions
 
 XGL_RESULT XGLAPI xglCreateDevice(
@@ -1793,11 +1793,12 @@ XGL_RESULT XGLAPI xglGetExtensionSupport(
 
 // Layer discovery function
 XGL_RESULT XGLAPI xglEnumerateLayers(
-    XGL_PHYSICAL_GPU gpu,
-    XGL_SIZE maxLayerCount,
-    XGL_SIZE maxStringSize,
-    XGL_CHAR* const* pOutLayers,
-    XGL_SIZE* pOutLayerCount);
+    XGL_PHYSICAL_GPU                            gpu,
+    XGL_SIZE                                    maxLayerCount,
+    XGL_SIZE                                    maxStringSize,
+    XGL_CHAR* const*                            pOutLayers,
+    XGL_SIZE*                                   pOutLayerCount,
+    XGL_VOID*                                   pReserved);
 
 // Queue functions
 
diff --git a/include/xglLayer.h b/include/xglLayer.h
index e369fc25..cf64633b 100644
--- a/include/xglLayer.h
+++ b/include/xglLayer.h
@@ -15,13 +15,13 @@
 #  define XGL_LAYER_EXPORT
 #endif
 
-typedef XGL_VOID * (XGLAPI *GetProcAddrType)(XGL_PHYSICAL_GPU gpu, const XGL_CHAR * pName);
 typedef XGL_RESULT (XGLAPI *InitAndEnumerateGpusType)(const XGL_APPLICATION_INFO* pAppInfo, const XGL_ALLOC_CALLBACKS* pAllocCb, XGL_UINT maxGpus, XGL_UINT* pGpuCount, XGL_PHYSICAL_GPU* pGpus);
 typedef XGL_RESULT (XGLAPI *GetGpuInfoType)(XGL_PHYSICAL_GPU gpu, XGL_PHYSICAL_GPU_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData);
+typedef XGL_VOID * (XGLAPI *GetProcAddrType)(XGL_PHYSICAL_GPU gpu, const XGL_CHAR * pName);
 typedef XGL_RESULT (XGLAPI *CreateDeviceType)(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo, XGL_DEVICE* pDevice);
 typedef XGL_RESULT (XGLAPI *DestroyDeviceType)(XGL_DEVICE device);
 typedef XGL_RESULT (XGLAPI *GetExtensionSupportType)(XGL_PHYSICAL_GPU gpu, const XGL_CHAR* pExtName);
-typedef XGL_RESULT (XGLAPI *EnumerateLayersType)(XGL_PHYSICAL_GPU gpu, XGL_SIZE maxLayerCount, XGL_SIZE maxStringSize, XGL_CHAR* const* pOutLayers, XGL_SIZE* pOutLayerCount);
+typedef XGL_RESULT (XGLAPI *EnumerateLayersType)(XGL_PHYSICAL_GPU gpu, XGL_SIZE maxLayerCount, XGL_SIZE maxStringSize, XGL_CHAR* const* pOutLayers, XGL_SIZE* pOutLayerCount, XGL_VOID* pReserved);
 typedef XGL_RESULT (XGLAPI *GetDeviceQueueType)(XGL_DEVICE device, XGL_QUEUE_TYPE queueType, XGL_UINT queueIndex, XGL_QUEUE* pQueue);
 typedef XGL_RESULT (XGLAPI *QueueSubmitType)(XGL_QUEUE queue, XGL_UINT cmdBufferCount, const XGL_CMD_BUFFER* pCmdBuffers, XGL_UINT memRefCount, const XGL_MEMORY_REF* pMemRefs, XGL_FENCE fence);
 typedef XGL_RESULT (XGLAPI *QueueSetGlobalMemReferencesType)(XGL_QUEUE queue, XGL_UINT memRefCount, const XGL_MEMORY_REF* pMemRefs);
diff --git a/layers/basic_plugin.c b/layers/basic_plugin.c
index ac8362da..d29e72d8 100644
--- a/layers/basic_plugin.c
+++ b/layers/basic_plugin.c
@@ -180,6 +180,39 @@ XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetFormatInfo(XGL_DEVICE device, XGL_FORMA
     return result;
 }
 
+XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(XGL_PHYSICAL_GPU gpu, XGL_SIZE maxLayerCount, XGL_SIZE maxStringSize, XGL_CHAR* const* pOutLayers, XGL_SIZE * pOutLayerCount, XGL_VOID* pReserved)
+{
+    if (gpu != NULL)
+    {
+        XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
+        printf("At start of wrapped xglEnumerateLayers() call w/ gpu: %p\n", gpu);
+        pCurObj = gpuw;
+        pthread_once(&tabOnce, initLayerTable);
+        XGL_RESULT result = myTable.EnumerateLayers((XGL_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayers, pOutLayerCount, pReserved);
+        return result;
+    } else
+    {
+        if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL || pReserved == NULL)
+            return XGL_ERROR_INVALID_POINTER;
+
+        // Example of a layer that is only compatible with Intel's GPUs
+        XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT*) pReserved;
+        GetGpuInfoType fpGetGpuInfo;
+        XGL_PHYSICAL_GPU_PROPERTIES gpuProps;
+        XGL_SIZE dataSize = sizeof(XGL_PHYSICAL_GPU_PROPERTIES);
+        fpGetGpuInfo = gpuw->pGPA((XGL_PHYSICAL_GPU) gpuw->nextObject, (const XGL_CHAR *) "xglGetGpuInfo");
+        fpGetGpuInfo((XGL_PHYSICAL_GPU) gpuw->nextObject, XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, &dataSize, &gpuProps);
+        if (gpuProps.vendorId == 0x8086)
+        {
+            *pOutLayerCount = 1;
+            strncpy(pOutLayers[0], "Basic", maxStringSize);
+        } else
+        {
+            *pOutLayerCount = 0;
+        }
+        return XGL_SUCCESS;
+    }
+}
 XGL_LAYER_EXPORT XGL_VOID * XGLAPI xglGetProcAddr(XGL_PHYSICAL_GPU gpu, const XGL_CHAR* pName) {
     XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
     if (gpu == NULL)
diff --git a/layers/draw_state.c b/layers/draw_state.c
index d5b8f195..46798500 100644
--- a/layers/draw_state.c
+++ b/layers/draw_state.c
@@ -927,14 +927,14 @@ XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetExtensionSupport(XGL_PHYSICAL_GPU gpu,
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(XGL_PHYSICAL_GPU gpu, XGL_SIZE maxLayerCount, XGL_SIZE maxStringSize, XGL_CHAR* const* pOutLayers, XGL_SIZE * pOutLayerCount)
+XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(XGL_PHYSICAL_GPU gpu, XGL_SIZE maxLayerCount, XGL_SIZE maxStringSize, XGL_CHAR* const* pOutLayers, XGL_SIZE * pOutLayerCount, XGL_VOID* pReserved)
 {
     if (gpu != NULL)
     {
         XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
         pCurObj = gpuw;
         pthread_once(&tabOnce, initLayerTable);
-        XGL_RESULT result = nextTable.EnumerateLayers((XGL_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayers, pOutLayerCount);
+        XGL_RESULT result = nextTable.EnumerateLayers((XGL_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayers, pOutLayerCount, pReserved);
         return result;
     } else
     {
diff --git a/layers/mem_tracker.c b/layers/mem_tracker.c
index e4ebaae8..0f31cb69 100644
--- a/layers/mem_tracker.c
+++ b/layers/mem_tracker.c
@@ -1092,14 +1092,14 @@ XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglGetExtensionSupport(XGL_PHYSICAL_GPU gpu,
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(XGL_PHYSICAL_GPU gpu, XGL_SIZE maxLayerCount, XGL_SIZE maxStringSize, XGL_CHAR* const* pOutLayers, XGL_SIZE * pOutLayerCount)
+XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(XGL_PHYSICAL_GPU gpu, XGL_SIZE maxLayerCount, XGL_SIZE maxStringSize, XGL_CHAR* const* pOutLayers, XGL_SIZE * pOutLayerCount, XGL_VOID* pReserved)
 {
         if (gpu != NULL)
     {
         XGL_BASE_LAYER_OBJECT* gpuw = (XGL_BASE_LAYER_OBJECT *) gpu;
         pCurObj = gpuw;
         pthread_once(&tabOnce, initLayerTable);
-        XGL_RESULT result = nextTable.EnumerateLayers((XGL_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayers, pOutLayerCount);
+        XGL_RESULT result = nextTable.EnumerateLayers((XGL_PHYSICAL_GPU)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayers, pOutLayerCount, pReserved);
         return result;
     } else
     {
diff --git a/loader/loader.c b/loader/loader.c
index be8e52be..f4f6d1a2 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -658,7 +658,7 @@ static bool find_layer_name(struct loader_icd *icd, XGL_UINT gpu_index, const ch
         }
         else {
             XGL_SIZE cnt;
-            fpEnumerateLayers(NULL, 16, 256, layers, &cnt); //gpu would be icd->gpus + gpu_index
+            fpEnumerateLayers(NULL, 16, 256, layers, &cnt, (XGL_VOID *) icd->gpus + gpu_index);
             for (unsigned int i = 0; i < cnt; i++) {
                 if (!strcmp((char *) layers[i], layer_name)) {
                     dlclose(handle);
@@ -1176,7 +1176,7 @@ LOADER_EXPORT XGL_RESULT XGLAPI xglInitAndEnumerateGpus(const XGL_APPLICATION_IN
     return (count > 0) ? XGL_SUCCESS : res;
 }
 
-LOADER_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(XGL_PHYSICAL_GPU gpu, XGL_SIZE maxLayerCount, XGL_SIZE maxStringSize, XGL_CHAR* const* pOutLayers, XGL_SIZE* pOutLayerCount)
+LOADER_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(XGL_PHYSICAL_GPU gpu, XGL_SIZE maxLayerCount, XGL_SIZE maxStringSize, XGL_CHAR* const* pOutLayers, XGL_SIZE* pOutLayerCount, XGL_VOID* pReserved)
 {
     XGL_SIZE count = loader.scanned_layer_count;
     // TODO handle layers per GPU, multiple icds
diff --git a/xgl.py b/xgl.py
index 033d85f7..fc8e9127 100644
--- a/xgl.py
+++ b/xgl.py
@@ -121,7 +121,8 @@ core = (
          Param("XGL_SIZE", "maxLayerCount"),
          Param("XGL_SIZE", "maxStringSize"),
          Param("XGL_CHAR* const*", "pOutLayers"),
-         Param("XGL_SIZE *", "pOutLayerCount"))),
+         Param("XGL_SIZE *", "pOutLayerCount"),
+         Param("XGL_VOID *", "pReserved"))),
 
     Proto("XGL_RESULT", "GetDeviceQueue",
         (Param("XGL_DEVICE", "device"),