wpad.h

Go to the documentation of this file.

#pragma once
#include <wut.h>
#include <coreinit/time.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define WPAD_MAX_IR_DOTS 4
#define WPAD_MAX_PRESSURE_SENSORS 4
 
typedef struct WPADStatusProController WPADStatusProController;
typedef struct WPADVec2D WPADVec2D;
typedef struct WPADVec3D WPADVec3D;
typedef struct WPADInfo WPADInfo;
typedef struct WPADAddress WPADAddress;
typedef struct WPADiQueueElement WPADiQueueElement;
typedef struct WPADiQueue WPADiQueue;
typedef struct WPADIRDot WPADIRDot;
typedef struct WPADIRDotEx WPADIRDotEx;
typedef struct WPADStatus WPADStatus;
typedef struct WPADStatusEx WPADStatusEx;
typedef struct WPADStatusNunchuk WPADStatusNunchuk;
typedef struct WPADStatusClassic WPADStatusClassic;
typedef struct WPADStatusMotionPlus WPADStatusMotionPlus;
typedef struct WPADStatusBalanceBoard WPADStatusBalanceBoard;
typedef struct WPADStatusTrain WPADStatusTrain;
typedef WPADStatusProController WPADStatusPro;
typedef struct WENCParams WENCParams;
 
typedef enum WPADError
{
   WPAD_ERROR_NONE          =  0,
   WPAD_ERROR_NO_CONTROLLER = -1,
   WPAD_ERROR_NOT_READY     = -2,
   WPAD_ERROR_TRANSFER      = -3,
   WPAD_ERROR_INVALID       = -4,
   WPAD_ERROR_PERMISSION    = -5,
   WPAD_ERROR_BROKEN        = -6,
   WPAD_ERROR_QUEUE_EMPTY   = -7,
   WPAD_ERROR_BAD_VALUE     = -8,
   WPAD_ERROR_BAD_CONF      = -9,
} WPADError;
 
 
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              = 0x00,
   WPAD_FMT_CORE_ACC          = 0x01,
   WPAD_FMT_CORE_ACC_DPD      = 0x02,
   WPAD_FMT_NUNCHUK           = 0x03,
   WPAD_FMT_NUNCHUK_ACC       = 0x04,
   WPAD_FMT_NUNCHUK_ACC_DPD   = 0x05,
   WPAD_FMT_CLASSIC           = 0x06,
   WPAD_FMT_CLASSIC_ACC       = 0x07,
   WPAD_FMT_CLASSIC_ACC_DPD   = 0x08,
   WPAD_FMT_CORE_ACC_DPD_FULL = 0x09,
   WPAD_FMT_TRAIN             = 0x0A,
   WPAD_FMT_GUITAR            = 0x0B,
   WPAD_FMT_BALANCE_BOARD     = 0x0C,
   WPAD_FMT_DRUM              = 0x0F,
   WPAD_FMT_MPLUS             = 0x10,
   WPAD_FMT_TAIKO             = 0x11,
   WPAD_FMT_PRO_CONTROLLER    = 0x16,
} WPADDataFormat;
 
