pspthreadman.h

Go to the documentation of this file.

/*
 * PSP Software Development Kit - http://www.pspdev.org
 * -----------------------------------------------------------------------
 * Licensed under the BSD license, see LICENSE in PSPSDK root for details.
 *
 * pspthreadman.h - Library imports for the kernel threading library.
 *
 * Copyright (c) 2005 Marcus R. Brown <mrbrown@ocgnet.org>
 * Copyright (c) 2005 James Forshaw <tyranid@gmail.com>
 * Copyright (c) 2005 John Kelley <ps2dev@kelley.ca>
 * Copyright (c) 2005 Florin Sasu
 *
 * $Id: pspthreadman.h 2433 2008-10-15 10:00:27Z iwn $
 */
#ifndef __THREADMAN_H__
#define __THREADMAN_H__

#include <psptypes.h>
#include <pspkerneltypes.h>
/* Include for profile register definitions */
#include <pspdebug.h>

/* Note: Some of the structures, types, and definitions in this file were
   extrapolated from symbolic debugging information found in the Japanese
   version of Puzzle Bobble. */

#ifdef __cplusplus
extern "C" {
#endif


typedef struct SceKernelSysClock {
        SceUInt32   low;
        SceUInt32   hi;
} SceKernelSysClock;

enum PspThreadAttributes
{
        PSP_THREAD_ATTR_VFPU = 0x00004000,
        PSP_THREAD_ATTR_USER = 0x80000000,
        PSP_THREAD_ATTR_USBWLAN = 0xa0000000,
        PSP_THREAD_ATTR_VSH = 0xc0000000,
        PSP_THREAD_ATTR_SCRATCH_SRAM = 0x00008000,
        PSP_THREAD_ATTR_NO_FILLSTACK = 0x00100000,
        PSP_THREAD_ATTR_CLEAR_STACK = 0x00200000,
};

/* Maintained for compatibility with older versions of PSPSDK. */
#define THREAD_ATTR_VFPU PSP_THREAD_ATTR_VFPU
#define THREAD_ATTR_USER PSP_THREAD_ATTR_USER


/* Threads. */

typedef int (*SceKernelThreadEntry)(SceSize args, void *argp);

typedef struct SceKernelThreadOptParam {
        SceSize         size;
        SceUID          stackMpid;
} SceKernelThreadOptParam;

typedef struct SceKernelThreadInfo {
        SceSize     size;
        char            name[32];
        SceUInt     attr;
        int             status;
        SceKernelThreadEntry    entry;
        void *          stack;
        int             stackSize;
        void *          gpReg;
        int             initPriority;
        int             currentPriority;
        int             waitType;
        SceUID          waitId;
        int             wakeupCount;
        int             exitStatus;
        SceKernelSysClock   runClocks;
        SceUInt     intrPreemptCount;
        SceUInt     threadPreemptCount;
        SceUInt     releaseCount;
} SceKernelThreadInfo;

typedef struct SceKernelThreadRunStatus {
        SceSize         size;
        int             status;
        int             currentPriority;
        int             waitType;
        int             waitId;
        int             wakeupCount;
        SceKernelSysClock runClocks;
        SceUInt         intrPreemptCount;
        SceUInt         threadPreemptCount;
        SceUInt         releaseCount;
} SceKernelThreadRunStatus;

/* Sure there must be more than this, but haven't seen them */
enum PspThreadStatus
{
        PSP_THREAD_RUNNING = 1,
        PSP_THREAD_READY   = 2,
        PSP_THREAD_WAITING = 4,
        PSP_THREAD_SUSPEND = 8,
        PSP_THREAD_STOPPED = 16,
        PSP_THREAD_KILLED  = 32, /* Thread manager has killed the thread (stack overflow) */
};

SceUID sceKernelCreateThread(const char *name, SceKernelThreadEntry entry, int initPriority,
                             int stackSize, SceUInt attr, SceKernelThreadOptParam *option);

int sceKernelDeleteThread(SceUID thid);

int sceKernelStartThread(SceUID thid, SceSize arglen, void *argp);

int sceKernelExitThread(int status);

int sceKernelExitDeleteThread(int status);

int sceKernelTerminateThread(SceUID thid);

int sceKernelTerminateDeleteThread(SceUID thid);

int sceKernelSuspendDispatchThread(void);

int sceKernelResumeDispatchThread(int state);

int sceKernelSleepThread(void);

int sceKernelSleepThreadCB(void);

int sceKernelWakeupThread(SceUID thid);

int sceKernelCancelWakeupThread(SceUID thid);

int sceKernelSuspendThread(SceUID thid);

int sceKernelResumeThread(SceUID thid);

int sceKernelWaitThreadEnd(SceUID thid, SceUInt *timeout);

int sceKernelWaitThreadEndCB(SceUID thid, SceUInt *timeout);

int sceKernelDelayThread(SceUInt delay);

int sceKernelDelayThreadCB(SceUInt delay);

int sceKernelDelaySysClockThread(SceKernelSysClock *delay);

int sceKernelDelaySysClockThreadCB(SceKernelSysClock *delay);

int sceKernelChangeCurrentThreadAttr(int unknown, SceUInt attr);

int sceKernelChangeThreadPriority(SceUID thid, int priority);

int sceKernelRotateThreadReadyQueue(int priority);

int sceKernelReleaseWaitThread(SceUID thid);

int sceKernelGetThreadId(void);

int sceKernelGetThreadCurrentPriority(void);

int sceKernelGetThreadExitStatus(SceUID thid);

int sceKernelCheckThreadStack(void);

int sceKernelGetThreadStackFreeSize(SceUID thid);

int sceKernelReferThreadStatus(SceUID thid, SceKernelThreadInfo *info);

int sceKernelReferThreadRunStatus(SceUID thid, SceKernelThreadRunStatus *status);


/* Semaphores. */

typedef struct SceKernelSemaOptParam {
        SceSize         size;
} SceKernelSemaOptParam;

typedef struct SceKernelSemaInfo {
        SceSize         size;
        char            name[32];
        SceUInt         attr;
        int             initCount;
        int             currentCount;
        int             maxCount;
        int             numWaitThreads;
} SceKernelSemaInfo;

SceUID sceKernelCreateSema(const char *name, SceUInt attr, int initVal, int maxVal, SceKernelSemaOptParam *option);

int sceKernelDeleteSema(SceUID semaid);

int sceKernelSignalSema(SceUID semaid, int signal);

int sceKernelWaitSema(SceUID semaid, int signal, SceUInt *timeout);

int sceKernelWaitSemaCB(SceUID semaid, int signal, SceUInt *timeout);

int sceKernelPollSema(SceUID semaid, int signal);

int sceKernelReferSemaStatus(SceUID semaid, SceKernelSemaInfo *info);


/* Event flags. */

typedef struct SceKernelEventFlagInfo {
        SceSize         size;
        char            name[32];
        SceUInt         attr;
        SceUInt         initPattern;
        SceUInt         currentPattern;
        int             numWaitThreads;
} SceKernelEventFlagInfo;

struct SceKernelEventFlagOptParam {
        SceSize         size;
};

typedef struct SceKernelEventFlagOptParam SceKernelEventFlagOptParam;

enum PspEventFlagAttributes
{
        PSP_EVENT_WAITMULTIPLE = 0x200
};

enum PspEventFlagWaitTypes
{
        PSP_EVENT_WAITAND = 0,
        PSP_EVENT_WAITOR  = 1,
        PSP_EVENT_WAITCLEAR = 0x20
};

SceUID sceKernelCreateEventFlag(const char *name, int attr, int bits, SceKernelEventFlagOptParam *opt);

int sceKernelSetEventFlag(SceUID evid, u32 bits);

int sceKernelClearEventFlag(SceUID evid, u32 bits);

int sceKernelPollEventFlag(int evid, u32 bits, u32 wait, u32 *outBits);

int sceKernelWaitEventFlag(int evid, u32 bits, u32 wait, u32 *outBits, SceUInt *timeout);

int sceKernelWaitEventFlagCB(int evid, u32 bits, u32 wait, u32 *outBits, SceUInt *timeout);

int sceKernelDeleteEventFlag(int evid);

int sceKernelReferEventFlagStatus(SceUID event, SceKernelEventFlagInfo *status);


/* Message boxes. */

typedef struct SceKernelMbxOptParam {
        SceSize         size;
} SceKernelMbxOptParam;

typedef struct SceKernelMbxInfo {
        SceSize         size;
        char            name[32];
        SceUInt         attr;
        int             numWaitThreads;
        int             numMessages;
        void            *firstMessage;
} SceKernelMbxInfo;

typedef struct SceKernelMsgPacket {
        struct SceKernelMsgPacket *next;
        SceUChar    msgPriority;
        SceUChar    dummy[3];
} SceKernelMsgPacket;

SceUID sceKernelCreateMbx(const char *name, SceUInt attr, SceKernelMbxOptParam *option);

int sceKernelDeleteMbx(SceUID mbxid);

int sceKernelSendMbx(SceUID mbxid, void *message);

int sceKernelReceiveMbx(SceUID mbxid, void **pmessage, SceUInt *timeout);

int sceKernelReceiveMbxCB(SceUID mbxid, void **pmessage, SceUInt *timeout);

int sceKernelPollMbx(SceUID mbxid, void **pmessage);

int sceKernelCancelReceiveMbx(SceUID mbxid, int *pnum);

int sceKernelReferMbxStatus(SceUID mbxid, SceKernelMbxInfo *info);


/* Alarms. */

typedef SceUInt (*SceKernelAlarmHandler)(void *common);

typedef struct SceKernelAlarmInfo {
        SceSize         size;
        /* The current schedule */
        SceKernelSysClock schedule;
        SceKernelAlarmHandler handler;
        void *          common;
} SceKernelAlarmInfo;

SceUID sceKernelSetAlarm(SceUInt clock, SceKernelAlarmHandler handler, void *common);

SceUID sceKernelSetSysClockAlarm(SceKernelSysClock *clock, SceKernelAlarmHandler handler, void *common);

int sceKernelCancelAlarm(SceUID alarmid);

int sceKernelReferAlarmStatus(SceUID alarmid, SceKernelAlarmInfo *info);

/* Callbacks. */

typedef int (*SceKernelCallbackFunction)(int arg1, int arg2, void *arg);

typedef struct SceKernelCallbackInfo {
        SceSize         size;
        char    name[32];
        SceUID  threadId;
        SceKernelCallbackFunction       callback;
        void *  common;
        int     notifyCount;
        int     notifyArg;
} SceKernelCallbackInfo;

int sceKernelCreateCallback(const char *name, SceKernelCallbackFunction func, void *arg);

int sceKernelReferCallbackStatus(SceUID cb, SceKernelCallbackInfo *status);

int sceKernelDeleteCallback(SceUID cb);

int sceKernelNotifyCallback(SceUID cb, int arg2);

int sceKernelCancelCallback(SceUID cb);

int sceKernelGetCallbackCount(SceUID cb);

int sceKernelCheckCallback(void);

/* Misc. */

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,
};

