cdc.h

Go to the documentation of this file.

#pragma once
#include <wut.h>
#include <coreinit/ios.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct CCRCDCMacAddress CCRCDCMacAddress;
typedef struct CCRCDCWpsArgs CCRCDCWpsArgs;
typedef struct CCRCDCSysMessage CCRCDCSysMessage;
typedef struct CCRCDCSysInfo CCRCDCSysInfo;
typedef struct CCRCDCEepromData CCRCDCEepromData;
typedef struct CCRCDCWowlWakeDrcArg CCRCDCWowlWakeDrcArg;
typedef struct CCRCDCUicConfig CCRCDCUicConfig;
typedef struct CCRCDCFWInfo CCRCDCFWInfo;
typedef struct CCRCDCSoftwareVersion CCRCDCSoftwareVersion;
typedef struct CCRCDCDrhState CCRCDCDrhState;
typedef struct CCRCDCDrcState CCRCDCDrcState;
typedef struct CCRCDCRegisterCallbackData CCRCDCRegisterCallbackData;
typedef uint8_t CCRCDCDestination;
typedef uint32_t CCRCDCWpsStatusType;
typedef uint8_t CCRCDCWakeState;
typedef uint8_t CCRCDCUicConfigId;
 
struct WUT_PACKED CCRCDCRegisterCallbackData
{
   int32_t attached;
   uint32_t chan;
   WUT_UNKNOWN_BYTES(6);
};
WUT_CHECK_OFFSET(CCRCDCRegisterCallbackData, 0x00, attached);
WUT_CHECK_OFFSET(CCRCDCRegisterCallbackData, 0x04, chan);
WUT_CHECK_SIZE(CCRCDCRegisterCallbackData, 0x0E);
 
typedef void (*CCRCDCRegisterCallbackFn)(CCRCDCRegisterCallbackData *, void *);
 
typedef enum CCRCDCDestinationEnum
{
   CCR_CDC_DESTINATION_DRH  = 1,
   CCR_CDC_DESTINATION_DRC0 = 2,
   CCR_CDC_DESTINATION_DRC1 = 3,
} CCRCDCDestinationEnum;
 
typedef enum CCRCDCWpsStatusEnum
{
   CCR_CDC_WPS_STATUS_PAIRED     = 0,
   CCR_CDC_WPS_STATUS_SEARCHING  = 1,
   CCR_CDC_WPS_STATUS_PAIRING    = 2,
} CCRCDCWpsStatusEnum;
 
typedef enum CCRCDCDrcStateEnum
{
   CCR_CDC_DRC_STATE_ACTIVE              = 0,
   CCR_CDC_DRC_STATE_PAIRING             = 1,
   CCR_CDC_DRC_STATE_FWUPDATE            = 2,
   CCR_CDC_DRC_STATE_STANDALONE          = 3,
   CCR_CDC_DRC_STATE_BACKGROUND          = 4,
   CCR_CDC_DRC_STATE_SLEEP               = 5,
   CCR_CDC_DRC_STATE_STANDBY             = 6,
   CCR_CDC_DRC_STATE_WOWLSETTING         = 7,
   CCR_CDC_DRC_STATE_DKSETTING           = 8,
   CCR_CDC_DRC_STATE_UNKNOWN9            = 9,
   CCR_CDC_DRC_STATE_WIIACTIVE           = 10,
   CCR_CDC_DRC_STATE_LOW_BATTERY         = 11,
   CCR_CDC_DRC_STATE_SUBACTIVE           = 12,
} CCRCDCDrcStateEnum;
 
typedef enum CCRCDCWakeStateEnum
{
   CCR_CDC_WAKE_STATE_ACTIVE     = 1,
   CCR_CDC_WAKE_STATE_BACKGROUND = 2,
} CCRCDCWakeStateEnum;
 