typedef enum WPADExtensionType
{
   WPAD_EXT_CORE           = 0x00,
   WPAD_EXT_NUNCHUK        = 0x01,
   WPAD_EXT_CLASSIC        = 0x02,
   WPAD_EXT_BALANCE_BOARD  = 0x03,
   WPAD_EXT_MPLUS          = 0x05,
   WPAD_EXT_MPLUS_NUNCHUK  = 0x06,
   WPAD_EXT_MPLUS_CLASSIC  = 0x07,
   WPAD_EXT_TRAIN          = 0x10,
   WPAD_EXT_GUITAR         = 0x11,
   WPAD_EXT_DRUM           = 0x12,
   WPAD_EXT_TAIKO          = 0x13,
   WPAD_EXT_PRO_CONTROLLER = 0x1f,
   WPAD_EXT_DEV_NOT_FOUND  = 0xfd,
   WPAD_EXT_UNKNOWN        = 0xff,
} 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_BUTTON_ZR               = 0x00000004,
   WPAD_PRO_TRIGGER_ZR              = WPAD_PRO_BUTTON_ZR,
   WPAD_PRO_BUTTON_X                = 0x00000008,
   WPAD_PRO_BUTTON_A                = 0x00000010,
   WPAD_PRO_BUTTON_Y                = 0x00000020,
   WPAD_PRO_BUTTON_B                = 0x00000040,
   WPAD_PRO_BUTTON_ZL               = 0x00000080,
   WPAD_PRO_TRIGGER_ZL              = WPAD_PRO_BUTTON_ZL,
   WPAD_PRO_RESERVED                = 0x00000100,
   WPAD_PRO_BUTTON_R                = 0x00000200,
   WPAD_PRO_TRIGGER_R               = WPAD_PRO_BUTTON_R,
   WPAD_PRO_BUTTON_PLUS             = 0x00000400,
   WPAD_PRO_BUTTON_HOME             = 0x00000800,
   WPAD_PRO_BUTTON_MINUS            = 0x00001000,
   WPAD_PRO_BUTTON_L                = 0x00002000,
   WPAD_PRO_TRIGGER_L               = WPAD_PRO_BUTTON_L,
   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 WPADMplsStatus
{
   WPAD_MPLS_STATUS_ATTACHED   = 0x01,
   WPAD_MPLS_STATUS_ROLL_CONV  = 0x02,
   WPAD_MPLS_STATUS_PITCH_CONV = 0x04,
   WPAD_MPLS_STATUS_YAW_CONV   = 0x08,
   WPAD_MPLS_STATUS_EXT_VALID  = 0x40,
   WPAD_MPLS_STATUS_VALID      = 0x80,
} WPADMplsStatus;
 
typedef enum WPADPeripheralSpace
{
   WPAD_PERIPHERAL_SPACE_SPEAKER    = 0xA2,
   WPAD_PERIPHERAL_SPACE_EXTENSION  = 0xA4,
   WPAD_PERIPHERAL_SPACE_MOTIONPLUS = 0xA6,
   WPAD_PERIPHERAL_SPACE_DPD        = 0xB0,
} WPADPeripheralSpace;
 
typedef enum WPADBalanceBoardCmd
{
   WPAD_BALANCE_BOARD_CMD_UPDATE_TEMP = 0x00,
   WPAD_BALANCE_BOARD_CMD_OFF         = 0x55,
   WPAD_BALANCE_BOARD_CMD_ON          = 0xAA,
} WPADBalanceBoardCmd;
 
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 WPADVec3D
{
   int16_t x;
   int16_t y;
   int16_t z;
};
WUT_CHECK_OFFSET(WPADVec3D, 0x00, x);
WUT_CHECK_OFFSET(WPADVec3D, 0x02, y);
WUT_CHECK_OFFSET(WPADVec3D, 0x04, z);
WUT_CHECK_SIZE(WPADVec3D, 0x06);
 
struct WPADIRDot
{
   WPADVec2D pos;
   uint16_t  pixels;
   uint8_t   id;
   WUT_PADDING_BYTES(1);
};
WUT_CHECK_OFFSET(WPADIRDot, 0x0, pos);
WUT_CHECK_OFFSET(WPADIRDot, 0x4, pixels);
WUT_CHECK_OFFSET(WPADIRDot, 0x6, id);
WUT_CHECK_SIZE(WPADIRDot, 0x8);
 
struct WPADIRDotEx
{
   WPADVec2D topRight;
   WPADVec2D bottomLeft;
   uint16_t pixels;
   uint8_t size;
   WUT_PADDING_BYTES(1);
};
WUT_CHECK_OFFSET(WPADIRDotEx, 0x00, topRight);
WUT_CHECK_OFFSET(WPADIRDotEx, 0x04, bottomLeft);
WUT_CHECK_OFFSET(WPADIRDotEx, 0x08, pixels);
WUT_CHECK_OFFSET(WPADIRDotEx, 0x0A, size);
WUT_CHECK_SIZE(WPADIRDotEx, 0x0C);
 