int sceKernelGetThreadmanIdList(enum SceKernelIdListType type, SceUID *readbuf, int readbufsize, int *idcount);

typedef struct SceKernelSystemStatus {
        SceSize         size;
        SceUInt         status;
        SceKernelSysClock       idleClocks;
        SceUInt         comesOutOfIdleCount;
        SceUInt         threadSwitchCount;
        SceUInt         vfpuSwitchCount;
} SceKernelSystemStatus;

int sceKernelReferSystemStatus(SceKernelSystemStatus *status);


SceUID sceKernelCreateMsgPipe(const char *name, int part, int attr, void *unk1, void *opt);

int sceKernelDeleteMsgPipe(SceUID uid);

int sceKernelSendMsgPipe(SceUID uid, void *message, unsigned int size, int unk1, void *unk2, unsigned int *timeout);

int sceKernelSendMsgPipeCB(SceUID uid, void *message, unsigned int size, int unk1, void *unk2, unsigned int *timeout);

int sceKernelTrySendMsgPipe(SceUID uid, void *message, unsigned int size, int unk1, void *unk2);

int sceKernelReceiveMsgPipe(SceUID uid, void *message, unsigned int size, int unk1, void *unk2, unsigned int *timeout);

int sceKernelReceiveMsgPipeCB(SceUID uid, void *message, unsigned int size, int unk1, void *unk2, unsigned int *timeout);