typedef enum CCRCDCBoardVersion
{
   CCR_CDC_BOARD_VERSION_DK1          = 0,
   CCR_CDC_BOARD_VERSION_DK1_EP_DK2   = 1,
   CCR_CDC_BOARD_VERSION_DP1          = 2,
   CCR_CDC_BOARD_VERSION_DP2          = 3,
   CCR_CDC_BOARD_VERSION_DK3          = 4,
   CCR_CDC_BOARD_VERSION_DK4          = 5,
   CCR_CDC_BOARD_VERSION_PREDP3_DP3   = 6,
   CCR_CDC_BOARD_VERSION_DK5          = 7,
   CCR_CDC_BOARD_VERSION_DP4          = 8,
   CCR_CDC_BOARD_VERSION_DKMP         = 9,
   CCR_CDC_BOARD_VERSION_DP5          = 10,
   CCR_CDC_BOARD_VERSION_MASS         = 11,
   CCR_CDC_BOARD_VERSION_DKMP2        = 12,
   CCR_CDC_BOARD_VERSION_DRC_I        = 13,
   CCR_CDC_BOARD_VERSION_DKTVMP       = 14,
} CCRCDCBoardVersion;
 
typedef enum CCRCDCChipVersion
{
   CCR_CDC_CHIP_VERSION_TS   = 0x10,
   CCR_CDC_CHIP_VERSION_ES1  = 0x20,
   CCR_CDC_CHIP_VERSION_ES2  = 0x30,
   CCR_CDC_CHIP_VERSION_ES3  = 0x40,
   CCR_CDC_CHIP_VERSION_MS01 = 0x41,
} CCRCDCChipVersion;
 
typedef enum CCRCDCUicConfigIdEnum
{
   CCR_CDC_UIC_CONFIG_ID_LANGUAGE_BANK                    = 0,
   CCR_CDC_UIC_CONFIG_ID_MIC_CONFIG                       = 2,
   CCR_CDC_UIC_CONFIG_ID_ACC_CALIBRATION_VALUE            = 3,
   CCR_CDC_UIC_CONFIG_ID_TP_CALIBRATION_VALUE             = 5,
   CCR_CDC_UIC_CONFIG_ID_UNK7                             = 7,
   CCR_CDC_UIC_CONFIG_ID_UNK8                             = 8,
   CCR_CDC_UIC_CONFIG_ID_LANGUAGE_EXT_ID                  = 9,
   CCR_CDC_UIC_CONFIG_ID_TV_CONTROL_ID                    = 10,
   CCR_CDC_UIC_CONFIG_ID_EXT_ID_2                         = 11,
   CCR_CDC_UIC_CONFIG_ID_EXT_ID_3                         = 12,
   CCR_CDC_UIC_CONFIG_ID_EXT_ID_4                         = 13,
   CCR_CDC_UIC_CONFIG_ID_INIT_BOOT_FLAG                   = 14,
   CCR_CDC_UIC_CONFIG_ID_UNK15                            = 15,
   CCR_CDC_UIC_CONFIG_ID_LCD_MODE                         = 16,
   CCR_CDC_UIC_CONFIG_ID_RC_DATABASE_EXT_ID               = 17,
   CCR_CDC_UIC_CONFIG_ID_UNK18                            = 18,
   CCR_CDC_UIC_CONFIG_ID_CAFFEINE_ENABLE_FLAG             = 19,
   CCR_CDC_UIC_CONFIG_ID_CAFFEINE_INITIAL_BOOT_FLAG       = 20,
   CCR_CDC_UIC_CONFIG_ID_CAFFEINE_CAFFEINE_SLOT           = 21,
   CCR_CDC_UIC_CONFIG_ID_CAFFEINE_NOTIFICATION_SOUND_MODE = 22,
   CCR_CDC_UIC_CONFIG_ID_CAFFEINE_NOTIFICATION_INFO       = 23,
   CCR_CDC_UIC_CONFIG_ID_CAFFEINE_NOTIFICATION_READ_COUNT = 24,
} CCRCDCUicConfigIdEnum;
 
