{

    k_eWiiOutputReportIDs_Rumble = 0x10,

    k_eWiiOutputReportIDs_LEDs = 0x11,

    k_eWiiOutputReportIDs_DataReportingMode = 0x12,

    k_eWiiOutputReportIDs_IRCameraEnable = 0x13,

    k_eWiiOutputReportIDs_SpeakerEnable = 0x14,

    k_eWiiOutputReportIDs_StatusRequest = 0x15,

    k_eWiiOutputReportIDs_WriteMemory = 0x16,

    k_eWiiOutputReportIDs_ReadMemory = 0x17,

    k_eWiiOutputReportIDs_SpeakerData = 0x18,

    k_eWiiOutputReportIDs_SpeakerMute = 0x19,

    k_eWiiOutputReportIDs_IRCameraEnable2 = 0x1a,

} EWiiOutputReportIDs;

​

typedef enum

{

    k_eWiiPlayerLEDs_P1 = 0x10,

    k_eWiiPlayerLEDs_P2 = 0x20,

    k_eWiiPlayerLEDs_P3 = 0x40,

    k_eWiiPlayerLEDs_P4 = 0x80,

} EWiiPlayerLEDs;

​

typedef enum

{

    k_eWiiCommunicationState_None,                  /* No special communications happening */

    k_eWiiCommunicationState_CheckMotionPlusStage1, /* Sent standard extension identify request */

    k_eWiiCommunicationState_CheckMotionPlusStage2, /* Sent Motion Plus extension identify request */

} EWiiCommunicationState;

​

typedef enum

{

    k_eWiiButtons_A = SDL_GAMEPAD_BUTTON_MISC1,

    k_eWiiButtons_B,

    k_eWiiButtons_One,

    k_eWiiButtons_Two,

    k_eWiiButtons_Plus,

    k_eWiiButtons_Minus,

    k_eWiiButtons_Home,

    k_eWiiButtons_DPad_Up,

    k_eWiiButtons_DPad_Down,

    k_eWiiButtons_DPad_Left,

    k_eWiiButtons_DPad_Right,

    k_eWiiButtons_Max

} EWiiButtons;

​

#define k_unWiiPacketDataLength 22

​

typedef struct

{

    Uint8 rgucBaseButtons[2];

    Uint8 rgucAccelerometer[3];

    Uint8 rgucExtension[21];

    SDL_bool hasBaseButtons;

    SDL_bool hasAccelerometer;

    Uint8 ucNExtensionBytes;

} WiiButtonData;

​

typedef struct

{

    Uint16 min;

    Uint16 max;

    Uint16 center;

    Uint16 deadzone;

} StickCalibrationData;

​

typedef struct

{

    SDL_HIDAPI_Device *device;

    SDL_Joystick *joystick;

    Uint64 timestamp;

    EWiiCommunicationState m_eCommState;

    EWiiExtensionControllerType m_eExtensionControllerType;

    SDL_bool m_bPlayerLights;

    int m_nPlayerIndex;

    SDL_bool m_bRumbleActive;

    SDL_bool m_bMotionPlusPresent;

    Uint8 m_ucMotionPlusMode;

    SDL_bool m_bReportSensors;

    Uint8 m_rgucReadBuffer[k_unWiiPacketDataLength];

    Uint64 m_ulLastInput;

    Uint64 m_ulLastStatus;

    Uint64 m_ulNextMotionPlusCheck;

    SDL_bool m_bDisconnected;

​

    StickCalibrationData m_StickCalibrationData[6];

} SDL_DriverWii_Context;

​

static void HIDAPI_DriverWii_RegisterHints(SDL_HintCallback callback, void *userdata)

{

    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_WII, callback, userdata);

}

​

static void HIDAPI_DriverWii_UnregisterHints(SDL_HintCallback callback, void *userdata)

{

    SDL_DelHintCallback(SDL_HINT_JOYSTICK_HIDAPI_WII, callback, userdata);

}

​

static SDL_bool HIDAPI_DriverWii_IsEnabled(void)

{

#if 1 /* This doesn't work with the dolphinbar, so don't enable by default right now */

    return SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_WII, SDL_FALSE);

#else

    return SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_WII,

                              SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI,

                                                 SDL_HIDAPI_DEFAULT));

#endif

}

​

static SDL_bool HIDAPI_DriverWii_IsSupportedDevice(SDL_HIDAPI_Device *device, const char *name, SDL_GamepadType type, Uint16 vendor_id, Uint16 product_id, Uint16 version, int interface_number, int interface_class, int interface_subclass, int interface_protocol)

