wpad.h

Go to the documentation of this file.

#pragma once
#include <wut.h>
#include <coreinit/time.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct WPADStatusProController WPADStatusProController;
typedef struct WPADVec2D WPADVec2D;
typedef struct WPADInfo WPADInfo;
typedef struct WPADAddress WPADAddress;
typedef struct WPADiQueueElement WPADiQueueElement;
typedef struct WPADiQueue WPADiQueue;
 
typedef enum WPADChan
{
   WPAD_CHAN_0                         = 0,
   WPAD_CHAN_1                         = 1,
   WPAD_CHAN_2                         = 2,
   WPAD_CHAN_3                         = 3,
   WPAD_CHAN_4                         = 4,
   WPAD_CHAN_5                         = 5,
   WPAD_CHAN_6                         = 6,
} WPADChan;
 
typedef enum WPADDataFormat
{
   WPAD_FMT_CORE                       = 0,
   WPAD_FMT_CORE_ACC                   = 1,
   WPAD_FMT_CORE_ACC_DPD               = 2,
   WPAD_FMT_NUNCHUK                    = 3,
   WPAD_FMT_NUNCHUK_ACC                = 4,
   WPAD_FMT_NUNCHUK_ACC_DPD            = 5,
   WPAD_FMT_CLASSIC                    = 6,
   WPAD_FMT_CLASSIC_ACC                = 7,
   WPAD_FMT_CLASSIC_ACC_DPD            = 8,
   WPAD_FMT_CORE_ACC_DPD_FULL          = 9,
   WPAD_FMT_TRAIN                      = 10,
   WPAD_FMT_GUITAR                     = 11,
   WPAD_FMT_BALANCE_BOARD              = 12,
   WPAD_FMT_DRUM                       = 15,
   WPAD_FMT_MPLUS                      = 16,
   WPAD_FMT_TAIKO                      = 17,
   WPAD_FMT_PRO_CONTROLLER             = 22,
} WPADDataFormat;
 
typedef enum WPADExtensionType
{
   WPAD_EXT_CORE                    = 0,
   WPAD_EXT_NUNCHUK                 = 1,
   WPAD_EXT_CLASSIC                 = 2,
   WPAD_EXT_MPLUS                   = 5,
   WPAD_EXT_MPLUS_NUNCHUK           = 6,
   WPAD_EXT_MPLUS_CLASSIC           = 7,
   WPAD_EXT_PRO_CONTROLLER          = 31,
   WPAD_EXT_DEV_NOT_FOUND           = 253,
   WPAD_EXT_UNKNOWN                 = 255
} WPADExtensionType;
 
typedef enum WPADButton
{
   WPAD_BUTTON_LEFT                    = 0x0001,
   WPAD_BUTTON_RIGHT                   = 0x0002,
   WPAD_BUTTON_DOWN                    = 0x0004,
   WPAD_BUTTON_UP                      = 0x0008,
   WPAD_BUTTON_PLUS                    = 0x0010,
   WPAD_BUTTON_2                       = 0x0100,
   WPAD_BUTTON_1                       = 0x0200,
   WPAD_BUTTON_B                       = 0x0400,
   WPAD_BUTTON_A                       = 0x0800,
   WPAD_BUTTON_MINUS                   = 0x1000,
   WPAD_BUTTON_Z                       = 0x2000,
   WPAD_BUTTON_C                       = 0x4000,
   WPAD_BUTTON_HOME                    = 0x8000,
} WPADButton;
 
typedef enum WPADNunchukButton
{
   WPAD_NUNCHUK_STICK_EMULATION_LEFT  = 0x0001,
   WPAD_NUNCHUK_STICK_EMULATION_RIGHT = 0x0002,
   WPAD_NUNCHUK_STICK_EMULATION_DOWN  = 0x0004,
   WPAD_NUNCHUK_STICK_EMULATION_UP    = 0x0008,
   WPAD_NUNCHUK_BUTTON_Z              = 0x2000,
   WPAD_NUNCHUK_BUTTON_C              = 0x4000,
} WPADNunchukButton;
 