typedef enum CCRCDCExt
{
   CCR_CDC_EXT_LANGUAGE    = 0,
   CCR_CDC_EXT_RC_DATABASE = 1,
   CCR_CDC_EXT_UNK2        = 2,
   CCR_CDC_EXT_UNK3        = 3,
   CCR_CDC_EXT_UNK4        = 4,
} CCRCDCExt;
 
typedef enum CCRCDCDrhStateEnum
{
   CCR_CDC_SYS_DRH_STATE_NORADIO = 0x00,
   CCR_CDC_SYS_DRH_STATE_WII     = 0x01,
   CCR_CDC_SYS_DRH_STATE_UNK2    = 0x02,
   CCR_CDC_SYS_DRH_STATE_NODRC   = 0x03,
   CCR_CDC_SYS_DRH_STATE_ECO     = 0x04,
   CCR_CDC_SYS_DRH_STATE_UNK7F   = 0x7F,
   CCR_CDC_SYS_DRH_STATE_CAFE    = 0xFF,
} CCRCDCDrhStateEnum;
 
struct WUT_PACKED CCRCDCMacAddress
{
   CCRCDCDestination device;
   uint8_t address[6];
};
WUT_CHECK_OFFSET(CCRCDCMacAddress, 0x0, device);
WUT_CHECK_OFFSET(CCRCDCMacAddress, 0x1, address);
WUT_CHECK_SIZE(CCRCDCMacAddress, 0x7);
 
struct WUT_PACKED CCRCDCWpsArgs
{
   uint8_t hasArgs;
   char pin[8];
   uint16_t timeout;
   // \c CCR_CDC_DESTINATION_DRC0 or \c CCR_CDC_DESTINATION_DRC1 depending on where the device should be paired to
   CCRCDCDestination pairDestination;
};
WUT_CHECK_OFFSET(CCRCDCWpsArgs, 0x0, hasArgs);
WUT_CHECK_OFFSET(CCRCDCWpsArgs, 0x1, pin);
WUT_CHECK_OFFSET(CCRCDCWpsArgs, 0x9, timeout);
WUT_CHECK_OFFSET(CCRCDCWpsArgs, 0xb, pairDestination);
WUT_CHECK_SIZE(CCRCDCWpsArgs, 0xc);
 
struct WUT_PACKED CCRCDCSysMessage
{
   uint16_t message;
   uint16_t timeout;
};
WUT_CHECK_OFFSET(CCRCDCSysMessage, 0x0, message);
WUT_CHECK_OFFSET(CCRCDCSysMessage, 0x2, timeout);
WUT_CHECK_SIZE(CCRCDCSysMessage, 0x4);
 
struct WUT_PACKED CCRCDCSysInfo
{
   CCRCDCBoardVersion boardVersion;
   CCRCDCChipVersion chipVersion;
   uint32_t lvcVersion;
   uint32_t umiVersion;
   uint32_t unknown;
   uint32_t sdCis;
   uint32_t splId;
};
WUT_CHECK_OFFSET(CCRCDCSysInfo, 0x00, boardVersion);
WUT_CHECK_OFFSET(CCRCDCSysInfo, 0x04, chipVersion);
WUT_CHECK_OFFSET(CCRCDCSysInfo, 0x08, lvcVersion);
WUT_CHECK_OFFSET(CCRCDCSysInfo, 0x0C, umiVersion);
WUT_CHECK_OFFSET(CCRCDCSysInfo, 0x10, unknown);
WUT_CHECK_OFFSET(CCRCDCSysInfo, 0x14, sdCis);
WUT_CHECK_OFFSET(CCRCDCSysInfo, 0x18, splId);
WUT_CHECK_SIZE(CCRCDCSysInfo, 0x1C);
 
struct WUT_PACKED CCRCDCEepromData
{
   uint32_t version;
   uint8_t data[0x300];
};
WUT_CHECK_OFFSET(CCRCDCEepromData, 0x0, version);
WUT_CHECK_OFFSET(CCRCDCEepromData, 0x4, data);
WUT_CHECK_SIZE(CCRCDCEepromData, 0x304);
 