int sceKernelTryReceiveMsgPipe(SceUID uid, void *message, unsigned int size, int unk1, void *unk2);

int sceKernelCancelMsgPipe(SceUID uid, int *psend, int *precv);

typedef struct SceKernelMppInfo {
        SceSize         size;
        char    name[32];
        SceUInt         attr;
        int     bufSize;
        int     freeSize;
        int     numSendWaitThreads;
        int     numReceiveWaitThreads;
} SceKernelMppInfo;
 
int sceKernelReferMsgPipeStatus(SceUID uid, SceKernelMppInfo *info);

/* VPL Functions */

struct SceKernelVplOptParam {
        SceSize         size;
};

SceUID sceKernelCreateVpl(const char *name, int part, int attr, unsigned int size, struct SceKernelVplOptParam *opt);

int sceKernelDeleteVpl(SceUID uid);

int sceKernelAllocateVpl(SceUID uid, unsigned int size, void **data, unsigned int *timeout);

int sceKernelAllocateVplCB(SceUID uid, unsigned int size, void **data, unsigned int *timeout);

int sceKernelTryAllocateVpl(SceUID uid, unsigned int size, void **data);

int sceKernelFreeVpl(SceUID uid, void *data);

int sceKernelCancelVpl(SceUID uid, int *pnum);