typedef enum WPADClassicButton
{
   WPAD_CLASSIC_BUTTON_UP               = 0x00000001,
   WPAD_CLASSIC_BUTTON_LEFT             = 0x00000002,
   WPAD_CLASSIC_BUTTON_ZR               = 0x00000004,
   WPAD_CLASSIC_BUTTON_X                = 0x00000008,
   WPAD_CLASSIC_BUTTON_A                = 0x00000010,
   WPAD_CLASSIC_BUTTON_Y                = 0x00000020,
   WPAD_CLASSIC_BUTTON_B                = 0x00000040,
   WPAD_CLASSIC_BUTTON_ZL               = 0x00000080,
   WPAD_CLASSIC_BUTTON_R                = 0x00000200,
   WPAD_CLASSIC_BUTTON_PLUS             = 0x00000400,
   WPAD_CLASSIC_BUTTON_HOME             = 0x00000800,
   WPAD_CLASSIC_BUTTON_MINUS            = 0x00001000,
   WPAD_CLASSIC_BUTTON_L                = 0x00002000,
   WPAD_CLASSIC_BUTTON_DOWN             = 0x00004000,
   WPAD_CLASSIC_BUTTON_RIGHT            = 0x00008000,
   WPAD_CLASSIC_STICK_L_EMULATION_LEFT  = 0x00010000,
   WPAD_CLASSIC_STICK_L_EMULATION_RIGHT = 0x00020000,
   WPAD_CLASSIC_STICK_L_EMULATION_DOWN  = 0x00040000,
   WPAD_CLASSIC_STICK_L_EMULATION_UP    = 0x00080000,
   WPAD_CLASSIC_STICK_R_EMULATION_LEFT  = 0x00100000,
   WPAD_CLASSIC_STICK_R_EMULATION_RIGHT = 0x00200000,
   WPAD_CLASSIC_STICK_R_EMULATION_DOWN  = 0x00400000,
   WPAD_CLASSIC_STICK_R_EMULATION_UP    = 0x00800000,
} WPADClassicButton;
 
typedef enum WPADProButton
{
   WPAD_PRO_BUTTON_UP                  = 0x00000001,
   WPAD_PRO_BUTTON_LEFT                = 0x00000002,
   WPAD_PRO_TRIGGER_ZR                 = 0x00000004,
   WPAD_PRO_BUTTON_X                   = 0x00000008,
   WPAD_PRO_BUTTON_A                   = 0x00000010,
   WPAD_PRO_BUTTON_Y                   = 0x00000020,
   WPAD_PRO_BUTTON_B                   = 0x00000040,
   WPAD_PRO_TRIGGER_ZL                 = 0x00000080,
   WPAD_PRO_RESERVED                   = 0x00000100,
   WPAD_PRO_TRIGGER_R                  = 0x00000200,
   WPAD_PRO_BUTTON_PLUS                = 0x00000400,
   WPAD_PRO_BUTTON_HOME                = 0x00000800,
   WPAD_PRO_BUTTON_MINUS               = 0x00001000,
   WPAD_PRO_TRIGGER_L                  = 0x00002000,
   WPAD_PRO_BUTTON_DOWN                = 0x00004000,
   WPAD_PRO_BUTTON_RIGHT               = 0x00008000,
   WPAD_PRO_BUTTON_STICK_R             = 0x00010000,
   WPAD_PRO_BUTTON_STICK_L             = 0x00020000,
   WPAD_PRO_STICK_L_EMULATION_UP       = 0x00200000,
   WPAD_PRO_STICK_L_EMULATION_DOWN     = 0x00100000,
   WPAD_PRO_STICK_L_EMULATION_LEFT     = 0x00040000,
   WPAD_PRO_STICK_L_EMULATION_RIGHT    = 0x00080000,
   WPAD_PRO_STICK_R_EMULATION_UP       = 0x02000000,
   WPAD_PRO_STICK_R_EMULATION_DOWN     = 0x01000000,
   WPAD_PRO_STICK_R_EMULATION_LEFT     = 0x00400000,
   WPAD_PRO_STICK_R_EMULATION_RIGHT    = 0x00800000,
} WPADProButton;
 
typedef enum WPADLed
{
  WPAD_LED_ONE      = 0x01,
  WPAD_LED_TWO      = 0x02,
  WPAD_LED_THREE    = 0x04,
  WPAD_LED_FOUR     = 0x08
} WPADLed;
WUT_ENUM_BITMASK_TYPE(WPADLed);
 
typedef enum WPADDpdFormat
{
    WPAD_DPD_FMT_NONE = 0,
    WPAD_DPD_FMT_BASIC = 1,
    WPAD_DPD_FMT_EXTENDED = 3,
    WPAD_DPD_FMT_FULL = 5
} WPADDpdFormat;
 