struct WPADStatus
{
   uint16_t  buttons;
   WPADVec3D acc;
   WPADIRDot ir[WPAD_MAX_IR_DOTS];
   uint8_t   extensionType;
   int8_t    error;
};
WUT_CHECK_OFFSET(WPADStatus, 0x00, buttons);
WUT_CHECK_OFFSET(WPADStatus, 0x02, acc);
WUT_CHECK_OFFSET(WPADStatus, 0x08, ir);
WUT_CHECK_OFFSET(WPADStatus, 0x28, extensionType);
WUT_CHECK_OFFSET(WPADStatus, 0x29, error);
WUT_CHECK_SIZE(WPADStatus, 0x2a);
 
struct WPADStatusEx
{
   WPADStatus core;
   WPADIRDotEx irEx[WPAD_MAX_IR_DOTS];
};
WUT_CHECK_OFFSET(WPADStatusEx, 0x00, core);
WUT_CHECK_OFFSET(WPADStatusEx, 0x2A, irEx);
WUT_CHECK_SIZE(WPADStatusEx, 0x5a);
 
struct WPADStatusNunchuk
{
   WPADStatus core;
   WPADVec3D  acc;
   struct
   {
      int8_t x;
      int8_t y;
   } stick;
};
WUT_CHECK_OFFSET(WPADStatusNunchuk, 0x00, core);
WUT_CHECK_OFFSET(WPADStatusNunchuk, 0x2a, acc);
WUT_CHECK_OFFSET(WPADStatusNunchuk, 0x30, stick.x);
WUT_CHECK_OFFSET(WPADStatusNunchuk, 0x31, stick.y);
WUT_CHECK_SIZE(WPADStatusNunchuk, 0x32);
 
struct WPADStatusClassic
{
   WPADStatus core;
   uint16_t   buttons;
   WPADVec2D  leftStick;
   WPADVec2D  rightStick;
   uint8_t    leftTrigger;
   uint8_t    rightTrigger;
};
WUT_CHECK_OFFSET(WPADStatusClassic, 0x00, core);
WUT_CHECK_OFFSET(WPADStatusClassic, 0x2a, buttons);
WUT_CHECK_OFFSET(WPADStatusClassic, 0x2c, leftStick);
WUT_CHECK_OFFSET(WPADStatusClassic, 0x30, rightStick);
WUT_CHECK_OFFSET(WPADStatusClassic, 0x34, leftTrigger);
WUT_CHECK_OFFSET(WPADStatusClassic, 0x35, rightTrigger);
WUT_CHECK_SIZE(WPADStatusClassic, 0x36);
 
struct WPADStatusProController
{
   WPADStatus core;
   WUT_PADDING_BYTES(2);
   uint32_t   buttons;
   WPADVec2D  leftStick;
   WPADVec2D  rightStick;
   BOOL       charging;
   BOOL       wired;
};
WUT_CHECK_OFFSET(WPADStatusProController, 0x00, core);
WUT_CHECK_OFFSET(WPADStatusProController, 0x2C, buttons);
WUT_CHECK_OFFSET(WPADStatusProController, 0x30, leftStick);
WUT_CHECK_OFFSET(WPADStatusProController, 0x34, rightStick);
WUT_CHECK_OFFSET(WPADStatusProController, 0x38, charging);
WUT_CHECK_OFFSET(WPADStatusProController, 0x3c, wired);
WUT_CHECK_SIZE(WPADStatusProController, 0x40);
 