{

    if (vendor_id == USB_VENDOR_NINTENDO &&

        (product_id == USB_PRODUCT_NINTENDO_WII_REMOTE ||

         product_id == USB_PRODUCT_NINTENDO_WII_REMOTE2)) {

        return SDL_TRUE;

    }

    return SDL_FALSE;

}

​

static int ReadInput(SDL_DriverWii_Context *ctx)

{

    int size;

​

    /* Make sure we don't try to read at the same time a write is happening */

    if (SDL_AtomicGet(&ctx->device->rumble_pending) > 0) {

        return 0;

    }

​

    size = SDL_hid_read_timeout(ctx->device->dev, ctx->m_rgucReadBuffer, sizeof(ctx->m_rgucReadBuffer), 0);

#ifdef DEBUG_WII_PROTOCOL

    if (size > 0) {

        HIDAPI_DumpPacket("Wii packet: size = %d", ctx->m_rgucReadBuffer, size);

    }

#endif

    return size;

}

​

static SDL_bool WriteOutput(SDL_DriverWii_Context *ctx, const Uint8 *data, int size, SDL_bool sync)

{

#ifdef DEBUG_WII_PROTOCOL

    if (size > 0) {

        HIDAPI_DumpPacket("Wii write packet: size = %d", data, size);

    }

#endif

    if (sync) {

        return SDL_hid_write(ctx->device->dev, data, size) >= 0;

    } else {

        /* Use the rumble thread for general asynchronous writes */

        if (SDL_HIDAPI_LockRumble() != 0) {

            return SDL_FALSE;

        }

        return SDL_HIDAPI_SendRumbleAndUnlock(ctx->device, data, size) >= 0;

    }

}

​

static SDL_bool ReadInputSync(SDL_DriverWii_Context *ctx, EWiiInputReportIDs expectedID, SDL_bool (*isMine)(const Uint8 *))

{

    Uint64 endTicks = SDL_GetTicks() + 250; /* Seeing successful reads after about 200 ms */

​

    int nRead = 0;

    while ((nRead = ReadInput(ctx)) != -1) {

        if (nRead > 0) {

            if (ctx->m_rgucReadBuffer[0] == expectedID && (!isMine || isMine(ctx->m_rgucReadBuffer))) {

                return SDL_TRUE;

            }

        } else {

            if (SDL_GetTicks() >= endTicks) {

                break;

            }

            SDL_Delay(1);

        }

    }

    SDL_SetError("Read timed out");

    return SDL_FALSE;

}

​

static SDL_bool IsWriteMemoryResponse(const Uint8 *data)

{

    return data[3] == k_eWiiOutputReportIDs_WriteMemory;

}

​

static SDL_bool WriteRegister(SDL_DriverWii_Context *ctx, Uint32 address, const Uint8 *data, int size, SDL_bool sync)

{

    Uint8 writeRequest[k_unWiiPacketDataLength];

​

    SDL_zeroa(writeRequest);

    writeRequest[0] = k_eWiiOutputReportIDs_WriteMemory;

    writeRequest[1] = (Uint8)(0x04 | ctx->m_bRumbleActive);

    writeRequest[2] = (address >> 16) & 0xff;

    writeRequest[3] = (address >> 8) & 0xff;

    writeRequest[4] = address & 0xff;

    writeRequest[5] = (Uint8)size;

    SDL_assert(size > 0 && size <= 16);

    SDL_memcpy(writeRequest + 6, data, size);

​

    if (!WriteOutput(ctx, writeRequest, sizeof(writeRequest), sync)) {

        return SDL_FALSE;

    }

    if (sync) {

        /* Wait for response */

        if (!ReadInputSync(ctx, k_eWiiInputReportIDs_Acknowledge, IsWriteMemoryResponse)) {

            return SDL_FALSE;

        }

        if (ctx->m_rgucReadBuffer[4]) {

            SDL_SetError("Write memory failed: %u", ctx->m_rgucReadBuffer[4]);

            return SDL_FALSE;

        }

    }

    return SDL_TRUE;

}

​

static SDL_bool ReadRegister(SDL_DriverWii_Context *ctx, Uint32 address, int size, SDL_bool sync)

{

    Uint8 readRequest[7];

​

    readRequest[0] = k_eWiiOutputReportIDs_ReadMemory;

    readRequest[1] = (Uint8)(0x04 | ctx->m_bRumbleActive);

    readRequest[2] = (address >> 16) & 0xff;

    readRequest[3] = (address >> 8) & 0xff;

    readRequest[4] = address & 0xff;