ctrl.h

 
#include "common_header.h"
 
#ifndef CTRL_H
#define CTRL_H
 
typedef void (*SceKernelButtonCallbackFunction)(u32 curButtons, u32 lastButtons, void *opt);
 
typedef struct {
    u32 timeStamp;
    u32 buttons;
    u8 aX;
    u8 aY;
    u8 rX;
    u8 rY;
    u8 rsrv[4];
} SceCtrlData;
 
typedef struct {
    u32 timeStamp;
    u32 buttons;
    u8 aX;
    u8 aY;
    u8 rX;
    u8 rY;
    u8 rsrv[4];
    s32 DPadSenseA;
    s32 DPadSenseB;
    s32 GPadSenseA;
    s32 GPadSenseB;
    s32 AxisSenseA;
    s32 AxisSenseB;
    s32 TiltA;
    s32 TiltB;
} SceCtrlData2;
 
typedef struct {
    u32 buttonMake;
    u32 buttonBreak;
    u32 buttonPress;
    u32 buttonRelease;
} SceCtrlLatch;
 
typedef struct {
    s32 unk1;
        s32 (*copyInputData)(void *pSrc, SceCtrlData2 *pDst);
} SceCtrlInputDataTransferHandler;
 
enum SceCtrlPadButtons {
    SCE_CTRL_SELECT         = 0x00000001,
    SCE_CTRL_L3             = 0x00000002,
    SCE_CTRL_R3             = 0x00000004,
    SCE_CTRL_START          = 0x00000008,
    SCE_CTRL_UP             = 0x00000010,
    SCE_CTRL_RIGHT          = 0x00000020,
    SCE_CTRL_DOWN           = 0x00000040,
    SCE_CTRL_LEFT           = 0x00000080,
    SCE_CTRL_LTRIGGER       = 0x00000100,
    SCE_CTRL_RTRIGGER       = 0x00000200,
    SCE_CTRL_L1TRIGGER      = 0x00000400,
    SCE_CTRL_R1TRIGGER      = 0x00000800,
    SCE_CTRL_TRIANGLE       = 0x00001000,
    SCE_CTRL_CIRCLE         = 0x00002000,
    SCE_CTRL_CROSS          = 0x00004000,
    SCE_CTRL_SQUARE         = 0x00008000,
    SCE_CTRL_INTERCEPTED    = 0x00010000,
    SCE_CTRL_HOLD           = 0x00020000,
    SCE_CTRL_WLAN_UP        = 0x00040000,
    SCE_CTRL_REMOTE         = 0x00080000,
    SCE_CTRL_VOLUP          = 0x00100000,
    SCE_CTRL_VOLDOWN        = 0x00200000,
    SCE_CTRL_SCREEN         = 0x00400000,
    SCE_CTRL_NOTE           = 0x00800000,       
    SCE_CTRL_DISC           = 0x01000000,
    SCE_CTRL_MS             = 0x02000000,
    SCE_CTRL_UNK_10000000   = 0x10000000,
    SCE_CTRL_UNK_20000000   = 0x20000000,
};
 
enum SceCtrlPadInputMode {
    SCE_CTRL_INPUT_DIGITAL_ONLY = 0,         
    SCE_CTRL_INPUT_DIGITAL_ANALOG = 1,
};
 
enum SceCtrlPadPollMode {
    SCE_CTRL_POLL_INACTIVE = 0,
    SCE_CTRL_POLL_ACTIVE = 1,
};
 
enum SceCtrlPort {
    /* Input is only obtained from the PSP. */
    SCE_CRTL_PORT_PSP = 0,
    /* Input is obtained from the PSP and a connected DualShock3 controller. */
    SCE_CTRL_PORT_DS3 = 1,
    /* Input is obtained from the PSP and an unknown connected external device. */
    SCE_CTRL_PORT_UNKNOWN_2 = 2
};
 
enum SceCtrlPadButtonMaskMode {
    SCE_CTRL_MASK_NO_MASK = 0,
    SCE_CTRL_MASK_IGNORE_BUTTONS = 1,
    SCE_CTRL_MASK_APPLY_BUTTONS = 2,
};
 