typedef enum WPADSpeakerCmd
{
    WPAD_SPEAKER_CMD_OFF    = 0,
    WPAD_SPEAKER_CMD_ON     = 1,
    WPAD_SPEAKER_CMD_MUTE   = 2,
    WPAD_SPEAKER_CMD_UNMUTE = 3,
    WPAD_SPEAKER_CMD_PLAY   = 4,
    WPAD_SPEAKER_CMD_ON_ALT = 5
} WPADSpeakerCmd;
 
typedef enum WPADMplsMode
{
    WPAD_MPLS_MODE_DISABLE      = 0,
    WPAD_MPLS_MODE_MPLS_ONLY    = 4,
    WPAD_MPLS_MODE_MPLS_NUNCHUK = 5,
    WPAD_MPLS_MODE_MPLS_CLASSIC = 7
} WPADMplsMode;
 
 
typedef enum WPADPeripheralSpace
{
    WPAD_PERIPHERAL_SPACE_SPEAKER     = 0xA2,
    WPAD_PERIPHERAL_SPACE_EXTENSION   = 0xA4,
    WPAD_PERIPHERAL_SPACE_MOTIONPLUS  = 0xA6,
    WPAD_PERIPHERAL_SPACE_DPD         = 0xB0
} WPADPeripheralSpace;
 
struct WPADVec2D
{
   int16_t x;
   int16_t y;
};
WUT_CHECK_OFFSET(WPADVec2D, 0x00, x);
WUT_CHECK_OFFSET(WPADVec2D, 0x02, y);
WUT_CHECK_SIZE(WPADVec2D, 0x04);
 
struct WPADStatusProController
{
   WUT_UNKNOWN_BYTES(0x28);
 
   uint8_t extensionType;
 
   uint8_t err;
   WUT_PADDING_BYTES(2);
   uint32_t buttons;
   WPADVec2D leftStick;
   WPADVec2D rightStick;
   WUT_UNKNOWN_BYTES(8);
   WPADDataFormat dataFormat;
};
WUT_CHECK_OFFSET(WPADStatusProController, 0x28, extensionType);
WUT_CHECK_OFFSET(WPADStatusProController, 0x29, err);
WUT_CHECK_OFFSET(WPADStatusProController, 0x2C, buttons);
WUT_CHECK_OFFSET(WPADStatusProController, 0x30, leftStick);
WUT_CHECK_OFFSET(WPADStatusProController, 0x34, rightStick);
WUT_CHECK_OFFSET(WPADStatusProController, 0x40, dataFormat);
WUT_CHECK_SIZE(WPADStatusProController, 0x44);
 
struct WPADInfo
{
    uint32_t irEnabled;
    uint32_t speakerEnabled;
    uint32_t extensionAttached;
    uint32_t batteryLow;
    uint32_t batteryNearEmpty;
    uint8_t batteryLevel;
    uint8_t led;
    uint8_t protocol;
    uint8_t firmware;
};
WUT_CHECK_OFFSET(WPADInfo, 0x00, irEnabled);
WUT_CHECK_OFFSET(WPADInfo, 0x04, speakerEnabled);
WUT_CHECK_OFFSET(WPADInfo, 0x08, extensionAttached);
WUT_CHECK_OFFSET(WPADInfo, 0x0c, batteryLow);
WUT_CHECK_OFFSET(WPADInfo, 0x10, batteryNearEmpty);
WUT_CHECK_OFFSET(WPADInfo, 0x14, batteryLevel);
WUT_CHECK_OFFSET(WPADInfo, 0x15, led);
WUT_CHECK_OFFSET(WPADInfo, 0x16, protocol);
WUT_CHECK_OFFSET(WPADInfo, 0x17, firmware);
WUT_CHECK_SIZE(WPADInfo, 0x18);
 
 
struct WPADiQueueElement
{
    uint8_t data[0x30];
};
WUT_CHECK_OFFSET(WPADiQueueElement, 0x00, data);
WUT_CHECK_SIZE(WPADiQueueElement, 0x30);
 
struct WPADiQueue
{
    uint8_t frontIndex;
    uint8_t backIndex;
    WUT_PADDING_BYTES(2);
    WPADiQueueElement* elements;
    uint32_t capacity;
};
WUT_CHECK_OFFSET(WPADiQueue, 0x00, frontIndex);
WUT_CHECK_OFFSET(WPADiQueue, 0x01, backIndex);
WUT_CHECK_OFFSET(WPADiQueue, 0x04, elements);
WUT_CHECK_OFFSET(WPADiQueue, 0x08, capacity);
WUT_CHECK_SIZE(WPADiQueue, 0xc);
 