struct WUT_PACKED CCRCDCWowlWakeDrcArg
{
   WUT_PADDING_BYTES(0x6);
   CCRCDCWakeState state;
};
WUT_CHECK_OFFSET(CCRCDCWowlWakeDrcArg, 0x6, state);
WUT_CHECK_SIZE(CCRCDCWowlWakeDrcArg, 0x7);
 
struct CCRCDCUicConfig
{
   CCRCDCUicConfigId configId;
   uint8_t size;
   uint8_t data[0x100];
};
WUT_CHECK_SIZE(CCRCDCUicConfig, 0x102);
WUT_CHECK_OFFSET(CCRCDCUicConfig, 0x00, configId);
WUT_CHECK_OFFSET(CCRCDCUicConfig, 0x01, size);
WUT_CHECK_OFFSET(CCRCDCUicConfig, 0x02, data);
 
struct CCRCDCFWInfo
{
   uint32_t imageSize;
   uint32_t blockSize;
   uint32_t imageVersion;
   uint32_t sequencePerSession;
   uint32_t updateProgress;
};
WUT_CHECK_OFFSET(CCRCDCFWInfo, 0x00, imageSize);
WUT_CHECK_OFFSET(CCRCDCFWInfo, 0x04, blockSize);
WUT_CHECK_OFFSET(CCRCDCFWInfo, 0x08, imageVersion);
WUT_CHECK_OFFSET(CCRCDCFWInfo, 0x0C, sequencePerSession);
WUT_CHECK_OFFSET(CCRCDCFWInfo, 0x10, updateProgress);
WUT_CHECK_SIZE(CCRCDCFWInfo, 0x14);
 
struct CCRCDCSoftwareVersion
{
   uint32_t runningVersion;
   uint32_t activeVersion;
};
WUT_CHECK_OFFSET(CCRCDCSoftwareVersion, 0x0, runningVersion);
WUT_CHECK_OFFSET(CCRCDCSoftwareVersion, 0x4, activeVersion);
WUT_CHECK_SIZE(CCRCDCSoftwareVersion, 0x8);
 
struct CCRCDCDrcState {
   uint8_t state;
};
WUT_CHECK_OFFSET(CCRCDCDrcState, 0x0, state);
WUT_CHECK_SIZE(CCRCDCDrcState, 0x1);
 
struct CCRCDCDrhState {
   uint8_t state;
};
WUT_CHECK_OFFSET(CCRCDCDrhState, 0x0, state);
WUT_CHECK_SIZE(CCRCDCDrhState, 0x1);
 
int32_t
CCRCDCCommand(uint8_t unk,
              uint8_t fragment,
              CCRCDCDestination dest,
              uint8_t flags0,
              uint8_t flags1,
              uint8_t service,
              uint8_t method,
              void *payload,
              uint32_t payloadSize,
              void *reply,
              uint32_t replySize);
 
int32_t
CCRCDCDevicePing(CCRCDCDestination dest);
 
int32_t
CCRCDCSetStationId(CCRCDCMacAddress *id);
 
int32_t
CCRCDCGetMacAddress(CCRCDCDestination dest,
                    CCRCDCMacAddress *mac);
 
int32_t
CCRCDCGetMultiDrc(uint8_t *numDrcs);
 
int32_t
CCRCDCSetMultiDrc(uint8_t numDrcs);
 
int32_t
CCRCDCSysGetDrcState(CCRCDCDestination dest,
                     CCRCDCDrcState *state);
 
int32_t
CCRCDCSysSetDrcState(CCRCDCDestination dest,
                     CCRCDCDrcState *state);
 
int32_t
CCRCDCSysGetDrhState(CCRCDCDrhState *state);
int32_t
CCRCDCSysSetDrhState(CCRCDCDrhState *state);
 
