added some sync func implementations

driver/command.c

@@ -1,7 +1,5 @@
 #include "common.h"
 
-#include "command.h"
-
 #include "kernel/vc4_packet.h"
 #include "../brcm/cle/v3d_decoder.h"
 #include "../brcm/clif/clif_dump.h"
@@ -418,7 +416,29 @@ VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(
 
 	_commandPool* cp = commandPool;
 
-	//TODO??
+	for(char* c = cp->pa.buf; c != cp->pa.buf + cp->pa.size; c += cp->pa.blockSize)
+	{
+		char* d = cp->pa.nextFreeBlock;
+		while(d)
+		{
+			if(c == d) break;
+		}
+
+		if(c == d) //block is free, as we found it in the free chain
+		{
+			continue;
+		}
+		else
+		{
+			//we found a valid block
+			_commandBuffer* cb = c;
+			assert(cb->state != CMDBUF_STATE_PENDING);
+			cb->state = CMDBUF_STATE_INITIAL;
+		}
+	}
+
+	//TODO secondary command buffer stuff
+	//TODO reset flag
 }
 
 /*
@@ -432,5 +452,16 @@ VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(
 
 	_commandBuffer* cb = commandBuffer;
 
-	//TODO??
+	assert(cb->state != CMDBUF_STATE_PENDING);
+
+	if(cb->state == CMDBUF_STATE_RECORDING || cb->state == CMDBUF_STATE_EXECUTABLE)
+	{
+		cb->state = CMDBUF_STATE_INVALID;
+	}
+	else
+	{
+		cb->state = CMDBUF_STATE_INITIAL;
+	}
+
+	//TODO flag?
 }

driver/common.c

@@ -1,6 +1,8 @@
 #include "common.h"
 
 #include "kernel/vc4_packet.h"
+#include "brcm/cle/v3d_decoder.h"
+#include "brcm/clif/clif_dump.h"
 
 uint32_t getFormatBpp(VkFormat f)
 {

driver/common.h

@@ -263,6 +263,12 @@ typedef struct VkCommandBuffer_T
 	_buffer* vertexBuffers[8];
 } _commandBuffer;
 
+typedef struct VkFence_T
+{
+	uint64_t seqno;
+	uint32_t signaled;
+} _fence;
+
 uint32_t getFormatBpp(VkFormat f);
 uint32_t packVec4IntoABGR8(const float rgba[4]);
 void createImageBO(_image* i);

driver/device.c

@@ -344,7 +344,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups(
 	for(; c < *pPhysicalDeviceGroupCount; ++c)
 	{
 		pPhysicalDeviceGroupProperties[c].physicalDeviceCount = 1;
-		pPhysicalDeviceGroupProperties[c].physicalDevices = &instance->dev;
+		pPhysicalDeviceGroupProperties[c].physicalDevices[0] = &instance->dev;
 		pPhysicalDeviceGroupProperties[c].subsetAllocation = 0;
 	}
 

driver/draw.c

@@ -1,7 +1,5 @@
 #include "common.h"
 
-#include "command.h"
-
 #include "kernel/vc4_packet.h"
 
 /*

driver/kernelInterface.c

@@ -235,18 +235,19 @@ int vc4_bo_wait(int fd, uint32_t bo, uint64_t timeout_ns)
 	return 1;
 }
 
-int vc4_seqno_wait(int fd, uint64_t* lastFinishedSeqno, uint64_t seqno, uint64_t timeout_ns)
+int vc4_seqno_wait(int fd, uint64_t* lastFinishedSeqno, uint64_t seqno, uint64_t* timeout_ns)
 {
 	assert(fd);
 	assert(lastFinishedSeqno);
 	assert(seqno);
+	assert(timeout_ns);
 
 	if (*lastFinishedSeqno >= seqno)
 		return 1;
 
 	struct drm_vc4_wait_seqno wait = {
 		.seqno = seqno,
-				.timeout_ns = timeout_ns,
+				.timeout_ns = *timeout_ns,
 	};
 
 	printf("Wait for seqno: %llu\n", seqno);
@@ -257,10 +258,17 @@ int vc4_seqno_wait(int fd, uint64_t* lastFinishedSeqno, uint64_t seqno, uint64_t
 			printf("Seqno wait failed: %s\n",
 				   strerror(errno));
 		}
+		else
+		{
+			//Timeout happened
+			*timeout_ns = -1;
+			return -1;
+		}
 
 		return 0;
 	}
 
+	*timeout_ns = wait.timeout_ns;
 	*lastFinishedSeqno = seqno;
 	return 1;
 }
@@ -526,10 +534,11 @@ void vc4_cl_submit(int fd, struct drm_vc4_submit_cl* submit, uint64_t* lastEmitt
 	}
 
 	if (*lastEmittedSeqno - *lastFinishedSeqno > 5) {
+		uint64_t timeout = WAIT_TIMEOUT_INFINITE;
 		if (!vc4_seqno_wait(fd,
 							lastFinishedSeqno,
 							*lastFinishedSeqno > 0 ? *lastEmittedSeqno - 5 : *lastEmittedSeqno,
-							WAIT_TIMEOUT_INFINITE))
+							&timeout))
 		{
 			printf("Job throttling failed\n");
 		}

driver/kernelInterface.h

@@ -50,7 +50,7 @@ void vc4_bo_unmap_unsynchronized(int fd, void* ptr, uint32_t size);
 //int vc4_bo_wait_ioctl(int fd, uint32_t handle, uint64_t timeout_ns);
 int vc4_bo_wait(int fd, uint32_t bo, uint64_t timeout_ns);
 //int vc4_seqno_wait_ioctl(int fd, uint64_t seqno, uint64_t timeout_ns);
-int vc4_seqno_wait(int fd, uint64_t* lastFinishedSeqno, uint64_t seqno, uint64_t timeout_ns);
+int vc4_seqno_wait(int fd, uint64_t* lastFinishedSeqno, uint64_t seqno, uint64_t* timeout_ns);
 int vc4_bo_flink(int fd, uint32_t bo, uint32_t *name);
 uint32_t vc4_bo_alloc_shader(int fd, const void *data, uint32_t* size);
 uint32_t vc4_bo_open_name(int fd, uint32_t name);

driver/sync.c

@@ -1,7 +1,5 @@
 #include "common.h"
 
-#include "command.h"
-
 #include "kernel/vc4_packet.h"
 
 /*
@@ -248,14 +246,29 @@ VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(
 		for(int d = 0; d < device->numQueues[c]; ++d)
 		{
 			uint64_t lastFinishedSeqno;
-			vc4_seqno_wait(controlFd, &lastFinishedSeqno, device->queues[c][d].lastEmitSeqno, WAIT_TIMEOUT_INFINITE);
+			uint64_t timeout = WAIT_TIMEOUT_INFINITE;
+			vc4_seqno_wait(controlFd, &lastFinishedSeqno, device->queues[c][d].lastEmitSeqno, &timeout);
 		}
 	}
 
 	return VK_SUCCESS;
 }
 
+/*
+ * https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkQueueWaitIdle
+ */
+VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(
+	VkQueue                                     queue)
+{
+	assert(queue);
 
+	_queue* q = queue;
+	uint64_t lastFinishedSeqno;
+	uint64_t timeout = WAIT_TIMEOUT_INFINITE;
+	vc4_seqno_wait(controlFd, &lastFinishedSeqno, q->lastEmitSeqno, &timeout);
+
+	return VK_SUCCESS;
+}
 
 /*
  * https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroySemaphore
@@ -273,3 +286,169 @@ VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(
 
 	sem_destroy((sem_t*)semaphore);
 }
+
+/*
+ * https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateFence
+ */
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(
+	VkDevice                                    device,
+	const VkFenceCreateInfo*                    pCreateInfo,
+	const VkAllocationCallbacks*                pAllocator,
+	VkFence*                                    pFence)
+{
+	assert(device);
+	assert(pCreateInfo);
+	assert(pFence);
+
+	assert(pAllocator == 0);
+
+	_fence* f = malloc(sizeof(_fence));
+
+	f->seqno = 0;
+	f->signaled = pCreateInfo->flags & VK_FENCE_CREATE_SIGNALED_BIT;
+
+	*pFence = f;
+}
+
+/*
+ * https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroyFence
+ */
+VKAPI_ATTR void VKAPI_CALL vkDestroyFence(
+	VkDevice                                    device,
+	VkFence                                     fence,
+	const VkAllocationCallbacks*                pAllocator)
+{
+	assert(device);
+	assert(fence);
+
+	assert(pAllocator == 0);
+
+	free(fence);
+}
+
+/*
+ * https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetFenceStatus
+ */
+VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(
+	VkDevice                                    device,
+	VkFence                                     fence)
+{
+	assert(device);
+	assert(fence);
+
+	//TODO update fence status based on last completed seqno?
+
+	_fence* f = fence;
+	return f->signaled ? VK_SUCCESS : VK_NOT_READY;
+}
+
+/*
+ * https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkResetFences
+ */
+VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(
+	VkDevice                                    device,
+	uint32_t                                    fenceCount,
+	const VkFence*                              pFences)
+{
+	assert(device);
+	assert(pFences);
+	assert(fenceCount > 0);
+
+	for(uint32_t c = 0; c < fenceCount; ++c)
+	{
+		_fence* f = pFences[c];
+		f->signaled = 0;
+		f->seqno = 0;
+	}
+}
+
+/*
+ * https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkWaitForFences
+ */
+VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(
+	VkDevice                                    device,
+	uint32_t                                    fenceCount,
+	const VkFence*                              pFences,
+	VkBool32                                    waitAll,
+	uint64_t                                    timeout)
+{
+	assert(device);
+	assert(pFences);
+	assert(fenceCount > 0);
+
+	if(waitAll)
+	{
+		if(!timeout)
+		{
+			for(uint32_t c = 0; c < fenceCount; ++c)
+			{
+				_fence* f = pFences[c];
+				if(!f->signaled) //if any unsignaled
+				{
+					return VK_TIMEOUT;
+				}
+
+				return VK_SUCCESS;
+			}
+		}
+
+		//wait for all to be signaled
+		for(uint32_t c = 0; c < fenceCount; ++c)
+		{
+			_fence* f = pFences[c];
+			uint64_t lastFinishedSeqno = 0;
+			if(!f->signaled)
+			{
+				int ret = vc4_seqno_wait(controlFd, &lastFinishedSeqno, f->seqno, &timeout);
+
+				if(ret < 0)
+				{
+					return VK_TIMEOUT;
+				}
+
+				f->signaled = 1;
+				f->seqno = 0;
+			}
+		}
+	}
+	else
+	{
+		if(!timeout)
+		{
+			for(uint32_t c = 0; c < fenceCount; ++c)
+			{
+				_fence* f = pFences[c];
+				if(f->signaled) //if any signaled
+				{
+					return VK_SUCCESS;
+				}
+
+				return VK_TIMEOUT;
+			}
+		}
+
+		//wait for any to be signaled
+		for(uint32_t c = 0; c < fenceCount; ++c)
+		{
+			_fence* f = pFences[c];
+			uint64_t lastFinishedSeqno = 0;
+			if(!f->signaled)
+			{
+				int ret = vc4_seqno_wait(controlFd, &lastFinishedSeqno, f->seqno, &timeout);
+
+				if(ret < 0)
+				{
+					continue;
+				}
+
+				f->signaled = 1;
+				f->seqno = 0;
+				return VK_SUCCESS;
+			}
+		}
+
+		return VK_TIMEOUT;
+	}
+
+	return VK_SUCCESS;
+}