struct WPADStatusMotionPlus
{
   WPADStatus core;
   union
   {
      struct
      {
         WPADVec3D acc;
         struct
         {
            int8_t x;
            int8_t y;
         } stick;
      } nunchuk;
      struct
      {
         uint16_t  buttons;
         WPADVec2D leftStick;
         WPADVec2D rightStick;
         uint8_t   leftTrigger;
         uint8_t   rightTrigger;
      } classic;
   };
   uint8_t   status;
   WUT_PADDING_BYTES(1);
   WPADVec3D angle;
};
WUT_CHECK_OFFSET(WPADStatusMotionPlus, 0x00, core);
WUT_CHECK_OFFSET(WPADStatusMotionPlus, 0x2a, nunchuk.acc);
WUT_CHECK_OFFSET(WPADStatusMotionPlus, 0x30, nunchuk.stick);
WUT_CHECK_OFFSET(WPADStatusMotionPlus, 0x2a, classic.buttons);
WUT_CHECK_OFFSET(WPADStatusMotionPlus, 0x2c, classic.leftStick);
WUT_CHECK_OFFSET(WPADStatusMotionPlus, 0x30, classic.rightStick);
WUT_CHECK_OFFSET(WPADStatusMotionPlus, 0x34, classic.leftTrigger);
WUT_CHECK_OFFSET(WPADStatusMotionPlus, 0x35, classic.rightTrigger);
WUT_CHECK_OFFSET(WPADStatusMotionPlus, 0x36, status);
WUT_CHECK_OFFSET(WPADStatusMotionPlus, 0x38, angle);
WUT_CHECK_SIZE(WPADStatusMotionPlus, 0x3e);
 
struct WPADStatusBalanceBoard
{
   WPADStatus core;
   uint16_t   pressure[WPAD_MAX_PRESSURE_SENSORS];
   int8_t     temperature;
   uint8_t    battery;
};
WUT_CHECK_OFFSET(WPADStatusBalanceBoard, 0x00, core);
WUT_CHECK_OFFSET(WPADStatusBalanceBoard, 0x2a, pressure);
WUT_CHECK_OFFSET(WPADStatusBalanceBoard, 0x32, temperature);
WUT_CHECK_OFFSET(WPADStatusBalanceBoard, 0x33, battery);
WUT_CHECK_SIZE(WPADStatusBalanceBoard, 0x34);
 
struct WPADStatusTrain
{
   WPADStatus core;
   uint16_t   buttons;
   uint8_t    brake;
   uint8_t    throttle;
};
WUT_CHECK_OFFSET(WPADStatusTrain, 0x00, core);
WUT_CHECK_OFFSET(WPADStatusTrain, 0x2a, buttons);
WUT_CHECK_OFFSET(WPADStatusTrain, 0x2c, brake);
WUT_CHECK_OFFSET(WPADStatusTrain, 0x2d, throttle);
WUT_CHECK_SIZE(WPADStatusTrain, 0x2e);
 
struct WPADInfo
{
   BOOL irEnabled;
   BOOL speakerEnabled;
   BOOL extensionAttached;
   BOOL batteryLow;
   BOOL speakerBufNearEmpty;
   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, speakerBufNearEmpty);
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);
 
struct WENCParams
{
   WUT_UNKNOWN_BYTES(32);
};
WUT_CHECK_SIZE(WENCParams, 32);
 
typedef void (*WPADCallback)(WPADChan channel, WPADError status);
typedef WPADCallback WPADControlLedCallback;
typedef WPADCallback WPADControlDpdCallback;
typedef WPADCallback WPADControlSpeakerCallback;
typedef WPADCallback WPADIsMplsAttachedCallback;
typedef WPADCallback WPADGetInfoCallback;
typedef WPADCallback WPADReadMemoryCallback;
typedef WPADCallback WPADWriteMemoryCallback;
typedef WPADCallback WPADConnectCallback;
typedef WPADCallback WPADiSendCallback;
typedef WPADCallback WPADiWriteGameDataCallback;
 
typedef void (*WPADSamplingCallback)(WPADChan channel);
 