/* The center position of the analog stick on both axes. */
#define SCE_CTRL_ANALOG_PAD_CENTER_VALUE            0x80
 
s32 sceCtrlInit(void);
 
s32 sceCtrlEnd(void);
 
s32 sceCtrlSuspend(void);
 
s32 sceCtrlResume(void);
 
u32 sceCtrlSetPollingMode(u8 pollMode);
 
u32 sceCtrlGetSamplingMode(u8 *pMode);
 
s32 sceCtrlSetSamplingMode(u8 mode);
 
u32 sceCtrlGetSamplingCycle(u32 *pCycle);
 
s32 sceCtrlSetSamplingCycle(u32 cycle);
 
u32 sceCtrlGetIdleCancelKey(u32 *pResetButtonsMake, u32 *pResetButtonsPress, u32 *pResetButtonsMakeHoldMode, 
                            u32 *pResetButtonsPressHoldMode);
 
u32 sceCtrlSetIdleCancelKey(u32 resetButtonsMake, u32 resetButtonsPress, u32 resetButtonsMakeHoldMode,
                            u32 resetButtonsPressHoldMode);
 
/* This constant defines that analog stick movement does not cancel the idle timer. */
#define SCE_CTRL_IDLE_CANCEL_TRESHOLD_NO_CANCELLATION    (-1)
 
s32 sceCtrlGetIdleCancelThreshold(s32 *pUnHoldThreshold, s32 *pHoldThreshold);
 
s32 sceCtrlSetIdleCancelThreshold(s32 unHoldThreshold, s32 holdThreshold);
 
s16 sceCtrlGetSuspendingExtraSamples(void);
 
s32 sceCtrlSetSuspendingExtraSamples(s16 suspendSamples);
 
s32 sceCtrl_driver_E467BEC8(u8 externalPort, SceCtrlInputDataTransferHandler *transferHandler, void *inputSource);
 
s32 sceCtrlPeekLatch(SceCtrlLatch *pLatch);
 
s32 sceCtrlReadLatch(SceCtrlLatch *pLatch);
 
s32 sceCtrlPeekBufferPositive(SceCtrlData *pData, u8 nBufs);
 
s32 sceCtrlPeekBufferNegative(SceCtrlData *pData, u8 nBufs);
 
s32 sceCtrlReadBufferPositive(SceCtrlData *pData, u8 nBufs);
 
s32 sceCtrlReadBufferNegative(SceCtrlData *pData, u8 nBufs);
 
s32 sceCtrlPeekBufferPositive2(u32 port, SceCtrlData2 *pData, u8 nBufs);
 
s32 sceCtrlPeekBufferNegative2(u32 port, SceCtrlData2 *pData, u8 nBufs);
 
s32 sceCtrlReadBufferPositive2(u32 port, SceCtrlData2 *pData, u8 nBufs);
 
s32 sceCtrlReadBufferNegative2(u32 port, SceCtrlData2 *pData, u8 nBufs);
 
s32 sceCtrlClearRapidFire(u8 slot);
 
s32 sceCtrlSetRapidFire(u8 slot, u32 uiMask, u32 uiTrigger, u32 uiTarget, u8 uiDelay, 
                        u8 uiMake, u8 uiBreak);
 
s32 sceCtrlSetAnalogEmulation(u8 slot, u8 aX, u8 aY, u32 uiMake);
 
s32 sceCtrlSetButtonEmulation(u8 slot, u32 userButtons, u32 kernelButtons, u32 uiMake);
 
u32 sceCtrlGetButtonIntercept(u32 buttons);
 
u32 sceCtrlSetButtonIntercept(u32 buttons, u32 buttonMaskMode);
 
s32 sceCtrlSetSpecialButtonCallback(u32 slot, u32 buttonMask, SceKernelButtonCallbackFunction callback, void *opt);
 
u32 sceCtrl_driver_6C86AF22(s32 arg1);
 
u32 sceCtrl_driver_5886194C(s8 arg1);
 
u32 sceCtrlUpdateCableTypeReq(void);
 
#endif  /* CTRL_H */