typedef struct SceKernelVplInfo {
        SceSize         size;
        char    name[32];
        SceUInt         attr;
        int     poolSize;
        int     freeSize;
        int     numWaitThreads;
} SceKernelVplInfo;

int sceKernelReferVplStatus(SceUID uid, SceKernelVplInfo *info);

/* FPL Functions */

struct SceKernelFplOptParam {
        SceSize         size;
};

int sceKernelCreateFpl(const char *name, int part, int attr, unsigned int size, unsigned int blocks, struct SceKernelFplOptParam *opt);

int sceKernelDeleteFpl(SceUID uid);

int sceKernelAllocateFpl(SceUID uid, void **data, unsigned int *timeout);

int sceKernelAllocateFplCB(SceUID uid, void **data, unsigned int *timeout);

int sceKernelTryAllocateFpl(SceUID uid, void **data);

int sceKernelFreeFpl(SceUID uid, void *data);

int sceKernelCancelFpl(SceUID uid, int *pnum);

typedef struct SceKernelFplInfo {
        SceSize         size;
        char    name[32];
        SceUInt         attr;
        int     blockSize;
        int     numBlocks;
        int     freeBlocks;
        int     numWaitThreads;
} SceKernelFplInfo;

int sceKernelReferFplStatus(SceUID uid, SceKernelFplInfo *info);

void _sceKernelReturnFromTimerHandler(void);

void _sceKernelReturnFromCallback(void);

int sceKernelUSec2SysClock(unsigned int usec, SceKernelSysClock *clock);