typedef void (*WPADExtensionCallback)(WPADChan channel, WPADExtensionType ext);
 
 
void
WPADInit(void);
 
void
WPADShutdown(void);
 
BOOL
WPADGetStatus(void);
 
void
WPADDisconnect(WPADChan channel);
 
WPADError
WPADProbe(WPADChan channel,
          WPADExtensionType *outExtensionType);
 
WPADError
WPADSetDataFormat(WPADChan channel,
                  WPADDataFormat format);
 
WPADDataFormat
WPADGetDataFormat(WPADChan channel);
 
void
WPADRead(WPADChan channel,
         WPADStatus *status);
 
WPADError
WPADControlLed(WPADChan channel,
               WPADLed led,
               WPADCallback callback);
 
WPADError
WPADControlDpd(WPADChan channel,
               WPADDpdFormat mode,
               WPADCallback callback);
 
WPADDpdFormat
WPADGetDpdFormat(WPADChan channel);
 
void
WPADControlMotor(WPADChan channel,
                 BOOL motorEnabled);
 
int32_t
WPADControlSpeaker(WPADChan channel,
                   WPADSpeakerCmd mode,
                   WPADCallback callback);
 
BOOL
WPADIsSpeakerEnabled(WPADChan channel);
 
BOOL
WPADCanSendStreamData(WPADChan channel);
 
WPADError
WPADSendStreamData(WPADChan channel,
                   const void *data,
                   uint32_t size);
 
uint32_t
WENCGetEncodeData(WENCParams *params,
                  BOOL continuing,
                  const int16_t *samples,
                  uint32_t sampleCount,
                  uint8_t *outEncodedData);
 
uint8_t
WPADGetSpeakerVolume(void);
 
void
WPADSetSpeakerVolume(uint8_t volume);
 
int32_t
WPADIsMplsAttached(WPADChan channel,
                   BOOL *outEnabled,
                   WPADCallback callback);
 
int32_t
WPADIsMplsIntegrated(WPADChan channel);
 
WPADError
WPADGetInfo(WPADChan channel,
            WPADInfo *outInfo);
 
WPADError
WPADGetInfoAsync(WPADChan channel,
                 WPADInfo *outInfo,
                 WPADCallback callback);
 
WPADError
WPADReadMemoryAsync(WPADChan channel,
                    void *destination,
                    uint16_t size,
                    uint32_t address,
                    WPADCallback callback);
 
WPADError
WPADWriteMemoryAsync(WPADChan channel,
                     void *source,
                     uint32_t size,
                     uint32_t address,
                     WPADCallback callback);
 
WPADError
WPADReadExtReg(WPADChan channel,
               void *destination,
               uint16_t size,
               WPADPeripheralSpace peripheral,
               uint32_t address,
               WPADCallback callback);
 
WPADError
WPADWriteExtReg(WPADChan channel,
                const void *source,
                uint32_t size,
                WPADPeripheralSpace peripheral,
                uint32_t address,
                WPADCallback callback);
 
WPADError
WPADGetBLCalibration(WPADChan channel,
                     void *destination,
                     uint32_t address,
                     uint32_t size,
                     WPADCallback callback);
 
void
WPADSetPowerSaveMode(WPADChan channel,
                     BOOL powerSave);
 
BOOL
WPADGetPowerSaveMode(WPADChan channel);
 
void
WPADGetAddress(WPADChan channel,
               WPADAddress* outAddress);
 
void
WPADEnableMotor(BOOL enable);
 
BOOL
WPADIsMotorEnabled(void);
 
void
WPADEnableURCC(BOOL enable);
 
BOOL
WPADIsEnabledURC(void);
 
void
WPADEnableWBC(void);
 
BOOL
WPADIsEnableWBC(void);
 
void
WPADEnableWiiRemote(BOOL enable);
 
void
WPADSetAutoSleepTime(uint8_t time);
 
BOOL
WPADStartSyncDevice(void);
 
