Initial commit. Added headers from psp2sdk.

1 files changed, 1003 insertions, 0 deletions

diff --git a/include/user/kernel/threadmgr.h b/include/user/kernel/threadmgr.h
new file mode 100644
index 0000000..ea2513a
--- /dev/null
+++ b/include/user/kernel/threadmgr.h
@@ -0,0 +1,1003 @@
+#ifndef _PSP2_KERNEL_THREADMGR_H_
+#define _PSP2_KERNEL_THREADMGR_H_
+
+#include <psp2/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** 64-bit system clock type. */
+typedef SceUInt64 SceKernelSysClock;
+
+/* Threads. */
+
+typedef int (*SceKernelThreadEntry)(SceSize args, void *argp);
+
+/** Additional options used when creating threads. */
+typedef struct SceKernelThreadOptParam {
+	/** Size of the ::SceKernelThreadOptParam structure. */
+	SceSize 	size;
+	/** Attributes */
+	SceUInt32       attr;
+} SceKernelThreadOptParam;
+
+/** Structure to hold the status information for a thread
+  * @see sceKernelGetThreadInfo
+  */
+typedef struct SceKernelThreadInfo {
+	/** Size of the structure */
+	SceSize         size;
+	/** The UID of the process where the thread belongs */
+	SceUID          processId; //Needs confirmation
+	/** Nul terminated name of the thread */
+	char            name[32];
+	/** Thread attributes */
+	SceUInt         attr;
+	/** Thread status */
+	int             status;
+	/** Thread entry point */
+	SceKernelThreadEntry entry;
+	/** Thread stack pointer */
+	void            *stack;
+	/** Thread stack size */
+	int             stackSize;
+	/** Initial priority */
+	int             initPriority;
+	/** Current priority */
+	int             currentPriority;
+	/** Initial CPU affinity mask */
+	int             initCpuAffinityMask;
+	/** Current CPU affinity mask */
+	int             currentCpuAffinityMask;
+	/** Current CPU ID */
+	int             currentCpuId;
+	/** Last executed CPU ID */
+	int             lastExecutedCpuId;
+	/** Wait type */
+	int             waitType;
+	/** Wait id */
+	SceUID          waitId;
+	/** Exit status of the thread */
+	int             exitStatus;
+	/** Number of clock cycles run */
+	SceKernelSysClock runClocks;
+	/** Interrupt preemption count */
+	SceUInt     intrPreemptCount;
+	/** Thread preemption count */
+	SceUInt     threadPreemptCount;
+	/** Thread release count */
+	SceUInt     threadReleaseCount;
+	/** Function notify callback UID */
+	SceUID      fNotifyCallback;
+	/** Reserved */
+	int         reserved;
+} SceKernelThreadInfo;
+
+/** Statistics about a running thread.
+ * @see sceKernelGetThreadRunStatus.
+ */
+typedef struct SceKernelThreadRunStatus {
+	SceSize        size;
+	struct {
+		SceUID processId;
+		SceUID threadId;
+		int    priority;
+	} cpuInfo[4];
+} SceKernelThreadRunStatus;
+
+/* Sure there must be more than this, but haven't seen them */
+typedef enum Psp2ThreadStatus
+{
+	PSP2_THREAD_RUNNING = 1,
+	PSP2_THREAD_READY   = 2,
+	PSP2_THREAD_WAITING = 4,
+	PSP2_THREAD_SUSPEND = 8,
+	PSP2_THREAD_STOPPED = 16,
+	PSP2_THREAD_KILLED  = 32, /* Thread manager has killed the thread (stack overflow) */
+} Psp2ThreadStatus;
+
+/**
+ * Create a thread
+ *
+ * @par Example:
+ * @code
+ * SceUID thid;
+ * thid = sceKernelCreateThread("my_thread", threadFunc, 0x10000100, 0x10000, 0, 0, NULL);
+ * @endcode
+ *
+ * @param name - An arbitrary thread name.
+ * @param entry - The thread function to run when started.
+ * @param initPriority - The initial priority of the thread. Less if higher priority.
+ * @param stackSize - The size of the initial stack.
+ * @param attr - The thread attributes, zero or more of ::Psp2ThreadAttributes.
+ * @param cpuAffinityMask - The CPU affinity mask
+ * @param option - Additional options specified by ::SceKernelThreadOptParam.
+
+ * @return UID of the created thread, or an error code.
+ */
+SceUID sceKernelCreateThread(const char *name, SceKernelThreadEntry entry, int initPriority,
+                             int stackSize, SceUInt attr, int cpuAffinityMask,
+                             const SceKernelThreadOptParam *option);
+
+/**
+ * Delate a thread
+ *
+ * @param thid - UID of the thread to be deleted.
+ *
+ * @return < 0 on error.
+ */
+int sceKernelDeleteThread(SceUID thid);
+
+/**
+ * Start a created thread
+ *
+ * @param thid - Thread id from sceKernelCreateThread
+ * @param arglen - Length of the data pointed to by argp, in bytes
+ * @param argp - Pointer to the arguments.
+ */
+int sceKernelStartThread(SceUID thid, SceSize arglen, void *argp);
+
+/**
+ * Exit a thread
+ *
+ * @param status - Exit status.
+ */
+int sceKernelExitThread(int status);
+
+/**
+  * Exit a thread and delete itself.
+  *
+  * @param status - Exit status
+  */
+int sceKernelExitDeleteThread(int status);
+
+/**
+  * Wait until a thread has ended.
+  *
+  * @param thid - Id of the thread to wait for.
+  * @param stat - Exit status.
+  * @param timeout - Timeout in microseconds (assumed).
+  *
+  * @return < 0 on error.
+  */
+int sceKernelWaitThreadEnd(SceUID thid, int *stat, SceUInt *timeout);
+
+/**
+  * Wait until a thread has ended and handle callbacks if necessary.
+  *
+  * @param thid - Id of the thread to wait for.
+  * @param stat - Exit status.
+  * @param timeout - Timeout in microseconds (assumed).
+  *
+  * @return < 0 on error.
+  */
+int sceKernelWaitThreadEndCB(SceUID thid, int *stat, SceUInt *timeout);
+
+/**
+  * Delay the current thread by a specified number of microseconds
+  *
+  * @param delay - Delay in microseconds.
+  *
+  * @par Example:
+  * @code
+  * sceKernelDelayThread(1000000); // Delay for a second
+  * @endcode
+  */
+int sceKernelDelayThread(SceUInt delay);
+
+/**
+  * Delay the current thread by a specified number of microseconds and handle any callbacks.
+  *
+  * @param delay - Delay in microseconds.
+  *
+  * @par Example:
+  * @code
+  * sceKernelDelayThread(1000000); // Delay for a second
+  * @endcode
+  */
+int sceKernelDelayThreadCB(SceUInt delay);
+
+/**
+ * Modify the attributes of the current thread.
+ *
+ * @param unknown - Set to 0.
+ * @param attr - The thread attributes to modify.  One of ::Psp2ThreadAttributes.
+ *
+ * @return < 0 on error.
+ */
+int sceKernelChangeCurrentThreadAttr(int unknown, SceUInt attr);
+
+/**
+  * Change the threads current priority.
+  *
+  * @param thid - The ID of the thread (from sceKernelCreateThread or sceKernelGetThreadId)
+  * @param priority - The new priority (the lower the number the higher the priority)
+  *
+  * @par Example:
+  * @code
+  * int thid = sceKernelGetThreadId();
+  * // Change priority of current thread to 16
+  * sceKernelChangeThreadPriority(thid, 16);
+  * @endcode
+  *
+  * @return 0 if successful, otherwise the error code.
+  */
+int sceKernelChangeThreadPriority(SceUID thid, int priority);
+
+/**
+ * Rotate thread ready queue at a set priority
+ *
+ * @param priority - The priority of the queue
+ *
+ * @return 0 on success, < 0 on error.
+ */
+int sceKernelRotateThreadReadyQueue(int priority);
+
+/**
+ * Release a thread in the wait state.
+ *
+ * @param thid - The UID of the thread.
+ *
+ * @return 0 on success, < 0 on error
+ */
+int sceKernelReleaseWaitThread(SceUID thid);
+
+/**
+  * Get the current thread Id
+  *
+  * @return The thread id of the calling thread.
+  */
+int sceKernelGetThreadId(void);
+
+/**
+ * Get the current priority of the thread you are in.
+ *
+ * @return The current thread priority
+ */
+int sceKernelGetThreadCurrentPriority(void);
+
+/**
+ * Get the exit status of a thread.
+ *
+ * @param thid - The UID of the thread to check.
+ *
+ * @return The exit status
+ */
+int sceKernelGetThreadExitStatus(SceUID thid);
+
+/**
+ * Check the thread stack?
+ *
+ * @return Unknown.
+ */
+int sceKernelCheckThreadStack(void);
+
+/**
+ * Get the free stack size for a thread.
+ *
+ * @param thid - The thread ID. Seem to take current thread
+ * if set to 0.
+ *
+ * @return The free size.
+ */
+int sceKernelGetThreadStackFreeSize(SceUID thid);
+
+/**
+  * Get the status information for the specified thread.
+  *
+  * @param thid - Id of the thread to get status
+  * @param info - Pointer to the info structure to receive the data.
+  * Note: The structures size field should be set to
+  * sizeof(SceKernelThreadInfo) before calling this function.
+  *
+  * @par Example:
+  * @code
+  * SceKernelThreadInfo status;
+  * status.size = sizeof(SceKernelThreadInfo);
+  * if(sceKernelGetThreadInfo(thid, &status) == 0)
+  * { Do something... }
+  * @endcode
+  * @return 0 if successful, otherwise the error code.
+  */
+int sceKernelGetThreadInfo(SceUID thid, SceKernelThreadInfo *info);
+
+/**
+ * Retrive the runtime status of a thread.
+ *
+ * @param thid - UID of the thread to retrive status.
+ * @param status - Pointer to a ::SceKernelThreadRunStatus struct to receive the runtime status.
+ *
+ * @return 0 if successful, otherwise the error code.
+ */
+int sceKernelGetThreadRunStatus(SceUID thid, SceKernelThreadRunStatus *status);
+
+
+/* Semaphores. */
+
+/** Additional options used when creating semaphores. */
+typedef struct SceKernelSemaOptParam {
+	/** Size of the ::SceKernelSemaOptParam structure. */
+	SceSize 	size;
+} SceKernelSemaOptParam;
+
+/** Current state of a semaphore.
+ * @see sceKernelGetSemaInfo.
+ */
+typedef struct SceKernelSemaInfo {
+	/** Size of the ::SceKernelSemaInfo structure. */
+	SceSize         size;
+	/** The UID of the semaphore */
+	SceUID          semaId;
+	/** NUL-terminated name of the semaphore. */
+	char            name[32];
+	/** Attributes. */
+	SceUInt         attr;
+	/** The initial count the semaphore was created with. */
+	int             initCount;
+	/** The current count. */
+	int             currentCount;
+	/** The maximum count. */
+	int             maxCount;
+	/** The number of threads waiting on the semaphore. */
+	int             numWaitThreads;
+} SceKernelSemaInfo;
+
+/**
+ * Creates a new semaphore
+ *
+ * @par Example:
+ * @code
+ * int semaid;
+ * semaid = sceKernelCreateSema("MyMutex", 0, 1, 1, 0);
+ * @endcode
+ *
+ * @param name - Specifies the name of the sema
+ * @param attr - Sema attribute flags (normally set to 0)
+ * @param initVal - Sema initial value
+ * @param maxVal - Sema maximum value
+ * @param option - Sema options (normally set to 0)
+ * @return A semaphore id
+ */
+SceUID sceKernelCreateSema(const char *name, SceUInt attr, int initVal, int maxVal, SceKernelSemaOptParam *option);
+
+/**
+ * Destroy a semaphore
+ *
+ * @param semaid - The semaid returned from a previous create call.
+ * @return Returns the value 0 if its succesful otherwise -1
+ */
+int sceKernelDeleteSema(SceUID semaid);
+
+/**
+ * Send a signal to a semaphore
+ *
+ * @par Example:
+ * @code
+ * // Signal the sema
+ * sceKernelSignalSema(semaid, 1);
+ * @endcode
+ *
+ * @param semaid - The sema id returned from sceKernelCreateSema
+ * @param signal - The amount to signal the sema (i.e. if 2 then increment the sema by 2)
+ *
+ * @return < 0 On error.
+ */
+int sceKernelSignalSema(SceUID semaid, int signal);
+
+/**
+ * Lock a semaphore
+ *
+ * @par Example:
+ * @code
+ * sceKernelWaitSema(semaid, 1, 0);
+ * @endcode
+ *
+ * @param semaid - The sema id returned from sceKernelCreateSema
+ * @param signal - The value to wait for (i.e. if 1 then wait till reaches a signal state of 1)
+ * @param timeout - Timeout in microseconds (assumed).
+ *
+ * @return < 0 on error.
+ */
+int sceKernelWaitSema(SceUID semaid, int signal, SceUInt *timeout);
+
+/**
+ * Lock a semaphore and handle callbacks if necessary.
+ *
+ * @par Example:
+ * @code
+ * sceKernelWaitSemaCB(semaid, 1, 0);
+ * @endcode
+ *
+ * @param semaid - The sema id returned from sceKernelCreateSema
+ * @param signal - The value to wait for (i.e. if 1 then wait till reaches a signal state of 1)
+ * @param timeout - Timeout in microseconds (assumed).
+ *
+ * @return < 0 on error.
+ */
+int sceKernelWaitSemaCB(SceUID semaid, int signal, SceUInt *timeout);
+
+/**
+ * Poll a sempahore.
+ *
+ * @param semaid - UID of the semaphore to poll.
+ * @param signal - The value to test for.
+ *
+ * @return < 0 on error.
+ */
+int sceKernelPollSema(SceUID semaid, int signal);
+
+/**
+ * Cancels a semaphore
+ *
+ * @param semaid - The sema id returned from sceKernelCreateSema
+ * @param setCount - The new lock count of the semaphore
+ * @param numWaitThreads - Number of threads waiting for the semaphore
+ * @return < 0 On error.
+ */
+int sceKernelCancelSema(SceUID semaid, int setCount, int *numWaitThreads);
+
+/**
+ * Retrieve information about a semaphore.
+ *
+ * @param semaid - UID of the semaphore to retrieve info for.
+ * @param info - Pointer to a ::SceKernelSemaInfo struct to receive the info.
+ *
+ * @return < 0 on error.
+ */
+int sceKernelGetSemaInfo(SceUID semaid, SceKernelSemaInfo *info);
+
+
+/* Mutexes. */
+
+/** Additional options used when creating mutexes. */
+typedef struct SceKernelMutexOptParam {
+	/** Size of the ::SceKernelMutexOptParam structure. */
+	SceSize 	size;
+	int             ceilingPriority;
+} SceKernelMutexOptParam;
+
+/** Current state of a mutex.
+ * @see sceKernelGetMutexInfo.
+ */
+typedef struct SceKernelMutexInfo {
+	/** Size of the ::SceKernelMutexInfo structure. */
+	SceSize         size;
+	/** The UID of the mutex. */
+	SceUID          mutexId;
+	/** NUL-terminated name of the mutex. */
+	char            name[32];
+	/** Attributes. */
+	SceUInt         attr;
+	/** The initial count the mutex was created with. */
+	int             initCount;
+	/** The current count. */
+	int             currentCount;
+	/** The UID of the current owner of the mutex. */
+	SceUID          currentOwnerId;
+	/** The number of threads waiting on the mutex. */
+	int             numWaitThreads;
+} SceKernelMutexInfo;
+
+/**
+ * Creates a new mutex
+ *
+ * @par Example:
+ * @code
+ * int mutexid;
+ * mutexid = sceKernelCreateMutex("MyMutex", 0, 1, 1, 0);
+ * @endcode
+ *
+ * @param name - Specifies the name of the mutex
+ * @param attr - Mutex attribute flags (normally set to 0)
+ * @param initCount - Mutex initial value
+ * @param option - Mutex options (normally set to 0)
+ * @return A mutex id
+ */
+SceUID sceKernelCreateMutex(const char *name, SceUInt attr, int initCount, SceKernelMutexOptParam *option);
+
+/**
+ * Destroy a mutex
+ *
+ * @param mutexid - The mutex id returned from sceKernelCreateMutex
+ * @return Returns the value 0 if its succesful otherwise -1
+ */
+int sceKernelDeleteMutex(SceUID mutexid);
+
+/**
+ * Open a mutex
+ *
+ * @param name - The name of the mutex to open
+ * @return Returns the value 0 if its succesful otherwise -1
+ */
+int sceKernelOpenMutex(const char *name);
+
+/**
+ * Close a mutex
+ *
+ * @param mutexid - The mutex id returned from sceKernelCreateMutex
+ * @return Returns the value 0 if its succesful otherwise -1
+ */
+int sceKernelCloseMutex(SceUID mutexid);
+
+/**
+ * Lock a mutex
+ *
+ * @param mutexid - The mutex id returned from sceKernelCreateMutex
+ * @param lockCount - The value to increment to the lock count of the mutex
+ * @param timeout - Timeout in microseconds (assumed)
+ * @return < 0 On error.
+ */
+int sceKernelLockMutex(SceUID mutexid, int lockCount, unsigned int *timeout);
+
+/**
+ * Lock a mutex and handle callbacks if necessary.
+ *
+ * @param mutexid - The mutex id returned from sceKernelCreateMutex
+ * @param lockCount - The value to increment to the lock count of the mutex
+ * @param timeout - Timeout in microseconds (assumed)
+ * @return < 0 On error.
+ */
+int sceKernelLockMutexCB(SceUID mutexid, int lockCount, unsigned int *timeout);
+
+/**
+ * Try to lock a mutex (non-blocking)
+ *
+ * @param mutexid - The mutex id returned from sceKernelCreateMutex
+ * @param lockCount - The value to increment to the lock count of the mutex
+ * @return < 0 On error.
+ */
+int sceKernelTryLockMutex(SceUID mutexid, int lockCount);
+
+/**
+ * Try to unlock a mutex (non-blocking)
+ *
+ * @param mutexid - The mutex id returned from sceKernelCreateMutex
+ * @param unlockCount - The value to decrement to the lock count of the mutex
+ * @return < 0 On error.
+ */
+int sceKernelUnlockMutex(SceUID mutexid, int unlockCount);
+
+/**
+ * Cancels a mutex
+ *
+ * @param mutexid - The mutex id returned from sceKernelCreateMutex
+ * @param newCount - The new lock count of the mutex
+ * @param numWaitThreads - Number of threads waiting for the mutex
+ * @return < 0 On error.
+ */
+int sceKernelCancelMutex(SceUID mutexid, int newCount, int *numWaitThreads);
+
+/**
+ * Retrieve information about a mutex.
+ *
+ * @param mutexid - UID of the mutex to retrieve info for.
+ * @param info - Pointer to a ::SceKernelMutexInfo struct to receive the info.
+ *
+ * @return < 0 on error.
+ */
+int sceKernelGetMutexInfo(SceUID mutexid, SceKernelMutexInfo info);
+
+
+/* Event flags. */
+
+/** Structure to hold the event flag information */
+typedef struct SceKernelEventFlagInfo {
+	SceSize 	size;
+	SceUID          evfId; // Needs confirmation
+	char 		name[32];
+	SceUInt 	attr;
+	SceUInt 	initPattern;
+	SceUInt 	currentPattern;
+	int 		numWaitThreads;
+} SceKernelEventFlagInfo;
+
+typedef struct SceKernelEventFlagOptParam {
+	SceSize         size;
+} SceKernelEventFlagOptParam;
+
+typedef struct SceKernelEventFlagOptParam SceKernelEventFlagOptParam;
+
+/** Event flag creation attributes */
+typedef enum Psp2EventFlagAttributes {
+	/** Allow the event flag to be waited upon by multiple threads */
+	PSP2_EVENT_WAITMULTIPLE = 0x200
+} Psp2EventFlagAttributes;
+
+/** Event flag wait types */
+typedef enum Psp2EventFlagWaitTypes {
+	/** Wait for all bits in the pattern to be set */
+	PSP2_EVENT_WAITAND = 0,
+	/** Wait for one or more bits in the pattern to be set */
+	PSP2_EVENT_WAITOR  = 1,
+	/** Clear the wait pattern when it matches */
+	PSP2_EVENT_WAITCLEAR = 0x20
+} Psp2EventFlagWaitTypes;
+
+/**
+  * Create an event flag.
+  *
+  * @param name - The name of the event flag.
+  * @param attr - Attributes from ::Psp2EventFlagAttributes
+  * @param bits - Initial bit pattern.
+  * @param opt  - Options, set to NULL
+  * @return < 0 on error. >= 0 event flag id.
+  *
+  * @par Example:
+  * @code
+  * int evid;
+  * evid = sceKernelCreateEventFlag("wait_event", 0, 0, 0);
+  * @endcode
+  */
+SceUID sceKernelCreateEventFlag(const char *name, int attr, int bits, SceKernelEventFlagOptParam *opt);
+
+/**
+  * Set an event flag bit pattern.
+  *
+  * @param evid - The event id returned by sceKernelCreateEventFlag.
+  * @param bits - The bit pattern to set.
+  *
+  * @return < 0 On error
+  */
+int sceKernelSetEventFlag(SceUID evid, unsigned int bits);
+
+/**
+ * Clear a event flag bit pattern
+ *
+ * @param evid - The event id returned by ::sceKernelCreateEventFlag
+ * @param bits - The bits to clean
+ *
+ * @return < 0 on Error
+ */
+int sceKernelClearEventFlag(SceUID evid, unsigned int bits);
+
+/**
+  * Poll an event flag for a given bit pattern.
+  *
+  * @param evid - The event id returned by sceKernelCreateEventFlag.
+  * @param bits - The bit pattern to poll for.
+  * @param wait - Wait type, one or more of ::Psp2EventFlagWaitTypes or'ed together
+  * @param outBits - The bit pattern that was matched.
+  * @return < 0 On error
+  */
+int sceKernelPollEventFlag(int evid, unsigned int bits, unsigned int wait, unsigned int *outBits);
+
+/**
+  * Wait for an event flag for a given bit pattern.
+  *
+  * @param evid - The event id returned by sceKernelCreateEventFlag.
+  * @param bits - The bit pattern to poll for.
+  * @param wait - Wait type, one or more of ::Psp2EventFlagWaitTypes or'ed together
+  * @param outBits - The bit pattern that was matched.
+  * @param timeout  - Timeout in microseconds
+  * @return < 0 On error
+  */
+int sceKernelWaitEventFlag(int evid, unsigned int bits, unsigned int wait, unsigned int *outBits, SceUInt *timeout);
+
+/**
+  * Wait for an event flag for a given bit pattern with callback.
+  *
+  * @param evid - The event id returned by sceKernelCreateEventFlag.
+  * @param bits - The bit pattern to poll for.
+  * @param wait - Wait type, one or more of ::Psp2EventFlagWaitTypes or'ed together
+  * @param outBits - The bit pattern that was matched.
+  * @param timeout  - Timeout in microseconds
+  * @return < 0 On error
+  */
+int sceKernelWaitEventFlagCB(int evid, unsigned int bits, unsigned int wait, unsigned int *outBits, SceUInt *timeout);
+
+/**
+  * Delete an event flag
+  *
+  * @param evid - The event id returned by sceKernelCreateEventFlag.
+  *
+  * @return < 0 On error
+  */
+int sceKernelDeleteEventFlag(int evid);
+
+/**
+  * Get the status of an event flag.
+  *
+  * @param event - The UID of the event.
+  * @param status - A pointer to a ::SceKernelEventFlagInfo structure.
+  *
+  * @return < 0 on error.
+  */
+int sceKernelGetEventFlagInfo(SceUID event, SceKernelEventFlagInfo *info);
+
+
+/* Callbacks. */
+
+/** Callback function prototype */
+typedef int (*SceKernelCallbackFunction)(int notifyId, int notifyCount, int notifyArg, void *common);
+
+/** Structure to hold the status information for a callback */
+typedef struct SceKernelCallbackInfo {
+	/** Size of the structure (i.e. sizeof(SceKernelCallbackInfo)) */
+	SceSize size;
+	/** The UID of the callback. */
+	SceUID  callbackId; // Needs confirmation
+	/** The name given to the callback */
+	char    name[32];
+	/** The thread id associated with the callback */
+	SceUID  threadId;
+	/** Pointer to the callback function */
+	SceKernelCallbackFunction callback;
+	/** User supplied argument for the callback */
+	void    *common;
+	/** Unknown */
+	int     notifyCount;
+	/** Unknown */
+	int     notifyArg;
+} SceKernelCallbackInfo;
+
+/**
+ * Create callback
+ *
+ * @par Example:
+ * @code
+ * int cbid;
+ * cbid = sceKernelCreateCallback("Exit Callback", exit_cb, NULL);
+ * @endcode
+ *
+ * @param name - A textual name for the callback
+ * @param func - A pointer to a function that will be called as the callback
+ * @param arg  - Argument for the callback ?
+ *
+ * @return >= 0 A callback id which can be used in subsequent functions, < 0 an error.
+ */
+int sceKernelCreateCallback(const char *name, unsigned int attr, SceKernelCallbackFunction func, void *arg);
+
+/**
+  * Gets the status of a specified callback.
+  *
+  * @param cb - The UID of the callback to retrieve info for.
+  * @param status - Pointer to a status structure. The size parameter should be
+  * initialised before calling.
+  *
+  * @return < 0 on error.
+  */
+int sceKernelGetCallbackInfo(SceUID cb, SceKernelCallbackInfo *infop);
+
+/**
+ * Delete a callback
+ *
+ * @param cb - The UID of the specified callback
+ *
+ * @return 0 on success, < 0 on error
+ */
+int sceKernelDeleteCallback(SceUID cb);
+
+/**
+ * Notify a callback
+ *
+ * @param cb - The UID of the specified callback
+ * @param arg2 - Passed as arg2 into the callback function
+ *
+ * @return 0 on success, < 0 on error
+ */
+int sceKernelNotifyCallback(SceUID cb, int arg2);
+
+/**
+ * Cancel a callback ?
+ *
+ * @param cb - The UID of the specified callback
+ *
+ * @return 0 on succes, < 0 on error
+ */
+int sceKernelCancelCallback(SceUID cb);
+
+/**
+ * Get the callback count
+ *
+ * @param cb - The UID of the specified callback
+ *
+ * @return The callback count, < 0 on error
+ */
+int sceKernelGetCallbackCount(SceUID cb);
+
+/**
+ * Check callback ?
+ *
+ * @return Something or another
+ */
+int sceKernelCheckCallback(void);
+
+
+/* Message pipes */
+
+/**
+ * Create a message pipe
+ *
+ * @param name - Name of the pipe
+ * @param part - ID of the memory partition
+ * @param attr - Set to 0?
+ * @param unk1 - Unknown
+ * @param opt  - Message pipe options (set to NULL)
+ *
+ * @return The UID of the created pipe, < 0 on error
+ */
+SceUID sceKernelCreateMsgPipe(const char *name, int part, int attr, void *unk1, void *opt);
+
+/**
+ * Delete a message pipe
+ *
+ * @param uid - The UID of the pipe
+ *
+ * @return 0 on success, < 0 on error
+ */
+int sceKernelDeleteMsgPipe(SceUID uid);
+
+/**
+ * Send a message to a pipe
+ *
+ * @param uid - The UID of the pipe
+ * @param message - Pointer to the message
+ * @param size - Size of the message
+ * @param unk1 - Unknown
+ * @param unk2 - Unknown
+ * @param timeout - Timeout for send
+ *
+ * @return 0 on success, < 0 on error
+ */
+int sceKernelSendMsgPipe(SceUID uid, void *message, unsigned int size, int unk1, void *unk2, unsigned int *timeout);
+
+/**
+ * Send a message to a pipe (with callback)
+ *
+ * @param uid - The UID of the pipe
+ * @param message - Pointer to the message
+ * @param size - Size of the message
+ * @param unk1 - Unknown
+ * @param unk2 - Unknown
+ * @param timeout - Timeout for send
+ *
+ * @return 0 on success, < 0 on error
+ */
+int sceKernelSendMsgPipeCB(SceUID uid, void *message, unsigned int size, int unk1, void *unk2, unsigned int *timeout);
+
+/**
+ * Try to send a message to a pipe
+ *
+ * @param uid - The UID of the pipe
+ * @param message - Pointer to the message
+ * @param size - Size of the message
+ * @param unk1 - Unknown
+ * @param unk2 - Unknown
+ *
+ * @return 0 on success, < 0 on error
+ */
+int sceKernelTrySendMsgPipe(SceUID uid, void *message, unsigned int size, int unk1, void *unk2);
+
+/**
+ * Receive a message from a pipe
+ *
+ * @param uid - The UID of the pipe
+ * @param message - Pointer to the message
+ * @param size - Size of the message
+ * @param unk1 - Unknown
+ * @param unk2 - Unknown
+ * @param timeout - Timeout for receive
+ *
+ * @return 0 on success, < 0 on error
+ */
+int sceKernelReceiveMsgPipe(SceUID uid, void *message, unsigned int size, int unk1, void *unk2, unsigned int *timeout);
+
+/**
+ * Receive a message from a pipe (with callback)
+ *
+ * @param uid - The UID of the pipe
+ * @param message - Pointer to the message
+ * @param size - Size of the message
+ * @param unk1 - Unknown
+ * @param unk2 - Unknown
+ * @param timeout - Timeout for receive
+ *
+ * @return 0 on success, < 0 on error
+ */
+int sceKernelReceiveMsgPipeCB(SceUID uid, void *message, unsigned int size, int unk1, void *unk2, unsigned int *timeout);
+
+/**
+ * Receive a message from a pipe
+ *
+ * @param uid - The UID of the pipe
+ * @param message - Pointer to the message
+ * @param size - Size of the message
+ * @param unk1 - Unknown
+ * @param unk2 - Unknown
+ *
+ * @return 0 on success, < 0 on error
+ */
+int sceKernelTryReceiveMsgPipe(SceUID uid, void *message, unsigned int size, int unk1, void *unk2);
+
+/**
+ * Cancel a message pipe
+ *
+ * @param uid - UID of the pipe to cancel
+ * @param psend - Receive number of sending threads?
+ * @param precv - Receive number of receiving threads?
+ *
+ * @return 0 on success, < 0 on error
+ */
+int sceKernelCancelMsgPipe(SceUID uid, int *psend, int *precv);
+
+/** Message Pipe status info */
+typedef struct SceKernelMppInfo {
+	SceSize size;
+	SceUID  mppId; // Needs confirmation
+	char    name[32];
+	SceUInt attr;
+	int     bufSize;
+	int     freeSize;
+	int     numSendWaitThreads;
+	int     numReceiveWaitThreads;
+} SceKernelMppInfo;
+
+/**
+ * Get the status of a Message Pipe
+ *
+ * @param uid - The uid of the Message Pipe
+ * @param info - Pointer to a ::SceKernelMppInfo structure
+ *
+ * @return 0 on success, < 0 on error
+ */
+int sceKernelGetMsgPipeInfo(SceUID uid, SceKernelMppInfo *info);
+
+
+/* Misc. */
+
+typedef struct SceKernelSystemInfo {
+	SceSize   size;
+	SceUInt32 activeCpuMask;
+
+	struct {
+		SceKernelSysClock idleClock;
+		SceUInt32         comesOutOfIdleCount;
+		SceUInt32         threadSwitchCount;
+	} cpuInfo[4];
+} SceKernelSystemInfo;
+
+/**
+ * Get the system information
+ *
+ * @param info - Pointer to a ::SceKernelSystemInfo structure
+ *
+ * @return 0 on success, < 0 on error
+ */
+int sceKernelGetSystemInfo(SceKernelSystemInfo *info);
+
+/* Misc. */
+
+/** Threadmgr types */
+typedef enum SceKernelIdListType {
+	SCE_KERNEL_TMID_Thread = 1,
+	SCE_KERNEL_TMID_Semaphore = 2,
+	SCE_KERNEL_TMID_EventFlag = 3,
+	SCE_KERNEL_TMID_Mbox = 4,
+	SCE_KERNEL_TMID_Vpl = 5,
+	SCE_KERNEL_TMID_Fpl = 6,
+	SCE_KERNEL_TMID_Mpipe = 7,
+	SCE_KERNEL_TMID_Callback = 8,
+	SCE_KERNEL_TMID_ThreadEventHandler = 9,
+	SCE_KERNEL_TMID_Alarm = 10,
+	SCE_KERNEL_TMID_VTimer = 11,
+	SCE_KERNEL_TMID_SleepThread = 64,
+	SCE_KERNEL_TMID_DelayThread = 65,
+	SCE_KERNEL_TMID_SuspendThread = 66,
+	SCE_KERNEL_TMID_DormantThread = 67,
+} SceKernelIdListType;
+
+/**
+ * Get the type of a threadman uid
+ *
+ * @param uid - The uid to get the type from
+ *
+ * @return The type, < 0 on error
+ */
+SceKernelIdListType sceKernelGetThreadmgrUIDClass(SceUID uid);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _PSP2_KERNEL_THREADMGR_H_ */