Initial commit

backends/platform/libretro/include/wiiu/os/thread.h

@@ -0,0 +1,277 @@
+#pragma once
+#include <wiiu/types.h>
+#include "time.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct OSThread OSThread;
+
+typedef int (*OSThreadEntryPointFn)(int argc, const char **argv);
+typedef void (*OSThreadCleanupCallbackFn)(OSThread *thread, void *stack);
+typedef void (*OSThreadDeallocatorFn)(OSThread *thread, void *stack);
+
+enum OS_THREAD_STATE
+{
+   OS_THREAD_STATE_NONE             = 0,
+
+   /*! Thread is ready to run */
+   OS_THREAD_STATE_READY            = 1 << 0,
+
+   /*! Thread is running */
+   OS_THREAD_STATE_RUNNING          = 1 << 1,
+
+   /*! Thread is waiting, i.e. on a mutex */
+   OS_THREAD_STATE_WAITING          = 1 << 2,
+
+   /*! Thread is about to terminate */
+   OS_THREAD_STATE_MORIBUND         = 1 << 3,
+};
+typedef uint8_t OSThreadState;
+
+enum OS_THREAD_REQUEST
+{
+   OS_THREAD_REQUEST_NONE           = 0,
+   OS_THREAD_REQUEST_SUSPEND        = 1,
+   OS_THREAD_REQUEST_CANCEL         = 2,
+};
+typedef uint32_t OSThreadRequest;
+
+enum OS_THREAD_ATTRIB
+{
+   /*! Allow the thread to run on CPU0. */
+   OS_THREAD_ATTRIB_AFFINITY_CPU0   = 1 << 0,
+
+   /*! Allow the thread to run on CPU1. */
+   OS_THREAD_ATTRIB_AFFINITY_CPU1   = 1 << 1,
+
+   /*! Allow the thread to run on CPU2. */
+   OS_THREAD_ATTRIB_AFFINITY_CPU2   = 1 << 2,
+
+   /*! Allow the thread to run any CPU. */
+   OS_THREAD_ATTRIB_AFFINITY_ANY    = ((1 << 0) | (1 << 1) | (1 << 2)),
+
+   /*! Start the thread detached. */
+   OS_THREAD_ATTRIB_DETACHED        = 1 << 3,
+
+   /*! Enables tracking of stack usage. */
+   OS_THREAD_ATTRIB_STACK_USAGE     = 1 << 5
+};
+typedef uint8_t OSThreadAttributes;
+
+#define OS_CONTEXT_TAG 0x4F53436F6E747874ull
+
+typedef struct OSContext
+{
+   /*! Should always be set to the value OS_CONTEXT_TAG. */
+   uint64_t tag;
+
+   uint32_t gpr[32];
+   uint32_t cr;
+   uint32_t lr;
+   uint32_t ctr;
+   uint32_t xer;
+   uint32_t srr0;
+   uint32_t srr1;
+   uint32_t __unknown[0x5];
+   uint32_t fpscr;
+   double fpr[32];
+   uint16_t spinLockCount;
+   uint16_t state;
+   uint32_t gqr[8];
+   uint32_t __unknown0;
+   double psf[32];
+   uint64_t coretime[3];
+   uint64_t starttime;
+   uint32_t error;
+   uint32_t __unknown1;
+   uint32_t pmc1;
+   uint32_t pmc2;
+   uint32_t pmc3;
+   uint32_t pmc4;
+   uint32_t mmcr0;
+   uint32_t mmcr1;
+} OSContext;
+
+typedef struct OSMutex OSMutex;
+typedef struct OSFastMutex OSFastMutex;
+
+typedef struct OSMutexQueue
+{
+   OSMutex *head;
+   OSMutex *tail;
+   void *parent;
+   uint32_t __unknown;
+} OSMutexQueue;
+
+typedef struct OSFastMutexQueue
+{
+   OSFastMutex *head;
+   OSFastMutex *tail;
+} OSFastMutexQueue;
+
+typedef struct
+{
+   OSThread *prev;
+   OSThread *next;
+} OSThreadLink;
+
+typedef struct
+{
+   OSThread *head;
+   OSThread *tail;
+   void *parent;
+   uint32_t __unknown;
+} OSThreadQueue;
+
+typedef struct
+{
+   OSThread *head;
+   OSThread *tail;
+} OSThreadSimpleQueue;
+
+#define OS_THREAD_TAG 0x74487244u
+#pragma pack(push, 1)
+typedef struct __attribute__ ((aligned (8))) OSThread
+{
+   OSContext context;
+
+   /*! Should always be set to the value OS_THREAD_TAG. */
+   uint32_t tag;
+
+   /*! Bitfield of OS_THREAD_STATE */
+   OSThreadState state;
+
+   /*! Bitfield of OS_THREAD_ATTRIB */
+   OSThreadAttributes attr;
+
+   /*! Unique thread ID */
+   uint16_t id;
+
+   /*! Suspend count (increased by OSSuspendThread). */
+   int32_t suspendCounter;
+
+   /*! Actual priority of thread. */
+   int32_t priority;
+
+   /*! Base priority of thread, 0 is highest priority, 31 is lowest priority. */
+   int32_t basePriority;
+
+   /*! Exit value */
+   int32_t exitValue;
+
+   uint32_t unknown0[0x9];
+
+   /*! Queue the thread is currently waiting on */
+   OSThreadQueue *queue;
+
+   /*! Link used for thread queue */
+   OSThreadLink link;
+
+   /*! Queue of threads waiting to join this thread */
+   OSThreadQueue joinQueue;
+
+   /*! Mutex this thread is waiting to lock */
+   OSMutex *mutex;
+
+   /*! Queue of mutexes this thread owns */
+   OSMutexQueue mutexQueue;
+
+   /*! Link for global active thread queue */
+   OSThreadLink activeLink;
+
+   /*! Stack start (top, highest address) */
+   void *stackStart;
+
+   /*! Stack end (bottom, lowest address) */
+   void *stackEnd;
+
+   /*! Thread entry point */
+   OSThreadEntryPointFn entryPoint;
+
+   uint32_t unknown1[0x77];
+
+   /*! Thread specific values, accessed with OSSetThreadSpecific and OSGetThreadSpecific. */
+   uint32_t specific[0x10];
+
+   uint32_t unknown2;
+
+   /*! Thread name, accessed with OSSetThreadName and OSGetThreadName. */
+   const char *name;
+
+   uint32_t unknown3;
+
+   /*! The stack pointer passed in OSCreateThread. */
+   void *userStackPointer;
+
+   /*! Called just before thread is terminated, set with OSSetThreadCleanupCallback */
+   OSThreadCleanupCallbackFn cleanupCallback;
+
+   /*! Called just after a thread is terminated, set with OSSetThreadDeallocator */
+   OSThreadDeallocatorFn deallocator;
+
+   /*! If TRUE then a thread can be cancelled or suspended, set with OSSetThreadCancelState */
+   BOOL cancelState;
+
+   /*! Current thread request, used for cancelleing and suspending the thread. */
+   OSThreadRequest requestFlag;
+
+   /*! Pending suspend request count */
+   int32_t needSuspend;
+
+   /*! Result of thread suspend */
+   int32_t suspendResult;
+
+   /*! Queue of threads waiting for a thread to be suspended. */
+   OSThreadQueue suspendQueue;
+
+   uint32_t unknown4[0x2B];
+} OSThread;
+#pragma pack(pop)
+
+void
+OSCancelThread(OSThread *thread);
+int32_t OSCheckActiveThreads();
+int32_t OSCheckThreadStackUsage(OSThread *thread);
+void OSClearThreadStackUsage(OSThread *thread);
+void OSContinueThread(OSThread *thread);
+BOOL OSCreateThread(OSThread *thread, OSThreadEntryPointFn entry, int32_t argc, char *argv,
+                    void *stack, uint32_t stackSize, int32_t priority, OSThreadAttributes attributes);
+void OSDetachThread(OSThread *thread);
+void OSExitThread(int32_t result);
+void OSGetActiveThreadLink(OSThread *thread, OSThreadLink *link);
+OSThread *OSGetCurrentThread();
+OSThread *OSGetDefaultThread(uint32_t coreID);
+uint32_t OSGetStackPointer();
+uint32_t OSGetThreadAffinity(OSThread *thread);
+const char *OSGetThreadName(OSThread *thread);
+int32_t OSGetThreadPriority(OSThread *thread);
+uint32_t OSGetThreadSpecific(uint32_t id);
+BOOL OSIsThreadSuspended(OSThread *thread);
+BOOL OSIsThreadTerminated(OSThread *thread);
+BOOL OSJoinThread(OSThread *thread, int *threadResult);
+int32_t OSResumeThread(OSThread *thread);
+BOOL OSRunThread(OSThread *thread, OSThreadEntryPointFn entry, int argc, const char **argv);
+BOOL OSSetThreadAffinity(OSThread *thread, uint32_t affinity);
+BOOL OSSetThreadCancelState(BOOL state);
+OSThreadCleanupCallbackFn OSSetThreadCleanupCallback(OSThread *thread,
+      OSThreadCleanupCallbackFn callback);
+OSThreadDeallocatorFn OSSetThreadDeallocator(OSThread *thread, OSThreadDeallocatorFn deallocator);
+void OSSetThreadName(OSThread *thread, const char *name);
+BOOL OSSetThreadPriority(OSThread *thread, int32_t priority);
+BOOL OSSetThreadRunQuantum(OSThread *thread, uint32_t quantum);
+void OSSetThreadSpecific(uint32_t id, uint32_t value);
+BOOL OSSetThreadStackUsage(OSThread *thread);
+void OSSleepThread(OSThreadQueue *queue);
+void OSSleepTicks(OSTime ticks);
+uint32_t OSSuspendThread(OSThread *thread);
+void OSTestThreadCancel();
+void OSWakeupThread(OSThreadQueue *queue);
+void OSYieldThread();
+void OSInitThreadQueue(OSThreadQueue *queue);
+void OSInitThreadQueueEx(OSThreadQueue *queue, void *parent);
+
+#ifdef __cplusplus
+}
+#endif