SceInt64 sceKernelUSec2SysClockWide(unsigned int usec);

int sceKernelSysClock2USec(SceKernelSysClock *clock, unsigned int *low, unsigned int *high);

int sceKernelSysClock2USecWide(SceInt64 clock, unsigned *low, unsigned int *high);

int sceKernelGetSystemTime(SceKernelSysClock *time);

SceInt64 sceKernelGetSystemTimeWide(void);

unsigned int sceKernelGetSystemTimeLow(void);

struct SceKernelVTimerOptParam {
        SceSize         size;
};

SceUID sceKernelCreateVTimer(const char *name, struct SceKernelVTimerOptParam *opt);

int sceKernelDeleteVTimer(SceUID uid);

int sceKernelGetVTimerBase(SceUID uid, SceKernelSysClock *base);

SceInt64 sceKernelGetVTimerBaseWide(SceUID uid);

int sceKernelGetVTimerTime(SceUID uid, SceKernelSysClock *time);

SceInt64 sceKernelGetVTimerTimeWide(SceUID uid);

int sceKernelSetVTimerTime(SceUID uid, SceKernelSysClock *time);

SceInt64 sceKernelSetVTimerTimeWide(SceUID uid, SceInt64 time);

int sceKernelStartVTimer(SceUID uid);

int sceKernelStopVTimer(SceUID uid);

typedef SceUInt (*SceKernelVTimerHandler)(SceUID uid, SceKernelSysClock *, SceKernelSysClock *, void *);
typedef SceUInt (*SceKernelVTimerHandlerWide)(SceUID uid, SceInt64, SceInt64, void *);

int sceKernelSetVTimerHandler(SceUID uid, SceKernelSysClock *time, SceKernelVTimerHandler handler, void *common);

int sceKernelSetVTimerHandlerWide(SceUID uid, SceInt64 time, SceKernelVTimerHandlerWide handler, void *common);

int sceKernelCancelVTimerHandler(SceUID uid);

typedef struct SceKernelVTimerInfo {
        SceSize         size;
        char    name[32];
        int     active;
        SceKernelSysClock       base;
        SceKernelSysClock       current;
        SceKernelSysClock       schedule;
        SceKernelVTimerHandler  handler;
        void *  common;
} SceKernelVTimerInfo;

int sceKernelReferVTimerStatus(SceUID uid, SceKernelVTimerInfo *info);

void _sceKernelExitThread(void);

enum SceKernelIdListType sceKernelGetThreadmanIdType(SceUID uid);

typedef int (*SceKernelThreadEventHandler)(int mask, SceUID thid, void *common);

typedef struct SceKernelThreadEventHandlerInfo {
        SceSize         size;
        char    name[32];
        SceUID  threadId;
        int     mask;
        SceKernelThreadEventHandler     handler;
        void *  common;
} SceKernelThreadEventHandlerInfo;

enum ThreadEventIds
{
        THREADEVENT_ALL = 0xFFFFFFFF,
        THREADEVENT_KERN = 0xFFFFFFF8,
        THREADEVENT_USER = 0xFFFFFFF0,
        THREADEVENT_CURRENT = 0
};

enum ThreadEvents
{
        THREAD_CREATE = 1,
        THREAD_START  = 2,
        THREAD_EXIT   = 4,
        THREAD_DELETE = 8,
};

SceUID sceKernelRegisterThreadEventHandler(const char *name, SceUID threadID, int mask, SceKernelThreadEventHandler handler, void *common);

int sceKernelReleaseThreadEventHandler(SceUID uid);

int sceKernelReferThreadEventHandlerStatus(SceUID uid, struct SceKernelThreadEventHandlerInfo *info);

PspDebugProfilerRegs *sceKernelReferThreadProfiler(void);

PspDebugProfilerRegs *sceKernelReferGlobalProfiler(void);

#ifdef __cplusplus
}
#endif

#endif