struct WPADAddress
{
    uint8_t btDeviceAddress[6];
};
WUT_CHECK_OFFSET(WPADAddress, 0x00, btDeviceAddress);
WUT_CHECK_SIZE(WPADAddress, 0x6);
 
typedef void (*WPADIsMplsAttachedCallback)(WPADChan chan, int32_t status);
typedef void (*WPADControlLedCallback)(WPADChan chan, int32_t status);
typedef void (*WPADControlDpdCallback)(WPADChan chan, int32_t status);
typedef void (*WPADControlSpeakerCallback)(WPADChan chan, int32_t status);
 
typedef void (*WPADGetInfoCallback)(WPADChan chan, int32_t status);
 
typedef void (*WPADReadMemoryCallback)(WPADChan chan, int32_t status);
 
typedef void (*WPADWriteMemoryCallback)(WPADChan chan, int32_t status);
 
typedef void (*WPADSamplingCallback)(WPADChan chan);
 
typedef void (*WPADExtensionCallback)(WPADChan chan, WPADExtensionType ext);
 
typedef void (*WPADConnectCallback)(WPADChan chan, int32_t status);
 
typedef void (*WPADiSendCallback)(WPADChan chan, int32_t status);
 
typedef void (*WPADiWriteGameDataCallback)(WPADChan chan, int32_t status);
 
void
WPADInit();
 
void
WPADShutdown();
 
void
WPADDisconnect(WPADChan chan);
 
int32_t
WPADProbe(WPADChan chan,
          WPADExtensionType *outExtensionType);
 
int32_t
WPADSetDataFormat(WPADChan chan,
                  WPADDataFormat format);
 
WPADDataFormat 
WPADGetDataFormat(WPADChan chan);
 
void
WPADRead(WPADChan chan,
         void *data);
 
int32_t
WPADControlLed(WPADChan channel, 
               WPADLed led, 
               WPADControlLedCallback callback);
 
int32_t 
WPADControlDpd(WPADChan channel,
               WPADDpdFormat mode,
               WPADControlDpdCallback callback);
 
WPADDpdFormat
WPADGetDpdFormat(WPADChan chan);
 
void
WPADControlMotor(WPADChan chan,
                 BOOL motorEnabled);
 
int32_t
WPADControlSpeaker(WPADChan chan,
                   WPADSpeakerCmd mode,
                   WPADControlSpeakerCallback);
 
BOOL
WPADIsSpeakerEnabled(WPADChan chan);
 
BOOL
WPADCanSendStreamData(WPADChan chan);
 
int32_t
WPADSendStreamData(WPADChan chan,
                   void* data,
                   uint32_t size);
 
uint8_t
WPADGetSpeakerVolume();
 
void
WPADSetSpeakerVolume(uint8_t volume);
 
int32_t 
WPADIsMplsAttached(WPADChan channel, 
                  BOOL *enabled,
                  WPADIsMplsAttachedCallback callback);
 
int32_t
WPADIsMplsIntegrated(WPADChan channel);
 
int32_t
WPADGetInfo(WPADChan channel,
            WPADInfo* outInfo);
 
int32_t
WPADGetInfoAsync(WPADChan channel,
            WPADInfo* outInfo,
            WPADGetInfoCallback);
 
int32_t
WPADReadMemoryAsync(WPADChan channel,
                    void *destination,
                    uint16_t size,
                    uint32_t address,
                    WPADReadMemoryCallback callback);
 
int32_t
WPADWriteMemoryAsync(WPADChan channel,
                     void *source,
                     uint32_t size,
                     uint32_t address,
                     WPADWriteMemoryCallback callback);
 
int32_t
WPADReadExtReg(WPADChan channel,
               void *destination,
               uint16_t size,
               WPADPeripheralSpace peripheral,
               uint32_t address,
               WPADReadMemoryCallback callback);
 
int32_t
WPADWriteExtReg(WPADChan channel,
                void *source,
                uint32_t size,
                WPADPeripheralSpace peripheral,
                uint32_t address,
                WPADWriteMemoryCallback callback);
 
int32_t
WPADGetBLCalibration(WPADChan channel,
                     void *destination,
                     uint32_t address,
                     uint32_t size,
                     WPADReadMemoryCallback callback);