int32_t
CCRCDCWpsStart(void);
 
int32_t
CCRCDCWpsStartEx(CCRCDCWpsArgs *args);
 
int32_t
CCRCDCWpsStatus(CCRCDCWpsStatusType *status);
 
int32_t
CCRCDCWpsStop(void);
 
int32_t
CCRCDCSysGetInfo(CCRCDCDestination dest,
                 CCRCDCSysInfo *info);
 
int32_t
CCRCDCSysDrcDisplayMessage(CCRCDCDestination dest,
                           CCRCDCSysMessage *message);
 
int32_t
CCRCDCPerGetUicEeprom(CCRCDCDestination dest,
                      CCRCDCEepromData *eeprom);
 
int32_t
CCRCDCPerGetUicEepromEx(CCRCDCDestination dest,
                        CCRCDCEepromData *eeprom,
                        IOSAsyncCallbackFn callback,
                        void *arg);
 
int32_t
CCRCDCSysConsoleShutdownInd(CCRCDCDestination dest);
 
int32_t
CCRCDCWowlWakeDrc(CCRCDCWowlWakeDrcArg *arg);
 
int32_t
CCRCDCPerClearUicConfig(CCRCDCDestination dest);
 
int32_t
CCRCDCPerSetUicConfig(CCRCDCDestination dest,
                      CCRCDCUicConfig *config);
 
uint16_t
CCRCDCCalcCRC16(void *data,
                uint32_t dataSize);
 
int32_t
CCRCDCGetFWInfo(CCRCDCDestination dest,
                CCRCDCFWInfo *outInfo);
 
int32_t
CCRCDCSoftwareGetVersion(CCRCDCDestination dest,
                         CCRCDCSoftwareVersion *outVersion);
 
int32_t
CCRCDCSoftwareUpdate(CCRCDCDestination dest,
                     const char *path,
                     IOSAsyncCallbackFn callback,
                     void *userContext);
 
int32_t
CCRCDCSoftwareAbort(CCRCDCDestination dest);
 
int32_t
CCRCDCSoftwareActivate(CCRCDCDestination dest);
 
int32_t
CCRCDCSoftwareLangUpdate(CCRCDCDestination dest,
                         const char *path,
                         uint32_t *outVersion,
                         IOSAsyncCallbackFn callback,
                         void *userContext);
 
int32_t
CCRCDCSoftwareLangActivate(CCRCDCDestination dest,
                           uint32_t version,
                           uint32_t *outActivationResult);
 
int32_t
CCRCDCSoftwareGetExtId(CCRCDCDestination dest,
                       CCRCDCExt ext,
                       uint32_t *outId);
 
int32_t
CCRCDCSoftwareExtUpdate(CCRCDCDestination dest,
                        const char *path,
                        uint32_t imageSize,
                        uint32_t extId,
                        CCRCDCExt ext,
                        IOSAsyncCallbackFn callback,
                        void *userContext);
 
int32_t
CCRCDCRegisterAOAttachCallback(CCRCDCRegisterCallbackFn callback,
                                void *context);
 
int32_t
CCRCDCRegisterCFGAttachCallback(CCRCDCRegisterCallbackFn callback,
                                void *context);
 
int32_t
CCRCDCRegisterHIDAttachCallback(CCRCDCRegisterCallbackFn callback,
                                void *context);
 
int32_t
CCRCDCRegisterSYSAttachCallback(CCRCDCRegisterCallbackFn callback,
                                void *context);
 
int32_t
CCRCDCRegisterUACAttachCallback(CCRCDCRegisterCallbackFn callback,
                                void *context);
 
int32_t
CCRCDCRegisterUVCAttachCallback(CCRCDCRegisterCallbackFn callback,
                                void *context);
 
int32_t
CCRCDCRegisterVOAttachCallback(CCRCDCRegisterCallbackFn callback,
                                void *context);
 
#ifdef __cplusplus
}
#endif