BOOL
WPADStartSyncDeviceEx(WPADAddress* deviceAddress,
                      const char* deviceName);
 
WPADConnectCallback
WPADSetConnectCallback(WPADChan channel,
                       WPADCallback callback);
WPADExtensionCallback
WPADSetExtensionCallback(WPADChan channel,
                         WPADExtensionCallback callback);
 
void
WPADSetAutoSamplingBuf(WPADChan channel,
                       void *buf,
                       uint32_t count);
 
uint32_t
WPADGetLatestIndexInBuf(WPADChan channel);
 
WPADSamplingCallback
WPADSetSamplingCallback(WPADChan channel,
                        WPADSamplingCallback callback);
 
void
WPADiShutdown(void);
 
void
WPADiClearQueue(WPADiQueue *queue);
 
bool
WPADiIsAvailableCmdQueue(WPADiQueue *queue,
                         uint32_t count);
 
int32_t
WPADiHIDParser(WPADChan channel,
               const uint8_t *hidData);
 
 
BOOL
WPADiSendSetVibrator(WPADiQueue *cmdQueue);
 
BOOL
WPADiSendSetPort(WPADiQueue *cmdQueue,
                 WPADLed led,
                 WPADCallback callback);
 
BOOL
WPADiSendSetReportType(WPADiQueue *cmdQueue,
                       WPADDataFormat dataFormat,
                       BOOL powerSave,
                       WPADCallback callback);
 
BOOL
WPADiSendGetContStat(WPADiQueue *cmdQueue,
                     WPADInfo *outInfo,
                     WPADCallback callback);
 
BOOL
WPADiSendEnableDPD(WPADiQueue *cmdQueue,
                   BOOL enable,
                   WPADCallback callback);
 
BOOL
WPADiSendEnableDPDCSB(WPADiQueue *cmdQueue,
                      BOOL enable,
                      WPADCallback callback);
 
BOOL
WPADiSendEnableSpeaker(WPADiQueue *cmdQueue,
                       BOOL enable,
                       WPADCallback callback);
 
BOOL
WPADiSendMuteSpeaker(WPADiQueue *cmdQueue,
                     BOOL mute,
                     WPADCallback callback);
 
BOOL
WPADiSendStreamData(WPADiQueue *cmdQueue,
                    void *source,
                    uint32_t size);
 
BOOL
WPADiSendWriteDataCmd(WPADiQueue *cmdQueue,
                      uint8_t byte,
                      uint32_t address,
                      WPADCallback callback);
 
BOOL
WPADiSendWriteData(WPADiQueue *cmdQueue,
                   void *source,
                   uint32_t size,
                   uint32_t address,
                   WPADCallback callback);
 
BOOL
WPADiSendReadData(WPADiQueue *cmdQueue,
                  void *destination,
                  uint16_t size,
                  uint32_t address,
                  WPADCallback callback);
 
uint32_t*
WPADiGetGameCode(void);
 
uint8_t
WPADiGetGameType(void);
 
void
WPADSetGameTitleUtf16(const uint16_t *title);
 
WPADError
WPADGetGameTitleUtf16(WPADChan channel,
                      uint16_t **outTitle);
 
WPADError
WPADGetGameDataTimestamp(WPADChan channel,
                         OSTime *outTimestamp);
 
WPADError
WPADiWriteGameData(WPADChan channel,
                   const void *source,
                   uint16_t size,
                   uint32_t offset,
                   WPADCallback callback);
 
WPADError
WPADiReadGameData(WPADChan channel,
                  void *destination,
                  uint16_t size,
                  uint32_t offset,
                  WPADCallback callback);
 
WPADMplsMode
WPADiGetMplsStatus(void);
 
uint8_t
WPADGetBatteryLevel(WPADChan channel);
 
WPADError
WPADControlBLC(WPADChan channel,
               WPADBalanceBoardCmd command,
               WPADCallback callback);
 
#ifdef __cplusplus
}
#endif