void
WPADSetPowerSaveMode(WPADChan chan,
                     BOOL powerSave);
 
BOOL
WPADGetPowerSaveMode(WPADChan chan);
 
void
WPADGetAddress(WPADChan chan,
               WPADAddress* outAddress);
 
void 
WPADEnableMotor(BOOL enable);
 
BOOL 
WPADIsMotorEnabled();
 
void
WPADEnableURCC(BOOL enable);
 
BOOL
WPADIsEnabledURC();
 
void
WPADEnableWBC(BOOL enable);
 
BOOL
WPADIsEnableWBC();
 
void
WPADEnableWiiRemote(BOOL enable);
 
void
WPADSetAutoSleepTime(uint8_t time);
 
BOOL
WPADStartSyncDevice();
 
BOOL
WPADStartSyncDeviceEx(WPADAddress* deviceAddress,
                      const char* deviceName);
 
WPADConnectCallback
WPADSetConnectCallback(WPADChan chan,
                       WPADConnectCallback callback);
WPADExtensionCallback
WPADSetExtensionCallback(WPADChan chan,
                         WPADExtensionCallback callback);
 
WPADSamplingCallback
WPADSetSamplingCallback(WPADChan chan,
                        WPADSamplingCallback callback);
 
void
WPADiShutdown();
 
void
WPADiClearQueue(WPADiQueue* queue);
 
bool
WPADiIsAvailableCmdQueue(WPADiQueue* queue,
                         uint32_t count);
 
int32_t
WPADiHIDParser(WPADChan channel,
               uint8_t* hidData);
 
 
BOOL
WPADiSendSetVibrator(WPADiQueue* cmdQueue);
 
BOOL
WPADiSendSetPort(WPADiQueue* cmdQueue,
                 WPADLed led,
                 WPADiSendCallback callback);
 
BOOL
WPADiSendSetReportType(WPADiQueue* cmdQueue,
                       WPADDataFormat dataFormat,
                       BOOL powerSave,
                       WPADiSendCallback callback);
 
BOOL
WPADiSendGetContStat(WPADiQueue* cmdQueue,
                     WPADInfo* outInfo,
                     WPADiSendCallback callback);
 
BOOL
WPADiSendEnableDPD(WPADiQueue* cmdQueue,
               BOOL enable,
               WPADiSendCallback callback);
 
BOOL
WPADiSendEnableDPDCSB(WPADiQueue* cmdQueue,
                  BOOL enable,
                  WPADiSendCallback callback);
 
BOOL
WPADiSendEnableSpeaker(WPADiQueue* cmdQueue,
                       BOOL enable,
                       WPADiSendCallback callback);
 
BOOL
WPADiSendMuteSpeaker(WPADiQueue* cmdQueue,
                     BOOL mute,
                     WPADiSendCallback callback);
 
BOOL
WPADiSendStreamData(WPADiQueue* cmdQueue,
                    void* source,
                    uint32_t size);
 
BOOL
WPADiSendWriteDataCmd(WPADiQueue* cmdQueue,
                      uint8_t byte,
                      uint32_t address,
                      WPADiSendCallback callback);
 
BOOL
WPADiSendWriteData(WPADiQueue* cmdQueue,
                   void* source,
                   uint32_t size,
                   uint32_t address,
                   WPADiSendCallback callback);
 
BOOL
WPADiSendReadData(WPADiQueue* cmdQueue,
                  void* destination,
                  uint16_t size,
                  uint32_t address,
                  WPADiSendCallback callback);
 
uint32_t*
WPADiGetGameCode();
 
uint8_t
WPADiGetGameType();
 
void
WPADSetGameTitleUtf16(uint16_t* title);
 
int32_t
WPADGetGameTitleUtf16(WPADChan chan,
                      uint16_t** outTitle);
 
int32_t
WPADGetGameDataTimestamp(WPADChan chan,
                         OSTime* timestamp);
 
int32_t
WPADiWriteGameData(WPADChan channel,
                   void* source,
                   uint16_t size,
                   uint32_t offset,
                   WPADWriteMemoryCallback callback);
 
int32_t
WPADiReadGameData(WPADChan channel,
                  void* destination,
                  uint16_t size,
                  uint32_t offset,
                  WPADReadMemoryCallback callback);
 
WPADMplsMode
WPADiGetMplsStatus();
 
#ifdef __cplusplus
}
#endif