23 files changed, 19217 insertions, 0 deletions

diff --git a/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_combined.c b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_combined.c
new file mode 100644
index 0000000..5426edb
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_combined.c
@@ -0,0 +1,236 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+// This driver supports the Nintendo Switch Joy-Cons pair controllers
+#include "SDL_internal.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI
+
+#include "SDL_hidapijoystick_c.h"
+#include "../SDL_sysjoystick.h"
+
+static void HIDAPI_DriverCombined_RegisterHints(SDL_HintCallback callback, void *userdata)
+{
+}
+
+static void HIDAPI_DriverCombined_UnregisterHints(SDL_HintCallback callback, void *userdata)
+{
+}
+
+static bool HIDAPI_DriverCombined_IsEnabled(void)
+{
+    return true;
+}
+
+static bool HIDAPI_DriverCombined_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)
+{
+    // This is always explicitly created for combined devices
+    return false;
+}
+
+static bool HIDAPI_DriverCombined_InitDevice(SDL_HIDAPI_Device *device)
+{
+    return HIDAPI_JoystickConnected(device, NULL);
+}
+
+static int HIDAPI_DriverCombined_GetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id)
+{
+    return -1;
+}
+
+static void HIDAPI_DriverCombined_SetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id, int player_index)
+{
+}
+
+static bool HIDAPI_DriverCombined_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    int i;
+    char *serial = NULL, *new_serial;
+    size_t serial_length = 0, new_length;
+
+    SDL_AssertJoysticksLocked();
+
+    for (i = 0; i < device->num_children; ++i) {
+        SDL_HIDAPI_Device *child = device->children[i];
+        if (!child->driver->OpenJoystick(child, joystick)) {
+            child->broken = true;
+
+            while (i-- > 0) {
+                child = device->children[i];
+                child->driver->CloseJoystick(child, joystick);
+            }
+            if (serial) {
+                SDL_free(serial);
+            }
+            return false;
+        }
+
+        // Extend the serial number with the child serial number
+        if (joystick->serial) {
+            new_length = serial_length + 1 + SDL_strlen(joystick->serial);
+            new_serial = (char *)SDL_realloc(serial, new_length);
+            if (new_serial) {
+                if (serial) {
+                    SDL_strlcat(new_serial, ",", new_length);
+                    SDL_strlcat(new_serial, joystick->serial, new_length);
+                } else {
+                    SDL_strlcpy(new_serial, joystick->serial, new_length);
+                }
+                serial = new_serial;
+                serial_length = new_length;
+            }
+            SDL_free(joystick->serial);
+            joystick->serial = NULL;
+        }
+    }
+
+    // Update the joystick with the combined serial numbers
+    if (joystick->serial) {
+        SDL_free(joystick->serial);
+    }
+    joystick->serial = serial;
+
+    return true;
+}
+
+static bool HIDAPI_DriverCombined_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+    int i;
+    bool result = false;
+
+    for (i = 0; i < device->num_children; ++i) {
+        SDL_HIDAPI_Device *child = device->children[i];
+        if (child->driver->RumbleJoystick(child, joystick, low_frequency_rumble, high_frequency_rumble)) {
+            result = true;
+        }
+    }
+    return result;
+}
+
+static bool HIDAPI_DriverCombined_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
+{
+    int i;
+    bool result = false;
+
+    for (i = 0; i < device->num_children; ++i) {
+        SDL_HIDAPI_Device *child = device->children[i];
+        if (child->driver->RumbleJoystickTriggers(child, joystick, left_rumble, right_rumble)) {
+            result = true;
+        }
+    }
+    return result;
+}
+
+static Uint32 HIDAPI_DriverCombined_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    int i;
+    Uint32 caps = 0;
+
+    for (i = 0; i < device->num_children; ++i) {
+        SDL_HIDAPI_Device *child = device->children[i];
+        caps |= child->driver->GetJoystickCapabilities(child, joystick);
+    }
+    return caps;
+}
+
+static bool HIDAPI_DriverCombined_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    int i;
+    bool result = false;
+
+    for (i = 0; i < device->num_children; ++i) {
+        SDL_HIDAPI_Device *child = device->children[i];
+        if (child->driver->SetJoystickLED(child, joystick, red, green, blue)) {
+            result = true;
+        }
+    }
+    return result;
+}
+
+static bool HIDAPI_DriverCombined_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *data, int size)
+{
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverCombined_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, bool enabled)
+{
+    int i;
+    bool result = false;
+
+    for (i = 0; i < device->num_children; ++i) {
+        SDL_HIDAPI_Device *child = device->children[i];
+        if (child->driver->SetJoystickSensorsEnabled(child, joystick, enabled)) {
+            result = true;
+        }
+    }
+    return result;
+}
+
+static bool HIDAPI_DriverCombined_UpdateDevice(SDL_HIDAPI_Device *device)
+{
+    int i;
+    int result = true;
+
+    for (i = 0; i < device->num_children; ++i) {
+        SDL_HIDAPI_Device *child = device->children[i];
+        if (!child->driver->UpdateDevice(child)) {
+            result = false;
+        }
+    }
+    return result;
+}
+
+static void HIDAPI_DriverCombined_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    int i;
+
+    for (i = 0; i < device->num_children; ++i) {
+        SDL_HIDAPI_Device *child = device->children[i];
+        child->driver->CloseJoystick(child, joystick);
+    }
+}
+
+static void HIDAPI_DriverCombined_FreeDevice(SDL_HIDAPI_Device *device)
+{
+}
+
+SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverCombined = {
+    "SDL_JOYSTICK_HIDAPI_COMBINED",
+    true,
+    HIDAPI_DriverCombined_RegisterHints,
+    HIDAPI_DriverCombined_UnregisterHints,
+    HIDAPI_DriverCombined_IsEnabled,
+    HIDAPI_DriverCombined_IsSupportedDevice,
+    HIDAPI_DriverCombined_InitDevice,
+    HIDAPI_DriverCombined_GetDevicePlayerIndex,
+    HIDAPI_DriverCombined_SetDevicePlayerIndex,
+    HIDAPI_DriverCombined_UpdateDevice,
+    HIDAPI_DriverCombined_OpenJoystick,
+    HIDAPI_DriverCombined_RumbleJoystick,
+    HIDAPI_DriverCombined_RumbleJoystickTriggers,
+    HIDAPI_DriverCombined_GetJoystickCapabilities,
+    HIDAPI_DriverCombined_SetJoystickLED,
+    HIDAPI_DriverCombined_SendJoystickEffect,
+    HIDAPI_DriverCombined_SetJoystickSensorsEnabled,
+    HIDAPI_DriverCombined_CloseJoystick,
+    HIDAPI_DriverCombined_FreeDevice,
+};
+
+#endif // SDL_JOYSTICK_HIDAPI
diff --git a/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_gamecube.c b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_gamecube.c
new file mode 100644
index 0000000..4d45c7a
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_gamecube.c
@@ -0,0 +1,534 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI
+
+#include "../../SDL_hints_c.h"
+#include "../SDL_sysjoystick.h"
+#include "SDL_hidapijoystick_c.h"
+#include "SDL_hidapi_rumble.h"
+#include "../../hidapi/SDL_hidapi_c.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI_GAMECUBE
+
+// Define this if you want to log all packets from the controller
+// #define DEBUG_GAMECUBE_PROTOCOL
+
+#define MAX_CONTROLLERS 4
+
+typedef struct
+{
+    bool pc_mode;
+    SDL_JoystickID joysticks[MAX_CONTROLLERS];
+    Uint8 wireless[MAX_CONTROLLERS];
+    Uint8 min_axis[MAX_CONTROLLERS * SDL_GAMEPAD_AXIS_COUNT];
+    Uint8 max_axis[MAX_CONTROLLERS * SDL_GAMEPAD_AXIS_COUNT];
+    Uint8 rumbleAllowed[MAX_CONTROLLERS];
+    Uint8 rumble[1 + MAX_CONTROLLERS];
+    // Without this variable, hid_write starts to lag a TON
+    bool rumbleUpdate;
+    bool useRumbleBrake;
+} SDL_DriverGameCube_Context;
+
+static void HIDAPI_DriverGameCube_RegisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_GAMECUBE, callback, userdata);
+}
+
+static void HIDAPI_DriverGameCube_UnregisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_GAMECUBE, callback, userdata);
+}
+
+static bool HIDAPI_DriverGameCube_IsEnabled(void)
+{
+    return SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_GAMECUBE,
+                              SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI,
+                                                 SDL_HIDAPI_DEFAULT));
+}
+
+static bool HIDAPI_DriverGameCube_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_GAMECUBE_ADAPTER) {
+        // Nintendo Co., Ltd.  Wii U GameCube Controller Adapter
+        return true;
+    }
+    if (vendor_id == USB_VENDOR_DRAGONRISE &&
+        (product_id == USB_PRODUCT_EVORETRO_GAMECUBE_ADAPTER1 ||
+         product_id == USB_PRODUCT_EVORETRO_GAMECUBE_ADAPTER2)) {
+        // EVORETRO GameCube Controller Adapter
+        return true;
+    }
+    return false;
+}
+
+static void ResetAxisRange(SDL_DriverGameCube_Context *ctx, int joystick_index)
+{
+    SDL_memset(&ctx->min_axis[joystick_index * SDL_GAMEPAD_AXIS_COUNT], 128 - 88, SDL_GAMEPAD_AXIS_COUNT);
+    SDL_memset(&ctx->max_axis[joystick_index * SDL_GAMEPAD_AXIS_COUNT], 128 + 88, SDL_GAMEPAD_AXIS_COUNT);
+
+    // Trigger axes may have a higher resting value
+    ctx->min_axis[joystick_index * SDL_GAMEPAD_AXIS_COUNT + SDL_GAMEPAD_AXIS_LEFT_TRIGGER] = 40;
+    ctx->min_axis[joystick_index * SDL_GAMEPAD_AXIS_COUNT + SDL_GAMEPAD_AXIS_RIGHT_TRIGGER] = 40;
+}
+
+static void SDLCALL SDL_JoystickGameCubeRumbleBrakeHintChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
+{
+    if (hint) {
+        SDL_DriverGameCube_Context *ctx = (SDL_DriverGameCube_Context *)userdata;
+        ctx->useRumbleBrake = SDL_GetStringBoolean(hint, false);
+    }
+}
+
+static bool HIDAPI_DriverGameCube_InitDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverGameCube_Context *ctx;
+    Uint8 packet[37];
+    Uint8 *curSlot;
+    Uint8 i;
+    int size;
+    Uint8 initMagic = 0x13;
+    Uint8 rumbleMagic = 0x11;
+
+#ifdef HAVE_ENABLE_GAMECUBE_ADAPTORS
+    SDL_EnableGameCubeAdaptors();
+#endif
+
+    ctx = (SDL_DriverGameCube_Context *)SDL_calloc(1, sizeof(*ctx));
+    if (!ctx) {
+        return false;
+    }
+    device->context = ctx;
+
+    ctx->joysticks[0] = 0;
+    ctx->joysticks[1] = 0;
+    ctx->joysticks[2] = 0;
+    ctx->joysticks[3] = 0;
+    ctx->rumble[0] = rumbleMagic;
+    ctx->useRumbleBrake = false;
+
+    if (device->vendor_id != USB_VENDOR_NINTENDO) {
+        ctx->pc_mode = true;
+    }
+
+    if (ctx->pc_mode) {
+        for (i = 0; i < MAX_CONTROLLERS; ++i) {
+            ResetAxisRange(ctx, i);
+            HIDAPI_JoystickConnected(device, &ctx->joysticks[i]);
+        }
+    } else {
+        // This is all that's needed to initialize the device. Really!
+        if (SDL_hid_write(device->dev, &initMagic, sizeof(initMagic)) != sizeof(initMagic)) {
+            SDL_LogDebug(SDL_LOG_CATEGORY_INPUT,
+                         "HIDAPI_DriverGameCube_InitDevice(): Couldn't initialize WUP-028");
+            return false;
+        }
+
+        // Wait for the adapter to initialize
+        SDL_Delay(10);
+
+        // Add all the applicable joysticks
+        while ((size = SDL_hid_read_timeout(device->dev, packet, sizeof(packet), 0)) > 0) {
+#ifdef DEBUG_GAMECUBE_PROTOCOL
+            HIDAPI_DumpPacket("Nintendo GameCube packet: size = %d", packet, size);
+#endif
+            if (size < 37 || packet[0] != 0x21) {
+                continue; // Nothing to do yet...?
+            }
+
+            // Go through all 4 slots
+            curSlot = packet + 1;
+            for (i = 0; i < MAX_CONTROLLERS; i += 1, curSlot += 9) {
+                ctx->wireless[i] = (curSlot[0] & 0x20) != 0;
+
+                // Only allow rumble if the adapter's second USB cable is connected
+                ctx->rumbleAllowed[i] = (curSlot[0] & 0x04) && !ctx->wireless[i];
+
+                if (curSlot[0] & 0x30) { // 0x10 - Wired, 0x20 - Wireless
+                    if (ctx->joysticks[i] == 0) {
+                        ResetAxisRange(ctx, i);
+                        HIDAPI_JoystickConnected(device, &ctx->joysticks[i]);
+                    }
+                } else {
+                    if (ctx->joysticks[i] != 0) {
+                        HIDAPI_JoystickDisconnected(device, ctx->joysticks[i]);
+                        ctx->joysticks[i] = 0;
+                    }
+                    continue;
+                }
+            }
+        }
+    }
+
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_GAMECUBE_RUMBLE_BRAKE,
+                        SDL_JoystickGameCubeRumbleBrakeHintChanged, ctx);
+
+    HIDAPI_SetDeviceName(device, "Nintendo GameCube Controller");
+
+    return true;
+}
+
+static int HIDAPI_DriverGameCube_GetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id)
+{
+    SDL_DriverGameCube_Context *ctx = (SDL_DriverGameCube_Context *)device->context;
+    Uint8 i;
+
+    for (i = 0; i < 4; ++i) {
+        if (instance_id == ctx->joysticks[i]) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+static void HIDAPI_DriverGameCube_SetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id, int player_index)
+{
+}
+
+static void HIDAPI_DriverGameCube_HandleJoystickPacket(SDL_HIDAPI_Device *device, SDL_DriverGameCube_Context *ctx, const Uint8 *packet, int size)
+{
+    SDL_Joystick *joystick;
+    Uint8 i, v;
+    Sint16 axis_value;
+    Uint64 timestamp = SDL_GetTicksNS();
+
+    if (size != 10) {
+        return; // How do we handle this packet?
+    }
+
+    i = packet[0] - 1;
+    if (i >= MAX_CONTROLLERS) {
+        return; // How do we handle this packet?
+    }
+
+    joystick = SDL_GetJoystickFromID(ctx->joysticks[i]);
+    if (!joystick) {
+        // Hasn't been opened yet, skip
+        return;
+    }
+
+#define READ_BUTTON(off, flag, button)  \
+    SDL_SendJoystickButton(             \
+        timestamp,                      \
+        joystick,                       \
+        button,                         \
+        ((packet[off] & flag) != 0));
+    READ_BUTTON(1, 0x02, 0) // A
+    READ_BUTTON(1, 0x04, 1) // B
+    READ_BUTTON(1, 0x08, 3) // Y
+    READ_BUTTON(1, 0x01, 2) // X
+    READ_BUTTON(2, 0x80, 4) // DPAD_LEFT
+    READ_BUTTON(2, 0x20, 5) // DPAD_RIGHT
+    READ_BUTTON(2, 0x40, 6) // DPAD_DOWN
+    READ_BUTTON(2, 0x10, 7) // DPAD_UP
+    READ_BUTTON(2, 0x02, 8) // START
+    READ_BUTTON(1, 0x80, 9) // RIGHTSHOULDER
+    /* These two buttons are for the bottoms of the analog triggers.
+     * More than likely, you're going to want to read the axes instead!
+     * -flibit
+     */
+    READ_BUTTON(1, 0x20, 10) // TRIGGERRIGHT
+    READ_BUTTON(1, 0x10, 11) // TRIGGERLEFT
+#undef READ_BUTTON
+
+#define READ_AXIS(off, axis, invert)                                                \
+    v = invert ? (0xff - packet[off]) : packet[off];                                \
+    if (v < ctx->min_axis[i * SDL_GAMEPAD_AXIS_COUNT + axis])                      \
+        ctx->min_axis[i * SDL_GAMEPAD_AXIS_COUNT + axis] = v;                      \
+    if (v > ctx->max_axis[i * SDL_GAMEPAD_AXIS_COUNT + axis])                      \
+        ctx->max_axis[i * SDL_GAMEPAD_AXIS_COUNT + axis] = v;                      \
+    axis_value = (Sint16)HIDAPI_RemapVal(v, ctx->min_axis[i * SDL_GAMEPAD_AXIS_COUNT + axis], ctx->max_axis[i * SDL_GAMEPAD_AXIS_COUNT + axis], SDL_MIN_SINT16, SDL_MAX_SINT16); \
+    SDL_SendJoystickAxis(                                                        \
+        timestamp,                                                                  \
+        joystick,                                                                   \
+        axis, axis_value);
+    READ_AXIS(3, SDL_GAMEPAD_AXIS_LEFTX, 0)
+    READ_AXIS(4, SDL_GAMEPAD_AXIS_LEFTY, 1)
+    READ_AXIS(6, SDL_GAMEPAD_AXIS_RIGHTX, 0)
+    READ_AXIS(5, SDL_GAMEPAD_AXIS_RIGHTY, 1)
+    READ_AXIS(7, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, 0)
+    READ_AXIS(8, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, 0)
+#undef READ_AXIS
+}
+
+static void HIDAPI_DriverGameCube_HandleNintendoPacket(SDL_HIDAPI_Device *device, SDL_DriverGameCube_Context *ctx, Uint8 *packet, int size)
+{
+    SDL_Joystick *joystick;
+    Uint8 *curSlot;
+    Uint8 i;
+    Sint16 axis_value;
+    Uint64 timestamp = SDL_GetTicksNS();
+
+    if (size < 37 || packet[0] != 0x21) {
+        return; // Nothing to do right now...?
+    }
+
+    // Go through all 4 slots
+    curSlot = packet + 1;
+    for (i = 0; i < MAX_CONTROLLERS; i += 1, curSlot += 9) {
+        ctx->wireless[i] = (curSlot[0] & 0x20) != 0;
+
+        // Only allow rumble if the adapter's second USB cable is connected
+        ctx->rumbleAllowed[i] = (curSlot[0] & 0x04) && !ctx->wireless[i];
+
+        if (curSlot[0] & 0x30) { // 0x10 - Wired, 0x20 - Wireless
+            if (ctx->joysticks[i] == 0) {
+                ResetAxisRange(ctx, i);
+                HIDAPI_JoystickConnected(device, &ctx->joysticks[i]);
+            }
+            joystick = SDL_GetJoystickFromID(ctx->joysticks[i]);
+
+            // Hasn't been opened yet, skip
+            if (!joystick) {
+                continue;
+            }
+        } else {
+            if (ctx->joysticks[i] != 0) {
+                HIDAPI_JoystickDisconnected(device, ctx->joysticks[i]);
+                ctx->joysticks[i] = 0;
+            }
+            continue;
+        }
+
+#define READ_BUTTON(off, flag, button)  \
+    SDL_SendJoystickButton(             \
+        timestamp,                      \
+        joystick,                       \
+        button,                         \
+        ((curSlot[off] & flag) != 0));
+        READ_BUTTON(1, 0x01, 0) // A
+        READ_BUTTON(1, 0x02, 1) // B
+        READ_BUTTON(1, 0x04, 2) // X
+        READ_BUTTON(1, 0x08, 3) // Y
+        READ_BUTTON(1, 0x10, 4) // DPAD_LEFT
+        READ_BUTTON(1, 0x20, 5) // DPAD_RIGHT
+        READ_BUTTON(1, 0x40, 6) // DPAD_DOWN
+        READ_BUTTON(1, 0x80, 7) // DPAD_UP
+        READ_BUTTON(2, 0x01, 8) // START
+        READ_BUTTON(2, 0x02, 9) // RIGHTSHOULDER
+        /* These two buttons are for the bottoms of the analog triggers.
+         * More than likely, you're going to want to read the axes instead!
+         * -flibit
+         */
+        READ_BUTTON(2, 0x04, 10) // TRIGGERRIGHT
+        READ_BUTTON(2, 0x08, 11) // TRIGGERLEFT
+#undef READ_BUTTON
+
+#define READ_AXIS(off, axis)                                                                \
+    if (curSlot[off] < ctx->min_axis[i * SDL_GAMEPAD_AXIS_COUNT + axis])                   \
+        ctx->min_axis[i * SDL_GAMEPAD_AXIS_COUNT + axis] = curSlot[off];                   \
+    if (curSlot[off] > ctx->max_axis[i * SDL_GAMEPAD_AXIS_COUNT + axis])                   \
+        ctx->max_axis[i * SDL_GAMEPAD_AXIS_COUNT + axis] = curSlot[off];                   \
+    axis_value = (Sint16)HIDAPI_RemapVal(curSlot[off], ctx->min_axis[i * SDL_GAMEPAD_AXIS_COUNT + axis], ctx->max_axis[i * SDL_GAMEPAD_AXIS_COUNT + axis], SDL_MIN_SINT16, SDL_MAX_SINT16); \
+    SDL_SendJoystickAxis(                                                                \
+        timestamp,                                                                          \
+        joystick,                                                                           \
+        axis, axis_value);
+        READ_AXIS(3, SDL_GAMEPAD_AXIS_LEFTX)
+        READ_AXIS(4, SDL_GAMEPAD_AXIS_LEFTY)
+        READ_AXIS(5, SDL_GAMEPAD_AXIS_RIGHTX)
+        READ_AXIS(6, SDL_GAMEPAD_AXIS_RIGHTY)
+        READ_AXIS(7, SDL_GAMEPAD_AXIS_LEFT_TRIGGER)
+        READ_AXIS(8, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER)
+#undef READ_AXIS
+    }
+}
+
+static bool HIDAPI_DriverGameCube_UpdateDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverGameCube_Context *ctx = (SDL_DriverGameCube_Context *)device->context;
+    Uint8 packet[USB_PACKET_LENGTH];
+    int size;
+
+    // Read input packet
+    while ((size = SDL_hid_read_timeout(device->dev, packet, sizeof(packet), 0)) > 0) {
+#ifdef DEBUG_GAMECUBE_PROTOCOL
+        HIDAPI_DumpPacket("Nintendo GameCube packet: size = %d", packet, size);
+#endif
+        if (ctx->pc_mode) {
+            HIDAPI_DriverGameCube_HandleJoystickPacket(device, ctx, packet, size);
+        } else {
+            HIDAPI_DriverGameCube_HandleNintendoPacket(device, ctx, packet, size);
+        }
+    }
+
+    // Write rumble packet
+    if (ctx->rumbleUpdate) {
+        SDL_HIDAPI_SendRumble(device, ctx->rumble, sizeof(ctx->rumble));
+        ctx->rumbleUpdate = false;
+    }
+
+    // If we got here, nothing bad happened!
+    return true;
+}
+
+static bool HIDAPI_DriverGameCube_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverGameCube_Context *ctx = (SDL_DriverGameCube_Context *)device->context;
+    Uint8 i;
+
+    SDL_AssertJoysticksLocked();
+
+    for (i = 0; i < MAX_CONTROLLERS; i += 1) {
+        if (joystick->instance_id == ctx->joysticks[i]) {
+            joystick->nbuttons = 12;
+            joystick->naxes = SDL_GAMEPAD_AXIS_COUNT;
+            if (ctx->wireless[i]) {
+                joystick->connection_state = SDL_JOYSTICK_CONNECTION_WIRELESS;
+            } else {
+                joystick->connection_state = SDL_JOYSTICK_CONNECTION_WIRED;
+            }
+            return true;
+        }
+    }
+    return false; // Should never get here!
+}
+
+static bool HIDAPI_DriverGameCube_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+    SDL_DriverGameCube_Context *ctx = (SDL_DriverGameCube_Context *)device->context;
+    Uint8 i, val;
+
+    SDL_AssertJoysticksLocked();
+
+    if (ctx->pc_mode) {
+        return SDL_Unsupported();
+    }
+
+    for (i = 0; i < MAX_CONTROLLERS; i += 1) {
+        if (joystick->instance_id == ctx->joysticks[i]) {
+            if (ctx->wireless[i]) {
+                return SDL_SetError("Nintendo GameCube WaveBird controllers do not support rumble");
+            }
+            if (!ctx->rumbleAllowed[i]) {
+                return SDL_SetError("Second USB cable for WUP-028 not connected");
+            }
+            if (ctx->useRumbleBrake) {
+                if (low_frequency_rumble == 0 && high_frequency_rumble > 0) {
+                    val = 0; // if only low is 0 we want to do a regular stop
+                } else if (low_frequency_rumble == 0 && high_frequency_rumble == 0) {
+                    val = 2; // if both frequencies are 0 we want to do a hard stop
+                } else {
+                    val = 1; // normal rumble
+                }
+            } else {
+                val = (low_frequency_rumble > 0 || high_frequency_rumble > 0);
+            }
+            if (val != ctx->rumble[i + 1]) {
+                ctx->rumble[i + 1] = val;
+                ctx->rumbleUpdate = true;
+            }
+            return true;
+        }
+    }
+
+    // Should never get here!
+    return SDL_SetError("Couldn't find joystick");
+}
+
+static bool HIDAPI_DriverGameCube_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
+{
+    return SDL_Unsupported();
+}
+
+static Uint32 HIDAPI_DriverGameCube_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverGameCube_Context *ctx = (SDL_DriverGameCube_Context *)device->context;
+    Uint32 result = 0;
+
+    SDL_AssertJoysticksLocked();
+
+    if (!ctx->pc_mode) {
+        Uint8 i;
+
+        for (i = 0; i < MAX_CONTROLLERS; i += 1) {
+            if (joystick->instance_id == ctx->joysticks[i]) {
+                if (!ctx->wireless[i] && ctx->rumbleAllowed[i]) {
+                    result |= SDL_JOYSTICK_CAP_RUMBLE;
+                    break;
+                }
+            }
+        }
+    }
+
+    return result;
+}
+
+static bool HIDAPI_DriverGameCube_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverGameCube_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *data, int size)
+{
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverGameCube_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, bool enabled)
+{
+    return SDL_Unsupported();
+}
+
+static void HIDAPI_DriverGameCube_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverGameCube_Context *ctx = (SDL_DriverGameCube_Context *)device->context;
+
+    // Stop rumble activity
+    if (ctx->rumbleUpdate) {
+        SDL_HIDAPI_SendRumble(device, ctx->rumble, sizeof(ctx->rumble));
+        ctx->rumbleUpdate = false;
+    }
+}
+
+static void HIDAPI_DriverGameCube_FreeDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverGameCube_Context *ctx = (SDL_DriverGameCube_Context *)device->context;
+
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_GAMECUBE_RUMBLE_BRAKE,
+                        SDL_JoystickGameCubeRumbleBrakeHintChanged, ctx);
+}
+
+SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverGameCube = {
+    SDL_HINT_JOYSTICK_HIDAPI_GAMECUBE,
+    true,
+    HIDAPI_DriverGameCube_RegisterHints,
+    HIDAPI_DriverGameCube_UnregisterHints,
+    HIDAPI_DriverGameCube_IsEnabled,
+    HIDAPI_DriverGameCube_IsSupportedDevice,
+    HIDAPI_DriverGameCube_InitDevice,
+    HIDAPI_DriverGameCube_GetDevicePlayerIndex,
+    HIDAPI_DriverGameCube_SetDevicePlayerIndex,
+    HIDAPI_DriverGameCube_UpdateDevice,
+    HIDAPI_DriverGameCube_OpenJoystick,
+    HIDAPI_DriverGameCube_RumbleJoystick,
+    HIDAPI_DriverGameCube_RumbleJoystickTriggers,
+    HIDAPI_DriverGameCube_GetJoystickCapabilities,
+    HIDAPI_DriverGameCube_SetJoystickLED,
+    HIDAPI_DriverGameCube_SendJoystickEffect,
+    HIDAPI_DriverGameCube_SetJoystickSensorsEnabled,
+    HIDAPI_DriverGameCube_CloseJoystick,
+    HIDAPI_DriverGameCube_FreeDevice,
+};
+
+#endif // SDL_JOYSTICK_HIDAPI_GAMECUBE
+
+#endif // SDL_JOYSTICK_HIDAPI
diff --git a/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_luna.c b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_luna.c
new file mode 100644
index 0000000..7c889a6
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_luna.c
@@ -0,0 +1,421 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI
+
+#include "../SDL_sysjoystick.h"
+#include "SDL_hidapijoystick_c.h"
+#include "SDL_hidapi_rumble.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI_LUNA
+
+// Define this if you want to log all packets from the controller
+// #define DEBUG_LUNA_PROTOCOL
+
+// Sending rumble on macOS blocks for a long time and eventually fails
+#ifndef SDL_PLATFORM_MACOS
+#define ENABLE_LUNA_BLUETOOTH_RUMBLE
+#endif
+
+enum
+{
+    SDL_GAMEPAD_BUTTON_LUNA_MICROPHONE = 11,
+    SDL_GAMEPAD_NUM_LUNA_BUTTONS,
+};
+
+typedef struct
+{
+    Uint8 last_state[USB_PACKET_LENGTH];
+} SDL_DriverLuna_Context;
+
+static void HIDAPI_DriverLuna_RegisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_LUNA, callback, userdata);
+}
+
+static void HIDAPI_DriverLuna_UnregisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_LUNA, callback, userdata);
+}
+
+static bool HIDAPI_DriverLuna_IsEnabled(void)
+{
+    return SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_LUNA, SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI, SDL_HIDAPI_DEFAULT));
+}
+
+static bool HIDAPI_DriverLuna_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)
+{
+    return SDL_IsJoystickAmazonLunaController(vendor_id, product_id);
+}
+
+static bool HIDAPI_DriverLuna_InitDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverLuna_Context *ctx;
+
+    ctx = (SDL_DriverLuna_Context *)SDL_calloc(1, sizeof(*ctx));
+    if (!ctx) {
+        return false;
+    }
+    device->context = ctx;
+
+    HIDAPI_SetDeviceName(device, "Amazon Luna Controller");
+
+    return HIDAPI_JoystickConnected(device, NULL);
+}
+
+static int HIDAPI_DriverLuna_GetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id)
+{
+    return -1;
+}
+
+static void HIDAPI_DriverLuna_SetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id, int player_index)
+{
+}
+
+static bool HIDAPI_DriverLuna_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverLuna_Context *ctx = (SDL_DriverLuna_Context *)device->context;
+
+    SDL_AssertJoysticksLocked();
+
+    SDL_zeroa(ctx->last_state);
+
+    // Initialize the joystick capabilities
+    joystick->nbuttons = SDL_GAMEPAD_NUM_LUNA_BUTTONS;
+    joystick->naxes = SDL_GAMEPAD_AXIS_COUNT;
+    joystick->nhats = 1;
+
+    return true;
+}
+
+static bool HIDAPI_DriverLuna_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+#ifdef ENABLE_LUNA_BLUETOOTH_RUMBLE
+    if (device->product_id == BLUETOOTH_PRODUCT_LUNA_CONTROLLER) {
+        // Same packet as on Xbox One controllers connected via Bluetooth
+        Uint8 rumble_packet[] = { 0x03, 0x0F, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xEB };
+
+        // Magnitude is 1..100 so scale the 16-bit input here
+        rumble_packet[4] = (Uint8)(low_frequency_rumble / 655);
+        rumble_packet[5] = (Uint8)(high_frequency_rumble / 655);
+
+        if (SDL_HIDAPI_SendRumble(device, rumble_packet, sizeof(rumble_packet)) != sizeof(rumble_packet)) {
+            return SDL_SetError("Couldn't send rumble packet");
+        }
+
+        return true;
+    }
+#endif // ENABLE_LUNA_BLUETOOTH_RUMBLE
+
+    // There is currently no rumble packet over USB
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverLuna_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
+{
+    return SDL_Unsupported();
+}
+
+static Uint32 HIDAPI_DriverLuna_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    Uint32 result = 0;
+
+#ifdef ENABLE_LUNA_BLUETOOTH_RUMBLE
+    if (device->product_id == BLUETOOTH_PRODUCT_LUNA_CONTROLLER) {
+        result |= SDL_JOYSTICK_CAP_RUMBLE;
+    }
+#endif
+
+    return result;
+}
+
+static bool HIDAPI_DriverLuna_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverLuna_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *data, int size)
+{
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverLuna_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, bool enabled)
+{
+    return SDL_Unsupported();
+}
+
+static void HIDAPI_DriverLuna_HandleUSBStatePacket(SDL_Joystick *joystick, SDL_DriverLuna_Context *ctx, Uint8 *data, int size)
+{
+    Uint64 timestamp = SDL_GetTicksNS();
+
+    if (ctx->last_state[1] != data[1]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SOUTH, ((data[1] & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_EAST, ((data[1] & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_WEST, ((data[1] & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_NORTH, ((data[1] & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data[1] & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data[1] & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK, ((data[1] & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data[1] & 0x80) != 0));
+    }
+    if (ctx->last_state[2] != data[2]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data[2] & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LUNA_MICROPHONE, ((data[2] & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data[2] & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_STICK, ((data[2] & 0x08) != 0));
+    }
+
+    if (ctx->last_state[3] != data[3]) {
+        Uint8 hat;
+
+        switch (data[3] & 0x0f) {
+        case 0:
+            hat = SDL_HAT_UP;
+            break;
+        case 1:
+            hat = SDL_HAT_RIGHTUP;
+            break;
+        case 2:
+            hat = SDL_HAT_RIGHT;
+            break;
+        case 3:
+            hat = SDL_HAT_RIGHTDOWN;
+            break;
+        case 4:
+            hat = SDL_HAT_DOWN;
+            break;
+        case 5:
+            hat = SDL_HAT_LEFTDOWN;
+            break;
+        case 6:
+            hat = SDL_HAT_LEFT;
+            break;
+        case 7:
+            hat = SDL_HAT_LEFTUP;
+            break;
+        default:
+            hat = SDL_HAT_CENTERED;
+            break;
+        }
+        SDL_SendJoystickHat(timestamp, joystick, 0, hat);
+    }
+
+#define READ_STICK_AXIS(offset) \
+    (data[offset] == 0x7f ? 0 : (Sint16)HIDAPI_RemapVal((float)data[offset], 0x00, 0xff, SDL_MIN_SINT16, SDL_MAX_SINT16))
+    {
+        Sint16 axis = READ_STICK_AXIS(4);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, axis);
+        axis = READ_STICK_AXIS(5);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, axis);
+        axis = READ_STICK_AXIS(6);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, axis);
+        axis = READ_STICK_AXIS(7);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, axis);
+    }
+#undef READ_STICK_AXIS
+
+#define READ_TRIGGER_AXIS(offset) \
+    (Sint16) HIDAPI_RemapVal((float)data[offset], 0x00, 0xff, SDL_MIN_SINT16, SDL_MAX_SINT16)
+    {
+        Sint16 axis = READ_TRIGGER_AXIS(8);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, axis);
+        axis = READ_TRIGGER_AXIS(9);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, axis);
+    }
+#undef READ_TRIGGER_AXIS
+
+    SDL_memcpy(ctx->last_state, data, SDL_min(size, sizeof(ctx->last_state)));
+}
+
+static void HIDAPI_DriverLuna_HandleBluetoothStatePacket(SDL_Joystick *joystick, SDL_DriverLuna_Context *ctx, Uint8 *data, int size)
+{
+    Uint64 timestamp = SDL_GetTicksNS();
+
+    if (size >= 2 && data[0] == 0x02) {
+        // Home button has dedicated report
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data[1] & 0x1) != 0));
+        return;
+    }
+
+    if (size >= 2 && data[0] == 0x04) {
+        // Battery level report
+        int percent = (int)SDL_roundf((data[1] / 255.0f) * 100.0f);
+        SDL_SendJoystickPowerInfo(joystick, SDL_POWERSTATE_ON_BATTERY, percent);
+        return;
+    }
+
+    if (size < 17 || data[0] != 0x01) {
+        // We don't know how to handle this report
+        return;
+    }
+
+    if (ctx->last_state[13] != data[13]) {
+        Uint8 hat;
+
+        switch (data[13] & 0x0f) {
+        case 1:
+            hat = SDL_HAT_UP;
+            break;
+        case 2:
+            hat = SDL_HAT_RIGHTUP;
+            break;
+        case 3:
+            hat = SDL_HAT_RIGHT;
+            break;
+        case 4:
+            hat = SDL_HAT_RIGHTDOWN;
+            break;
+        case 5:
+            hat = SDL_HAT_DOWN;
+            break;
+        case 6:
+            hat = SDL_HAT_LEFTDOWN;
+            break;
+        case 7:
+            hat = SDL_HAT_LEFT;
+            break;
+        case 8:
+            hat = SDL_HAT_LEFTUP;
+            break;
+        default:
+            hat = SDL_HAT_CENTERED;
+            break;
+        }
+        SDL_SendJoystickHat(timestamp, joystick, 0, hat);
+    }
+
+    if (ctx->last_state[14] != data[14]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SOUTH, ((data[14] & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_EAST, ((data[14] & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_WEST, ((data[14] & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_NORTH, ((data[14] & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data[14] & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data[14] & 0x80) != 0));
+    }
+    if (ctx->last_state[15] != data[15]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data[15] & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data[15] & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_STICK, ((data[15] & 0x40) != 0));
+    }
+    if (ctx->last_state[16] != data[16]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK, ((data[16] & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LUNA_MICROPHONE, ((data[16] & 0x02) != 0));
+    }
+
+#define READ_STICK_AXIS(offset) \
+    (data[offset] == 0x7f ? 0 : (Sint16)HIDAPI_RemapVal((float)data[offset], 0x00, 0xff, SDL_MIN_SINT16, SDL_MAX_SINT16))
+    {
+        Sint16 axis = READ_STICK_AXIS(2);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, axis);
+        axis = READ_STICK_AXIS(4);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, axis);
+        axis = READ_STICK_AXIS(6);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, axis);
+        axis = READ_STICK_AXIS(8);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, axis);
+    }
+#undef READ_STICK_AXIS
+
+#define READ_TRIGGER_AXIS(offset) \
+    (Sint16) HIDAPI_RemapVal((float)((int)(((data[offset] | (data[offset + 1] << 8)) & 0x3ff) - 0x200)), 0x00 - 0x200, 0x3ff - 0x200, SDL_MIN_SINT16, SDL_MAX_SINT16)
+    {
+        Sint16 axis = READ_TRIGGER_AXIS(9);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, axis);
+        axis = READ_TRIGGER_AXIS(11);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, axis);
+    }
+#undef READ_TRIGGER_AXIS
+
+    SDL_memcpy(ctx->last_state, data, SDL_min(size, sizeof(ctx->last_state)));
+}
+
+static bool HIDAPI_DriverLuna_UpdateDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverLuna_Context *ctx = (SDL_DriverLuna_Context *)device->context;
+    SDL_Joystick *joystick = NULL;
+    Uint8 data[USB_PACKET_LENGTH];
+    int size = 0;
+
+    if (device->num_joysticks > 0) {
+        joystick = SDL_GetJoystickFromID(device->joysticks[0]);
+    } else {
+        return false;
+    }
+
+    while ((size = SDL_hid_read_timeout(device->dev, data, sizeof(data), 0)) > 0) {
+#ifdef DEBUG_LUNA_PROTOCOL
+        HIDAPI_DumpPacket("Amazon Luna packet: size = %d", data, size);
+#endif
+        if (!joystick) {
+            continue;
+        }
+
+        switch (size) {
+        case 10:
+            HIDAPI_DriverLuna_HandleUSBStatePacket(joystick, ctx, data, size);
+            break;
+        default:
+            HIDAPI_DriverLuna_HandleBluetoothStatePacket(joystick, ctx, data, size);
+            break;
+        }
+    }
+
+    if (size < 0) {
+        // Read error, device is disconnected
+        HIDAPI_JoystickDisconnected(device, device->joysticks[0]);
+    }
+    return (size >= 0);
+}
+
+static void HIDAPI_DriverLuna_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+}
+
+static void HIDAPI_DriverLuna_FreeDevice(SDL_HIDAPI_Device *device)
+{
+}
+
+SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverLuna = {
+    SDL_HINT_JOYSTICK_HIDAPI_LUNA,
+    true,
+    HIDAPI_DriverLuna_RegisterHints,
+    HIDAPI_DriverLuna_UnregisterHints,
+    HIDAPI_DriverLuna_IsEnabled,
+    HIDAPI_DriverLuna_IsSupportedDevice,
+    HIDAPI_DriverLuna_InitDevice,
+    HIDAPI_DriverLuna_GetDevicePlayerIndex,
+    HIDAPI_DriverLuna_SetDevicePlayerIndex,
+    HIDAPI_DriverLuna_UpdateDevice,
+    HIDAPI_DriverLuna_OpenJoystick,
+    HIDAPI_DriverLuna_RumbleJoystick,
+    HIDAPI_DriverLuna_RumbleJoystickTriggers,
+    HIDAPI_DriverLuna_GetJoystickCapabilities,
+    HIDAPI_DriverLuna_SetJoystickLED,
+    HIDAPI_DriverLuna_SendJoystickEffect,
+    HIDAPI_DriverLuna_SetJoystickSensorsEnabled,
+    HIDAPI_DriverLuna_CloseJoystick,
+    HIDAPI_DriverLuna_FreeDevice,
+};
+
+#endif // SDL_JOYSTICK_HIDAPI_LUNA
+
+#endif // SDL_JOYSTICK_HIDAPI
diff --git a/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_nintendo.h b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_nintendo.h
new file mode 100644
index 0000000..0a5836f
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_nintendo.h
@@ -0,0 +1,49 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+// These are values used in the controller type byte of the controller GUID
+
+// These values come directly out of the hardware, so don't change them
+typedef enum
+{
+    k_eSwitchDeviceInfoControllerType_Unknown = 0,
+    k_eSwitchDeviceInfoControllerType_JoyConLeft = 1,
+    k_eSwitchDeviceInfoControllerType_JoyConRight = 2,
+    k_eSwitchDeviceInfoControllerType_ProController = 3,
+    k_eSwitchDeviceInfoControllerType_LicProController = 6,
+    k_eSwitchDeviceInfoControllerType_HVCLeft = 7,
+    k_eSwitchDeviceInfoControllerType_HVCRight = 8,
+    k_eSwitchDeviceInfoControllerType_NESLeft = 9,
+    k_eSwitchDeviceInfoControllerType_NESRight = 10,
+    k_eSwitchDeviceInfoControllerType_SNES = 11,
+    k_eSwitchDeviceInfoControllerType_N64 = 12,
+    k_eSwitchDeviceInfoControllerType_SEGA_Genesis = 13,
+} ESwitchDeviceInfoControllerType;
+
+// These values are used internally but can be updated as needed
+typedef enum
+{
+    k_eWiiExtensionControllerType_Unknown = 0,
+    k_eWiiExtensionControllerType_None = 128,
+    k_eWiiExtensionControllerType_Nunchuk = 129,
+    k_eWiiExtensionControllerType_Gamepad = 130,
+    k_eWiiExtensionControllerType_WiiUPro = 131,
+} EWiiExtensionControllerType;
diff --git a/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_ps3.c b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_ps3.c
new file mode 100644
index 0000000..6c82647
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_ps3.c
@@ -0,0 +1,1446 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI
+
+#include "../../SDL_hints_c.h"
+#include "../SDL_sysjoystick.h"
+#include "SDL_hidapijoystick_c.h"
+#include "SDL_hidapi_rumble.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI_PS3
+
+// Define this if you want to log all packets from the controller
+// #define DEBUG_PS3_PROTOCOL
+
+#define LOAD16(A, B) (Sint16)((Uint16)(A) | (((Uint16)(B)) << 8))
+
+typedef enum
+{
+    k_EPS3ReportIdState = 1,
+    k_EPS3ReportIdEffects = 1,
+} EPS3ReportId;
+
+typedef enum
+{
+    k_EPS3SonySixaxisReportIdState = 0,
+    k_EPS3SonySixaxisReportIdEffects = 0,
+} EPS3SonySixaxisReportId;
+
+// Commands for Sony's sixaxis.sys Windows driver
+// All commands must be sent using 49-byte buffer containing output report
+// Byte 0 indicates reportId and must always be 0
+// Byte 1 indicates a command, supported values are specified below:
+typedef enum
+{
+    // This command allows to set user LEDs.
+    // Bytes 5,6.7.8 contain mode for corresponding LED: 0 - LED is off, 1 - LED in on, 2 - LED is flashing.
+    // Bytes 9-16 specify 64-bit LED flash period in 100 ns units if some LED is flashing, otherwise not used.
+    k_EPS3SixaxisCommandSetLEDs = 1,
+
+    // This command allows to set left and right motors.
+    // Byte 5 is right motor duration (0-255) and byte 6, if not zero, activates right motor. Zero value disables right motor.
+    // Byte 7 is left motor duration (0-255) and byte 8 is left motor amplitude (0-255).
+    k_EPS3SixaxisCommandSetMotors = 2,
+
+    // This command allows to block/unblock setting device LEDs by applications.
+    // Byte 5 is used as parameter - any non-zero value blocks LEDs, zero value will unblock LEDs.
+    k_EPS3SixaxisCommandBlockLEDs = 3,
+
+    // This command refreshes driver settings. No parameters used.
+    // When sixaxis driver loads it reads 'CurrentDriverSetting' binary value from 'HKLM\System\CurrentControlSet\Services\sixaxis\Parameters' registry key.
+    // If the key is not present then default values are used. Sending this command forces sixaxis driver to re-read the registry and update driver settings.
+    k_EPS3SixaxisCommandRefreshDriverSetting = 9,
+
+    // This command clears current bluetooth pairing. No parameters used.
+    k_EPS3SixaxisCommandClearPairing = 10
+} EPS3SixaxisDriverCommands;
+
+typedef struct
+{
+    SDL_HIDAPI_Device *device;
+    SDL_Joystick *joystick;
+    bool is_shanwan;
+    bool has_analog_buttons;
+    bool report_sensors;
+    bool effects_updated;
+    int player_index;
+    Uint8 rumble_left;
+    Uint8 rumble_right;
+    Uint8 last_state[USB_PACKET_LENGTH];
+} SDL_DriverPS3_Context;
+
+static bool HIDAPI_DriverPS3_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *effect, int size);
+
+static void HIDAPI_DriverPS3_RegisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_PS3, callback, userdata);
+}
+
+static void HIDAPI_DriverPS3_UnregisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_PS3, callback, userdata);
+}
+
+static bool HIDAPI_DriverPS3_IsEnabled(void)
+{
+    bool default_value;
+
+#ifdef SDL_PLATFORM_MACOS
+    // This works well on macOS
+    default_value = true;
+#elif defined(SDL_PLATFORM_WIN32)
+    /* For official Sony driver (sixaxis.sys) use SDL_HINT_JOYSTICK_HIDAPI_PS3_SIXAXIS_DRIVER.
+     *
+     * See https://github.com/ViGEm/DsHidMini as an alternative driver
+     */
+    default_value = false;
+#elif defined(SDL_PLATFORM_LINUX)
+    /* Linux drivers do a better job of managing the transition between
+     * USB and Bluetooth. There are also some quirks in communicating
+     * with PS3 controllers that have been implemented in SDL's hidapi
+     * for libusb, but are not possible to support using hidraw if the
+     * kernel doesn't already know about them.
+     */
+    default_value = false;
+#else
+    // Untested, default off
+    default_value = false;
+#endif
+
+    if (default_value) {
+        default_value = SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI, SDL_HIDAPI_DEFAULT);
+    }
+    return SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_PS3, default_value);
+}
+
+static bool HIDAPI_DriverPS3_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_SONY && product_id == USB_PRODUCT_SONY_DS3) {
+        return true;
+    }
+    if (vendor_id == USB_VENDOR_SHANWAN && product_id == USB_PRODUCT_SHANWAN_DS3) {
+        return true;
+    }
+    return false;
+}
+
+static int ReadFeatureReport(SDL_hid_device *dev, Uint8 report_id, Uint8 *report, size_t length)
+{
+    SDL_memset(report, 0, length);
+    report[0] = report_id;
+    return SDL_hid_get_feature_report(dev, report, length);
+}
+
+static int SendFeatureReport(SDL_hid_device *dev, Uint8 *report, size_t length)
+{
+    return SDL_hid_send_feature_report(dev, report, length);
+}
+
+static bool HIDAPI_DriverPS3_InitDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverPS3_Context *ctx;
+    bool is_shanwan = false;
+
+    if (device->vendor_id == USB_VENDOR_SONY &&
+        SDL_strncasecmp(device->name, "ShanWan", 7) == 0) {
+        is_shanwan = true;
+    }
+    if (device->vendor_id == USB_VENDOR_SHANWAN ||
+        device->vendor_id == USB_VENDOR_SHANWAN_ALT) {
+        is_shanwan = true;
+    }
+
+    ctx = (SDL_DriverPS3_Context *)SDL_calloc(1, sizeof(*ctx));
+    if (!ctx) {
+        return false;
+    }
+    ctx->device = device;
+    ctx->is_shanwan = is_shanwan;
+    ctx->has_analog_buttons = true;
+
+    device->context = ctx;
+
+    // Set the controller into report mode over Bluetooth
+    if (device->is_bluetooth) {
+        Uint8 data[] = { 0xf4, 0x42, 0x03, 0x00, 0x00 };
+
+        SendFeatureReport(device->dev, data, sizeof(data));
+    }
+
+    // Set the controller into report mode over USB
+    if (!device->is_bluetooth) {
+        Uint8 data[USB_PACKET_LENGTH];
+
+        int size = ReadFeatureReport(device->dev, 0xf2, data, 17);
+        if (size < 0) {
+            SDL_LogDebug(SDL_LOG_CATEGORY_INPUT,
+                         "HIDAPI_DriverPS3_InitDevice(): Couldn't read feature report 0xf2");
+            return false;
+        }
+#ifdef DEBUG_PS3_PROTOCOL
+        HIDAPI_DumpPacket("PS3 0xF2 packet: size = %d", data, size);
+#endif
+        size = ReadFeatureReport(device->dev, 0xf5, data, 8);
+        if (size < 0) {
+            SDL_LogDebug(SDL_LOG_CATEGORY_INPUT,
+                         "HIDAPI_DriverPS3_InitDevice(): Couldn't read feature report 0xf5");
+            return false;
+        }
+#ifdef DEBUG_PS3_PROTOCOL
+        HIDAPI_DumpPacket("PS3 0xF5 packet: size = %d", data, size);
+#endif
+        if (!ctx->is_shanwan) {
+            // An output report could cause ShanWan controllers to rumble non-stop
+            SDL_hid_write(device->dev, data, 1);
+        }
+    }
+
+    device->type = SDL_GAMEPAD_TYPE_PS3;
+    HIDAPI_SetDeviceName(device, "PS3 Controller");
+
+    return HIDAPI_JoystickConnected(device, NULL);
+}
+
+static int HIDAPI_DriverPS3_GetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id)
+{
+    return -1;
+}
+
+static bool HIDAPI_DriverPS3_UpdateEffects(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverPS3_Context *ctx = (SDL_DriverPS3_Context *)device->context;
+
+    Uint8 effects[] = {
+        0x01, 0xff, 0x00, 0xff, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00,
+        0xff, 0x27, 0x10, 0x00, 0x32,
+        0xff, 0x27, 0x10, 0x00, 0x32,
+        0xff, 0x27, 0x10, 0x00, 0x32,
+        0xff, 0x27, 0x10, 0x00, 0x32,
+        0x00, 0x00, 0x00, 0x00, 0x00
+    };
+
+    effects[2] = ctx->rumble_right ? 1 : 0;
+    effects[4] = ctx->rumble_left;
+
+    effects[9] = (0x01 << (1 + (ctx->player_index % 4)));
+
+    return HIDAPI_DriverPS3_SendJoystickEffect(device, ctx->joystick, effects, sizeof(effects));
+}
+
+static void HIDAPI_DriverPS3_SetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id, int player_index)
+{
+    SDL_DriverPS3_Context *ctx = (SDL_DriverPS3_Context *)device->context;
+
+    if (!ctx) {
+        return;
+    }
+
+    ctx->player_index = player_index;
+
+    // This will set the new LED state based on the new player index
+    HIDAPI_DriverPS3_UpdateEffects(device);
+}
+
+static bool HIDAPI_DriverPS3_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverPS3_Context *ctx = (SDL_DriverPS3_Context *)device->context;
+
+    SDL_AssertJoysticksLocked();
+
+    ctx->joystick = joystick;
+    ctx->effects_updated = false;
+    ctx->rumble_left = 0;
+    ctx->rumble_right = 0;
+    SDL_zeroa(ctx->last_state);
+
+    // Initialize player index (needed for setting LEDs)
+    ctx->player_index = SDL_GetJoystickPlayerIndex(joystick);
+
+    // Initialize the joystick capabilities
+    joystick->nbuttons = 11;
+    joystick->naxes = 6;
+    if (ctx->has_analog_buttons) {
+        joystick->naxes += 10;
+    }
+    joystick->nhats = 1;
+
+    SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_ACCEL, 100.0f);
+
+    return true;
+}
+
+static bool HIDAPI_DriverPS3_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+    SDL_DriverPS3_Context *ctx = (SDL_DriverPS3_Context *)device->context;
+
+    ctx->rumble_left = (low_frequency_rumble >> 8);
+    ctx->rumble_right = (high_frequency_rumble >> 8);
+
+    return HIDAPI_DriverPS3_UpdateEffects(device);
+}
+
+static bool HIDAPI_DriverPS3_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
+{
+    return SDL_Unsupported();
+}
+
+static Uint32 HIDAPI_DriverPS3_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    return SDL_JOYSTICK_CAP_RUMBLE;
+}
+
+static bool HIDAPI_DriverPS3_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverPS3_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *effect, int size)
+{
+    Uint8 data[49];
+    int report_size, offset;
+
+    SDL_zeroa(data);
+
+    data[0] = k_EPS3ReportIdEffects;
+    report_size = sizeof(data);
+    offset = 1;
+    SDL_memcpy(&data[offset], effect, SDL_min((sizeof(data) - offset), (size_t)size));
+
+    if (SDL_HIDAPI_SendRumble(device, data, report_size) != report_size) {
+        return SDL_SetError("Couldn't send rumble packet");
+    }
+    return true;
+}
+
+static bool HIDAPI_DriverPS3_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, bool enabled)
+{
+    SDL_DriverPS3_Context *ctx = (SDL_DriverPS3_Context *)device->context;
+
+    ctx->report_sensors = enabled;
+
+    return true;
+}
+
+static float HIDAPI_DriverPS3_ScaleAccel(Sint16 value)
+{
+    // Accelerometer values are in big endian order
+    value = SDL_Swap16BE(value);
+    return ((float)(value - 511) / 113.0f) * SDL_STANDARD_GRAVITY;
+}
+
+static void HIDAPI_DriverPS3_HandleMiniStatePacket(SDL_Joystick *joystick, SDL_DriverPS3_Context *ctx, Uint8 *data, int size)
+{
+    Sint16 axis;
+    Uint64 timestamp = SDL_GetTicksNS();
+
+    if (ctx->last_state[4] != data[4]) {
+        Uint8 hat;
+
+        switch (data[4] & 0x0f) {
+        case 0:
+            hat = SDL_HAT_UP;
+            break;
+        case 1:
+            hat = SDL_HAT_RIGHTUP;
+            break;
+        case 2:
+            hat = SDL_HAT_RIGHT;
+            break;
+        case 3:
+            hat = SDL_HAT_RIGHTDOWN;
+            break;
+        case 4:
+            hat = SDL_HAT_DOWN;
+            break;
+        case 5:
+            hat = SDL_HAT_LEFTDOWN;
+            break;
+        case 6:
+            hat = SDL_HAT_LEFT;
+            break;
+        case 7:
+            hat = SDL_HAT_LEFTUP;
+            break;
+        default:
+            hat = SDL_HAT_CENTERED;
+            break;
+        }
+        SDL_SendJoystickHat(timestamp, joystick, 0, hat);
+
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_NORTH, ((data[4] & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_EAST, ((data[4] & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SOUTH, ((data[4] & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_WEST, ((data[4] & 0x80) != 0));
+    }
+
+    if (ctx->last_state[5] != data[5]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data[5] & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data[5] & 0x02) != 0));
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, (data[5] & 0x04) ? SDL_JOYSTICK_AXIS_MAX : SDL_JOYSTICK_AXIS_MIN);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, (data[5] & 0x08) ? SDL_JOYSTICK_AXIS_MAX : SDL_JOYSTICK_AXIS_MIN);
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK, ((data[5] & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data[5] & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data[5] & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_STICK, ((data[5] & 0x80) != 0));
+    }
+
+    axis = ((int)data[2] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, axis);
+    axis = ((int)data[3] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, axis);
+    axis = ((int)data[0] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, axis);
+    axis = ((int)data[1] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, axis);
+
+    SDL_memcpy(ctx->last_state, data, SDL_min(size, sizeof(ctx->last_state)));
+}
+
+static void HIDAPI_DriverPS3_HandleStatePacket(SDL_Joystick *joystick, SDL_DriverPS3_Context *ctx, Uint8 *data, int size)
+{
+    Sint16 axis;
+    Uint64 timestamp = SDL_GetTicksNS();
+
+    if (ctx->last_state[2] != data[2]) {
+        Uint8 hat = 0;
+
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK, ((data[2] & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data[2] & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_STICK, ((data[2] & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data[2] & 0x08) != 0));
+
+        if (data[2] & 0x10) {
+            hat |= SDL_HAT_UP;
+        }
+        if (data[2] & 0x20) {
+            hat |= SDL_HAT_RIGHT;
+        }
+        if (data[2] & 0x40) {
+            hat |= SDL_HAT_DOWN;
+        }
+        if (data[2] & 0x80) {
+            hat |= SDL_HAT_LEFT;
+        }
+        SDL_SendJoystickHat(timestamp, joystick, 0, hat);
+    }
+
+    if (ctx->last_state[3] != data[3]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data[3] & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data[3] & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_NORTH, ((data[3] & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_EAST, ((data[3] & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SOUTH, ((data[3] & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_WEST, ((data[3] & 0x80) != 0));
+    }
+
+    if (ctx->last_state[4] != data[4]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data[4] & 0x01) != 0));
+    }
+
+    axis = ((int)data[18] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, axis);
+    axis = ((int)data[19] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, axis);
+    axis = ((int)data[6] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, axis);
+    axis = ((int)data[7] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, axis);
+    axis = ((int)data[8] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, axis);
+    axis = ((int)data[9] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, axis);
+
+    // Buttons are mapped as axes in the order they appear in the button enumeration
+    if (ctx->has_analog_buttons) {
+        static int button_axis_offsets[] = {
+            24, // SDL_GAMEPAD_BUTTON_SOUTH
+            23, // SDL_GAMEPAD_BUTTON_EAST
+            25, // SDL_GAMEPAD_BUTTON_WEST
+            22, // SDL_GAMEPAD_BUTTON_NORTH
+            0,  // SDL_GAMEPAD_BUTTON_BACK
+            0,  // SDL_GAMEPAD_BUTTON_GUIDE
+            0,  // SDL_GAMEPAD_BUTTON_START
+            0,  // SDL_GAMEPAD_BUTTON_LEFT_STICK
+            0,  // SDL_GAMEPAD_BUTTON_RIGHT_STICK
+            20, // SDL_GAMEPAD_BUTTON_LEFT_SHOULDER
+            21, // SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER
+            14, // SDL_GAMEPAD_BUTTON_DPAD_UP
+            16, // SDL_GAMEPAD_BUTTON_DPAD_DOWN
+            17, // SDL_GAMEPAD_BUTTON_DPAD_LEFT
+            15, // SDL_GAMEPAD_BUTTON_DPAD_RIGHT
+        };
+        Uint8 i, axis_index = 6;
+
+        for (i = 0; i < SDL_arraysize(button_axis_offsets); ++i) {
+            int offset = button_axis_offsets[i];
+            if (!offset) {
+                // This button doesn't report as an axis
+                continue;
+            }
+
+            axis = ((int)data[offset] * 257) - 32768;
+            SDL_SendJoystickAxis(timestamp, joystick, axis_index, axis);
+            ++axis_index;
+        }
+    }
+
+    if (ctx->report_sensors) {
+        float sensor_data[3];
+
+        sensor_data[0] = HIDAPI_DriverPS3_ScaleAccel(LOAD16(data[41], data[42]));
+        sensor_data[1] = -HIDAPI_DriverPS3_ScaleAccel(LOAD16(data[45], data[46]));
+        sensor_data[2] = -HIDAPI_DriverPS3_ScaleAccel(LOAD16(data[43], data[44]));
+        SDL_SendJoystickSensor(timestamp, joystick, SDL_SENSOR_ACCEL, timestamp, sensor_data, SDL_arraysize(sensor_data));
+    }
+
+    SDL_memcpy(ctx->last_state, data, SDL_min(size, sizeof(ctx->last_state)));
+}
+
+static bool HIDAPI_DriverPS3_UpdateDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverPS3_Context *ctx = (SDL_DriverPS3_Context *)device->context;
+    SDL_Joystick *joystick = NULL;
+    Uint8 data[USB_PACKET_LENGTH];
+    int size;
+
+    if (device->num_joysticks > 0) {
+        joystick = SDL_GetJoystickFromID(device->joysticks[0]);
+    } else {
+        return false;
+    }
+
+    while ((size = SDL_hid_read_timeout(device->dev, data, sizeof(data), 0)) > 0) {
+#ifdef DEBUG_PS3_PROTOCOL
+        HIDAPI_DumpPacket("PS3 packet: size = %d", data, size);
+#endif
+        if (!joystick) {
+            continue;
+        }
+
+        if (size == 7) {
+            // Seen on a ShanWan PS2 -> PS3 USB converter
+            HIDAPI_DriverPS3_HandleMiniStatePacket(joystick, ctx, data, size);
+
+            // Wait for the first report to set the LED state after the controller stops blinking
+            if (!ctx->effects_updated) {
+                HIDAPI_DriverPS3_UpdateEffects(device);
+                ctx->effects_updated = true;
+            }
+            continue;
+        }
+
+        switch (data[0]) {
+        case k_EPS3ReportIdState:
+            if (data[1] == 0xFF) {
+                // Invalid data packet, ignore
+                break;
+            }
+            HIDAPI_DriverPS3_HandleStatePacket(joystick, ctx, data, size);
+
+            // Wait for the first report to set the LED state after the controller stops blinking
+            if (!ctx->effects_updated) {
+                HIDAPI_DriverPS3_UpdateEffects(device);
+                ctx->effects_updated = true;
+            }
+            break;
+        default:
+#ifdef DEBUG_JOYSTICK
+            SDL_Log("Unknown PS3 packet: 0x%.2x", data[0]);
+#endif
+            break;
+        }
+    }
+
+    if (size < 0) {
+        // Read error, device is disconnected
+        HIDAPI_JoystickDisconnected(device, device->joysticks[0]);
+    }
+    return (size >= 0);
+}
+
+static void HIDAPI_DriverPS3_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverPS3_Context *ctx = (SDL_DriverPS3_Context *)device->context;
+
+    ctx->joystick = NULL;
+}
+
+static void HIDAPI_DriverPS3_FreeDevice(SDL_HIDAPI_Device *device)
+{
+}
+
+SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverPS3 = {
+    SDL_HINT_JOYSTICK_HIDAPI_PS3,
+    true,
+    HIDAPI_DriverPS3_RegisterHints,
+    HIDAPI_DriverPS3_UnregisterHints,
+    HIDAPI_DriverPS3_IsEnabled,
+    HIDAPI_DriverPS3_IsSupportedDevice,
+    HIDAPI_DriverPS3_InitDevice,
+    HIDAPI_DriverPS3_GetDevicePlayerIndex,
+    HIDAPI_DriverPS3_SetDevicePlayerIndex,
+    HIDAPI_DriverPS3_UpdateDevice,
+    HIDAPI_DriverPS3_OpenJoystick,
+    HIDAPI_DriverPS3_RumbleJoystick,
+    HIDAPI_DriverPS3_RumbleJoystickTriggers,
+    HIDAPI_DriverPS3_GetJoystickCapabilities,
+    HIDAPI_DriverPS3_SetJoystickLED,
+    HIDAPI_DriverPS3_SendJoystickEffect,
+    HIDAPI_DriverPS3_SetJoystickSensorsEnabled,
+    HIDAPI_DriverPS3_CloseJoystick,
+    HIDAPI_DriverPS3_FreeDevice,
+};
+
+static bool HIDAPI_DriverPS3ThirdParty_IsEnabled(void)
+{
+    return SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_PS3,
+                              SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI,
+                                                 SDL_HIDAPI_DEFAULT));
+}
+
+static bool HIDAPI_DriverPS3ThirdParty_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)
+{
+    Uint8 data[USB_PACKET_LENGTH];
+    int size;
+
+    if (vendor_id == USB_VENDOR_LOGITECH &&
+        product_id == USB_PRODUCT_LOGITECH_CHILLSTREAM) {
+        return true;
+    }
+
+    if ((type == SDL_GAMEPAD_TYPE_PS3 && vendor_id != USB_VENDOR_SONY) ||
+        HIDAPI_SupportsPlaystationDetection(vendor_id, product_id)) {
+        if (device && device->dev) {
+            size = ReadFeatureReport(device->dev, 0x03, data, sizeof(data));
+            if (size == 8 && data[2] == 0x26) {
+                // Supported third party controller
+                return true;
+            } else {
+                return false;
+            }
+        } else {
+            // Might be supported by this driver, enumerate and find out
+            return true;
+        }
+    }
+    return false;
+}
+
+static bool HIDAPI_DriverPS3ThirdParty_InitDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverPS3_Context *ctx;
+
+    ctx = (SDL_DriverPS3_Context *)SDL_calloc(1, sizeof(*ctx));
+    if (!ctx) {
+        return false;
+    }
+    ctx->device = device;
+    if (device->vendor_id == USB_VENDOR_SWITCH && device->product_id == USB_PRODUCT_SWITCH_RETROBIT_CONTROLLER) {
+        ctx->has_analog_buttons = false;
+    } else {
+        ctx->has_analog_buttons = true;
+    }
+
+    device->context = ctx;
+
+    device->type = SDL_GAMEPAD_TYPE_PS3;
+
+    if (device->vendor_id == USB_VENDOR_LOGITECH &&
+        device->product_id == USB_PRODUCT_LOGITECH_CHILLSTREAM) {
+        HIDAPI_SetDeviceName(device, "Logitech ChillStream");
+    }
+
+    return HIDAPI_JoystickConnected(device, NULL);
+}
+
+static int HIDAPI_DriverPS3ThirdParty_GetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id)
+{
+    return -1;
+}
+
+static void HIDAPI_DriverPS3ThirdParty_SetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id, int player_index)
+{
+}
+
+static bool HIDAPI_DriverPS3ThirdParty_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverPS3_Context *ctx = (SDL_DriverPS3_Context *)device->context;
+
+    SDL_AssertJoysticksLocked();
+
+    ctx->joystick = joystick;
+    SDL_zeroa(ctx->last_state);
+
+    // Initialize the joystick capabilities
+    joystick->nbuttons = 11;
+    joystick->naxes = 6;
+    if (ctx->has_analog_buttons) {
+        joystick->naxes += 10;
+    }
+    joystick->nhats = 1;
+
+    if (device->vendor_id == USB_VENDOR_SWITCH && device->product_id == USB_PRODUCT_SWITCH_RETROBIT_CONTROLLER) {
+        // This is a wireless controller using a USB dongle
+        joystick->connection_state = SDL_JOYSTICK_CONNECTION_WIRELESS;
+    }
+
+    return true;
+}
+
+static bool HIDAPI_DriverPS3ThirdParty_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverPS3ThirdParty_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
+{
+    return SDL_Unsupported();
+}
+
+static Uint32 HIDAPI_DriverPS3ThirdParty_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    return 0;
+}
+
+static bool HIDAPI_DriverPS3ThirdParty_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverPS3ThirdParty_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *effect, int size)
+{
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverPS3ThirdParty_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, bool enabled)
+{
+    return SDL_Unsupported();
+}
+
+static void HIDAPI_DriverPS3ThirdParty_HandleStatePacket18(SDL_Joystick *joystick, SDL_DriverPS3_Context *ctx, Uint8 *data, int size)
+{
+    Sint16 axis;
+    Uint64 timestamp = SDL_GetTicksNS();
+
+    if (ctx->last_state[0] != data[0]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_WEST, ((data[0] & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SOUTH, ((data[0] & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_EAST, ((data[0] & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_NORTH, ((data[0] & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data[0] & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data[0] & 0x20) != 0));
+    }
+
+    if (ctx->last_state[1] != data[1]) {
+        Uint8 hat;
+
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK, ((data[1] & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data[1] & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data[1] & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_STICK, ((data[1] & 0x08) != 0));
+
+        switch (data[1] >> 4) {
+        case 0:
+            hat = SDL_HAT_UP;
+            break;
+        case 1:
+            hat = SDL_HAT_RIGHTUP;
+            break;
+        case 2:
+            hat = SDL_HAT_RIGHT;
+            break;
+        case 3:
+            hat = SDL_HAT_RIGHTDOWN;
+            break;
+        case 4:
+            hat = SDL_HAT_DOWN;
+            break;
+        case 5:
+            hat = SDL_HAT_LEFTDOWN;
+            break;
+        case 6:
+            hat = SDL_HAT_LEFT;
+            break;
+        case 7:
+            hat = SDL_HAT_LEFTUP;
+            break;
+        default:
+            hat = SDL_HAT_CENTERED;
+            break;
+        }
+        SDL_SendJoystickHat(timestamp, joystick, 0, hat);
+    }
+
+    axis = ((int)data[16] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, axis);
+    axis = ((int)data[17] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, axis);
+    axis = ((int)data[2] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, axis);
+    axis = ((int)data[3] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, axis);
+    axis = ((int)data[4] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, axis);
+    axis = ((int)data[5] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, axis);
+
+    // Buttons are mapped as axes in the order they appear in the button enumeration
+    if (ctx->has_analog_buttons) {
+        static int button_axis_offsets[] = {
+            12, // SDL_GAMEPAD_BUTTON_SOUTH
+            11, // SDL_GAMEPAD_BUTTON_EAST
+            13, // SDL_GAMEPAD_BUTTON_WEST
+            10, // SDL_GAMEPAD_BUTTON_NORTH
+            0,  // SDL_GAMEPAD_BUTTON_BACK
+            0,  // SDL_GAMEPAD_BUTTON_GUIDE
+            0,  // SDL_GAMEPAD_BUTTON_START
+            0,  // SDL_GAMEPAD_BUTTON_LEFT_STICK
+            0,  // SDL_GAMEPAD_BUTTON_RIGHT_STICK
+            14, // SDL_GAMEPAD_BUTTON_LEFT_SHOULDER
+            15, // SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER
+            8,  // SDL_GAMEPAD_BUTTON_DPAD_UP
+            9,  // SDL_GAMEPAD_BUTTON_DPAD_DOWN
+            7,  // SDL_GAMEPAD_BUTTON_DPAD_LEFT
+            6,  // SDL_GAMEPAD_BUTTON_DPAD_RIGHT
+        };
+        Uint8 i, axis_index = 6;
+
+        for (i = 0; i < SDL_arraysize(button_axis_offsets); ++i) {
+            int offset = button_axis_offsets[i];
+            if (!offset) {
+                // This button doesn't report as an axis
+                continue;
+            }
+
+            axis = ((int)data[offset] * 257) - 32768;
+            SDL_SendJoystickAxis(timestamp, joystick, axis_index, axis);
+            ++axis_index;
+        }
+    }
+
+    SDL_memcpy(ctx->last_state, data, SDL_min(size, sizeof(ctx->last_state)));
+}
+
+static void HIDAPI_DriverPS3ThirdParty_HandleStatePacket19(SDL_Joystick *joystick, SDL_DriverPS3_Context *ctx, Uint8 *data, int size)
+{
+    Sint16 axis;
+    Uint64 timestamp = SDL_GetTicksNS();
+
+    if (ctx->last_state[0] != data[0]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_WEST, ((data[0] & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SOUTH, ((data[0] & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_EAST, ((data[0] & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_NORTH, ((data[0] & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data[0] & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data[0] & 0x20) != 0));
+    }
+
+    if (ctx->last_state[1] != data[1]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK, ((data[1] & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data[1] & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data[1] & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_STICK, ((data[1] & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data[1] & 0x10) != 0));
+    }
+
+    if (ctx->device->vendor_id == USB_VENDOR_SAITEK && ctx->device->product_id == USB_PRODUCT_SAITEK_CYBORG_V3) {
+        // Cyborg V.3 Rumble Pad doesn't set the dpad bits as expected, so use the axes instead
+        Uint8 hat = 0;
+
+        if (data[7]) {
+            hat |= SDL_HAT_RIGHT;
+        }
+        if (data[8]) {
+            hat |= SDL_HAT_LEFT;
+        }
+        if (data[9]) {
+            hat |= SDL_HAT_UP;
+        }
+        if (data[10]) {
+            hat |= SDL_HAT_DOWN;
+        }
+        SDL_SendJoystickHat(timestamp, joystick, 0, hat);
+    } else {
+        if (ctx->last_state[2] != data[2]) {
+            Uint8 hat;
+
+            switch (data[2] & 0x0f) {
+            case 0:
+                hat = SDL_HAT_UP;
+                break;
+            case 1:
+                hat = SDL_HAT_RIGHTUP;
+                break;
+            case 2:
+                hat = SDL_HAT_RIGHT;
+                break;
+            case 3:
+                hat = SDL_HAT_RIGHTDOWN;
+                break;
+            case 4:
+                hat = SDL_HAT_DOWN;
+                break;
+            case 5:
+                hat = SDL_HAT_LEFTDOWN;
+                break;
+            case 6:
+                hat = SDL_HAT_LEFT;
+                break;
+            case 7:
+                hat = SDL_HAT_LEFTUP;
+                break;
+            default:
+                hat = SDL_HAT_CENTERED;
+                break;
+            }
+            SDL_SendJoystickHat(timestamp, joystick, 0, hat);
+        }
+    }
+
+    if (data[0] & 0x40) {
+        axis = 32767;
+    } else {
+        axis = ((int)data[17] * 257) - 32768;
+    }
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, axis);
+    if (data[0] & 0x80) {
+        axis = 32767;
+    } else {
+        axis = ((int)data[18] * 257) - 32768;
+    }
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, axis);
+    axis = ((int)data[3] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, axis);
+    axis = ((int)data[4] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, axis);
+    axis = ((int)data[5] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, axis);
+    axis = ((int)data[6] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, axis);
+
+    // Buttons are mapped as axes in the order they appear in the button enumeration
+    if (ctx->has_analog_buttons) {
+        static int button_axis_offsets[] = {
+            13, // SDL_GAMEPAD_BUTTON_SOUTH
+            12, // SDL_GAMEPAD_BUTTON_EAST
+            14, // SDL_GAMEPAD_BUTTON_WEST
+            11, // SDL_GAMEPAD_BUTTON_NORTH
+            0,  // SDL_GAMEPAD_BUTTON_BACK
+            0,  // SDL_GAMEPAD_BUTTON_GUIDE
+            0,  // SDL_GAMEPAD_BUTTON_START
+            0,  // SDL_GAMEPAD_BUTTON_LEFT_STICK
+            0,  // SDL_GAMEPAD_BUTTON_RIGHT_STICK
+            15, // SDL_GAMEPAD_BUTTON_LEFT_SHOULDER
+            16, // SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER
+            9,  // SDL_GAMEPAD_BUTTON_DPAD_UP
+            10, // SDL_GAMEPAD_BUTTON_DPAD_DOWN
+            8,  // SDL_GAMEPAD_BUTTON_DPAD_LEFT
+            7,  // SDL_GAMEPAD_BUTTON_DPAD_RIGHT
+        };
+        Uint8 i, axis_index = 6;
+
+        for (i = 0; i < SDL_arraysize(button_axis_offsets); ++i) {
+            int offset = button_axis_offsets[i];
+            if (!offset) {
+                // This button doesn't report as an axis
+                continue;
+            }
+
+            axis = ((int)data[offset] * 257) - 32768;
+            SDL_SendJoystickAxis(timestamp, joystick, axis_index, axis);
+            ++axis_index;
+        }
+    }
+
+    SDL_memcpy(ctx->last_state, data, SDL_min(size, sizeof(ctx->last_state)));
+}
+
+static bool HIDAPI_DriverPS3ThirdParty_UpdateDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverPS3_Context *ctx = (SDL_DriverPS3_Context *)device->context;
+    SDL_Joystick *joystick = NULL;
+    Uint8 data[USB_PACKET_LENGTH];
+    int size;
+
+    if (device->num_joysticks > 0) {
+        joystick = SDL_GetJoystickFromID(device->joysticks[0]);
+    } else {
+        return false;
+    }
+
+    while ((size = SDL_hid_read_timeout(device->dev, data, sizeof(data), 0)) > 0) {
+#ifdef DEBUG_PS3_PROTOCOL
+        HIDAPI_DumpPacket("PS3 packet: size = %d", data, size);
+#endif
+        if (!joystick) {
+            continue;
+        }
+
+        if (size >= 19) {
+            HIDAPI_DriverPS3ThirdParty_HandleStatePacket19(joystick, ctx, data, size);
+        } else if (size == 18) {
+            // This packet format was seen with the Logitech ChillStream
+            HIDAPI_DriverPS3ThirdParty_HandleStatePacket18(joystick, ctx, data, size);
+        } else {
+#ifdef DEBUG_JOYSTICK
+            SDL_Log("Unknown PS3 packet, size %d", size);
+#endif
+        }
+    }
+
+    if (size < 0) {
+        // Read error, device is disconnected
+        HIDAPI_JoystickDisconnected(device, device->joysticks[0]);
+    }
+    return (size >= 0);
+}
+
+static void HIDAPI_DriverPS3ThirdParty_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverPS3_Context *ctx = (SDL_DriverPS3_Context *)device->context;
+
+    ctx->joystick = NULL;
+}
+
+static void HIDAPI_DriverPS3ThirdParty_FreeDevice(SDL_HIDAPI_Device *device)
+{
+}
+
+SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverPS3ThirdParty = {
+    SDL_HINT_JOYSTICK_HIDAPI_PS3,
+    true,
+    HIDAPI_DriverPS3_RegisterHints,
+    HIDAPI_DriverPS3_UnregisterHints,
+    HIDAPI_DriverPS3ThirdParty_IsEnabled,
+    HIDAPI_DriverPS3ThirdParty_IsSupportedDevice,
+    HIDAPI_DriverPS3ThirdParty_InitDevice,
+    HIDAPI_DriverPS3ThirdParty_GetDevicePlayerIndex,
+    HIDAPI_DriverPS3ThirdParty_SetDevicePlayerIndex,
+    HIDAPI_DriverPS3ThirdParty_UpdateDevice,
+    HIDAPI_DriverPS3ThirdParty_OpenJoystick,
+    HIDAPI_DriverPS3ThirdParty_RumbleJoystick,
+    HIDAPI_DriverPS3ThirdParty_RumbleJoystickTriggers,
+    HIDAPI_DriverPS3ThirdParty_GetJoystickCapabilities,
+    HIDAPI_DriverPS3ThirdParty_SetJoystickLED,
+    HIDAPI_DriverPS3ThirdParty_SendJoystickEffect,
+    HIDAPI_DriverPS3ThirdParty_SetJoystickSensorsEnabled,
+    HIDAPI_DriverPS3ThirdParty_CloseJoystick,
+    HIDAPI_DriverPS3ThirdParty_FreeDevice,
+};
+
+static bool HIDAPI_DriverPS3_UpdateRumbleSonySixaxis(SDL_HIDAPI_Device *device);
+static bool HIDAPI_DriverPS3_UpdateLEDsSonySixaxis(SDL_HIDAPI_Device *device);
+
+static void HIDAPI_DriverPS3SonySixaxis_RegisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_PS3_SIXAXIS_DRIVER, callback, userdata);
+}
+
+static void HIDAPI_DriverPS3SonySixaxis_UnregisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_PS3_SIXAXIS_DRIVER, callback, userdata);
+}
+
+static bool HIDAPI_DriverPS3SonySixaxis_IsEnabled(void)
+{
+#ifdef SDL_PLATFORM_WIN32
+    return SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_PS3_SIXAXIS_DRIVER, false);
+#else
+    return false;
+#endif
+}
+
+static bool HIDAPI_DriverPS3SonySixaxis_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_SONY && product_id == USB_PRODUCT_SONY_DS3) {
+        return true;
+    }
+    return false;
+}
+
+static bool HIDAPI_DriverPS3SonySixaxis_InitDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverPS3_Context *ctx;
+
+    ctx = (SDL_DriverPS3_Context *)SDL_calloc(1, sizeof(*ctx));
+    if (!ctx) {
+        return false;
+    }
+    ctx->device = device;
+    ctx->has_analog_buttons = true;
+
+    device->context = ctx;
+
+    Uint8 data[USB_PACKET_LENGTH];
+
+    int size = ReadFeatureReport(device->dev, 0xf2, data, sizeof(data));
+    if (size < 0) {
+        SDL_LogDebug(SDL_LOG_CATEGORY_INPUT,
+                     "HIDAPI_DriverPS3SonySixaxis_InitDevice(): Couldn't read feature report 0xf2. Trying again with 0x0.");
+        SDL_zeroa(data);
+        size = ReadFeatureReport(device->dev, 0x00, data, sizeof(data));
+        if (size < 0) {
+            SDL_LogDebug(SDL_LOG_CATEGORY_INPUT,
+                         "HIDAPI_DriverPS3SonySixaxis_InitDevice(): Couldn't read feature report 0x00.");
+            return false;
+        }
+#ifdef DEBUG_PS3_PROTOCOL
+        HIDAPI_DumpPacket("PS3 0x0 packet: size = %d", data, size);
+#endif
+    }
+#ifdef DEBUG_PS3_PROTOCOL
+    HIDAPI_DumpPacket("PS3 0xF2 packet: size = %d", data, size);
+#endif
+
+    device->type = SDL_GAMEPAD_TYPE_PS3;
+    HIDAPI_SetDeviceName(device, "PS3 Controller");
+
+    return HIDAPI_JoystickConnected(device, NULL);
+}
+
+static int HIDAPI_DriverPS3SonySixaxis_GetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id)
+{
+    return -1;
+}
+
+static void HIDAPI_DriverPS3SonySixaxis_SetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id, int player_index)
+{
+    SDL_DriverPS3_Context *ctx = (SDL_DriverPS3_Context *)device->context;
+
+    if (!ctx) {
+        return;
+    }
+
+    ctx->player_index = player_index;
+
+    // This will set the new LED state based on the new player index
+    HIDAPI_DriverPS3_UpdateLEDsSonySixaxis(device);
+}
+
+static bool HIDAPI_DriverPS3SonySixaxis_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverPS3_Context *ctx = (SDL_DriverPS3_Context *)device->context;
+
+    SDL_AssertJoysticksLocked();
+
+    ctx->joystick = joystick;
+    ctx->effects_updated = false;
+    ctx->rumble_left = 0;
+    ctx->rumble_right = 0;
+    SDL_zeroa(ctx->last_state);
+
+    // Initialize player index (needed for setting LEDs)
+    ctx->player_index = SDL_GetJoystickPlayerIndex(joystick);
+
+    // Initialize the joystick capabilities
+    joystick->nbuttons = 11;
+    joystick->naxes = 6;
+    if (ctx->has_analog_buttons) {
+        joystick->naxes += 10;
+    }
+    joystick->nhats = 1;
+
+    SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_ACCEL, 100.0f);
+
+    return true;
+}
+
+static bool HIDAPI_DriverPS3SonySixaxis_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+    SDL_DriverPS3_Context *ctx = (SDL_DriverPS3_Context *)device->context;
+
+    ctx->rumble_left = (low_frequency_rumble >> 8);
+    ctx->rumble_right = (high_frequency_rumble >> 8);
+
+    return HIDAPI_DriverPS3_UpdateRumbleSonySixaxis(device);
+}
+
+static bool HIDAPI_DriverPS3SonySixaxis_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
+{
+    return SDL_Unsupported();
+}
+
+static Uint32 HIDAPI_DriverPS3SonySixaxis_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    return 0;
+}
+
+static bool HIDAPI_DriverPS3SonySixaxis_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverPS3SonySixaxis_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *effect, int size)
+{
+    Uint8 data[49];
+    int report_size;
+
+    SDL_zeroa(data);
+
+    data[0] = k_EPS3SonySixaxisReportIdEffects;
+    report_size = sizeof(data);
+
+    // No offset with Sony sixaxis.sys driver
+    SDL_memcpy(&data, effect, SDL_min(sizeof(data), (size_t)size));
+
+    if (SDL_HIDAPI_SendRumble(device, data, report_size) != report_size) {
+        return SDL_SetError("Couldn't send rumble packet");
+    }
+    return true;
+}
+
+static bool HIDAPI_DriverPS3SonySixaxis_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, bool enabled)
+{
+    SDL_DriverPS3_Context *ctx = (SDL_DriverPS3_Context *)device->context;
+
+    ctx->report_sensors = enabled;
+
+    return true;
+}
+
+static void HIDAPI_DriverPS3SonySixaxis_HandleStatePacket(SDL_Joystick *joystick, SDL_DriverPS3_Context *ctx, Uint8 *data, int size)
+{
+    Sint16 axis;
+    Uint64 timestamp = SDL_GetTicksNS();
+
+    if (ctx->last_state[2] != data[2]) {
+        Uint8 hat = 0;
+
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK, ((data[2] & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data[2] & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_STICK, ((data[2] & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data[2] & 0x08) != 0));
+
+        if (data[2] & 0x10) {
+            hat |= SDL_HAT_UP;
+        }
+        if (data[2] & 0x20) {
+            hat |= SDL_HAT_RIGHT;
+        }
+        if (data[2] & 0x40) {
+            hat |= SDL_HAT_DOWN;
+        }
+        if (data[2] & 0x80) {
+            hat |= SDL_HAT_LEFT;
+        }
+        SDL_SendJoystickHat(timestamp, joystick, 0, hat);
+    }
+
+    if (ctx->last_state[3] != data[3]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data[3] & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data[3] & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_NORTH, ((data[3] & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_EAST, ((data[3] & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SOUTH, ((data[3] & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_WEST, ((data[3] & 0x80) != 0));
+    }
+
+    if (ctx->last_state[4] != data[4]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data[4] & 0x01) != 0));
+    }
+
+    axis = ((int)data[18] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, axis);
+    axis = ((int)data[19] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, axis);
+    axis = ((int)data[6] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, axis);
+    axis = ((int)data[7] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, axis);
+    axis = ((int)data[8] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, axis);
+    axis = ((int)data[9] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, axis);
+
+    // Buttons are mapped as axes in the order they appear in the button enumeration
+    if (ctx->has_analog_buttons) {
+        static int button_axis_offsets[] = {
+            24, // SDL_GAMEPAD_BUTTON_SOUTH
+            23, // SDL_GAMEPAD_BUTTON_EAST
+            25, // SDL_GAMEPAD_BUTTON_WEST
+            22, // SDL_GAMEPAD_BUTTON_NORTH
+            0,  // SDL_GAMEPAD_BUTTON_BACK
+            0,  // SDL_GAMEPAD_BUTTON_GUIDE
+            0,  // SDL_GAMEPAD_BUTTON_START
+            0,  // SDL_GAMEPAD_BUTTON_LEFT_STICK
+            0,  // SDL_GAMEPAD_BUTTON_RIGHT_STICK
+            20, // SDL_GAMEPAD_BUTTON_LEFT_SHOULDER
+            21, // SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER
+            14, // SDL_GAMEPAD_BUTTON_DPAD_UP
+            16, // SDL_GAMEPAD_BUTTON_DPAD_DOWN
+            17, // SDL_GAMEPAD_BUTTON_DPAD_LEFT
+            15, // SDL_GAMEPAD_BUTTON_DPAD_RIGHT
+        };
+        Uint8 i, axis_index = 6;
+
+        for (i = 0; i < SDL_arraysize(button_axis_offsets); ++i) {
+            int offset = button_axis_offsets[i];
+            if (!offset) {
+                // This button doesn't report as an axis
+                continue;
+            }
+
+            axis = ((int)data[offset] * 257) - 32768;
+            SDL_SendJoystickAxis(timestamp, joystick, axis_index, axis);
+            ++axis_index;
+        }
+    }
+
+    if (ctx->report_sensors) {
+        float sensor_data[3];
+
+        sensor_data[0] = HIDAPI_DriverPS3_ScaleAccel(LOAD16(data[41], data[42]));
+        sensor_data[1] = -HIDAPI_DriverPS3_ScaleAccel(LOAD16(data[45], data[46]));
+        sensor_data[2] = -HIDAPI_DriverPS3_ScaleAccel(LOAD16(data[43], data[44]));
+        SDL_SendJoystickSensor(timestamp, joystick, SDL_SENSOR_ACCEL, timestamp, sensor_data, SDL_arraysize(sensor_data));
+    }
+
+    SDL_memcpy(ctx->last_state, data, SDL_min(size, sizeof(ctx->last_state)));
+}
+
+static bool HIDAPI_DriverPS3SonySixaxis_UpdateDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverPS3_Context *ctx = (SDL_DriverPS3_Context *)device->context;
+    SDL_Joystick *joystick = NULL;
+    Uint8 data[USB_PACKET_LENGTH];
+    int size;
+
+    if (device->num_joysticks > 0) {
+        joystick = SDL_GetJoystickFromID(device->joysticks[0]);
+    } else {
+        return false;
+    }
+
+    if (!joystick) {
+        return false;
+    }
+
+    // With sixaxis.sys driver we need to use hid_get_feature_report instead of hid_read
+    size = ReadFeatureReport(device->dev, 0x0, data, sizeof(data));
+    if (size < 0) {
+        SDL_LogDebug(SDL_LOG_CATEGORY_INPUT,
+                     "HIDAPI_DriverPS3SonySixaxis_UpdateDevice(): Couldn't read feature report 0x00");
+        return false;
+    }
+
+    switch (data[0]) {
+    case k_EPS3SonySixaxisReportIdState:
+        HIDAPI_DriverPS3SonySixaxis_HandleStatePacket(joystick, ctx, &data[1], size - 1); // report data starts in data[1]
+
+        // Wait for the first report to set the LED state after the controller stops blinking
+        if (!ctx->effects_updated) {
+            HIDAPI_DriverPS3_UpdateLEDsSonySixaxis(device);
+            ctx->effects_updated = true;
+        }
+
+        break;
+    default:
+#ifdef DEBUG_JOYSTICK
+        SDL_Log("Unknown PS3 packet: 0x%.2x", data[0]);
+#endif
+        break;
+    }
+
+    if (size < 0) {
+        // Read error, device is disconnected
+        HIDAPI_JoystickDisconnected(device, device->joysticks[0]);
+    }
+    return (size >= 0);
+}
+
+static void HIDAPI_DriverPS3SonySixaxis_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverPS3_Context *ctx = (SDL_DriverPS3_Context *)device->context;
+
+    ctx->joystick = NULL;
+}
+
+static void HIDAPI_DriverPS3SonySixaxis_FreeDevice(SDL_HIDAPI_Device *device)
+{
+}
+
+static bool HIDAPI_DriverPS3_UpdateRumbleSonySixaxis(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverPS3_Context *ctx = (SDL_DriverPS3_Context *)device->context;
+
+    Uint8 effects[] = {
+        0x0,                           // Report Id
+        k_EPS3SixaxisCommandSetMotors, // 2 = Set Motors
+        0x00, 0x00, 0x00,              // padding
+        0xff,                          // Small Motor duration - 0xff is forever
+        0x00,                          // Small Motor off/on (0 or 1)
+        0xff,                          // Large Motor duration - 0xff is forever
+        0x00                           // Large Motor force (0 to 255)
+    };
+
+    effects[6] = ctx->rumble_right ? 1 : 0; // Small motor
+    effects[8] = ctx->rumble_left;          // Large motor
+
+    return HIDAPI_DriverPS3SonySixaxis_SendJoystickEffect(device, ctx->joystick, effects, sizeof(effects));
+}
+
+static bool HIDAPI_DriverPS3_UpdateLEDsSonySixaxis(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverPS3_Context *ctx = (SDL_DriverPS3_Context *)device->context;
+
+    Uint8 effects[] = {
+        0x0,                         // Report Id
+        k_EPS3SixaxisCommandSetLEDs, // 1 = Set LEDs
+        0x00, 0x00, 0x00,            // padding
+        0x00, 0x00, 0x00, 0x00       // LED #4, LED #3, LED #2, LED #1 (0 = Off, 1 = On, 2 = Flashing)
+    };
+
+    // Turn on LED light on DS3 Controller for relevant player (player_index 0 lights up LED #1, player_index 1 lights up LED #2, etc)
+    if (ctx->player_index < 4) {
+        effects[8 - ctx->player_index] = 1;
+    }
+
+    return HIDAPI_DriverPS3SonySixaxis_SendJoystickEffect(device, ctx->joystick, effects, sizeof(effects));
+}
+
+SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverPS3SonySixaxis = {
+    SDL_HINT_JOYSTICK_HIDAPI_PS3_SIXAXIS_DRIVER,
+    true,
+    HIDAPI_DriverPS3SonySixaxis_RegisterHints,
+    HIDAPI_DriverPS3SonySixaxis_UnregisterHints,
+    HIDAPI_DriverPS3SonySixaxis_IsEnabled,
+    HIDAPI_DriverPS3SonySixaxis_IsSupportedDevice,
+    HIDAPI_DriverPS3SonySixaxis_InitDevice,
+    HIDAPI_DriverPS3SonySixaxis_GetDevicePlayerIndex,
+    HIDAPI_DriverPS3SonySixaxis_SetDevicePlayerIndex,
+    HIDAPI_DriverPS3SonySixaxis_UpdateDevice,
+    HIDAPI_DriverPS3SonySixaxis_OpenJoystick,
+    HIDAPI_DriverPS3SonySixaxis_RumbleJoystick,
+    HIDAPI_DriverPS3SonySixaxis_RumbleJoystickTriggers,
+    HIDAPI_DriverPS3SonySixaxis_GetJoystickCapabilities,
+    HIDAPI_DriverPS3SonySixaxis_SetJoystickLED,
+    HIDAPI_DriverPS3SonySixaxis_SendJoystickEffect,
+    HIDAPI_DriverPS3SonySixaxis_SetJoystickSensorsEnabled,
+    HIDAPI_DriverPS3SonySixaxis_CloseJoystick,
+    HIDAPI_DriverPS3SonySixaxis_FreeDevice,
+};
+
+#endif // SDL_JOYSTICK_HIDAPI_PS3
+
+#endif // SDL_JOYSTICK_HIDAPI
diff --git a/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_ps4.c b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_ps4.c
new file mode 100644
index 0000000..7404bf2
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_ps4.c
@@ -0,0 +1,1390 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+/* This driver supports both simplified reports and the extended input reports enabled by Steam.
+   Code and logic contributed by Valve Corporation under the SDL zlib license.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI
+
+#include "../../SDL_hints_c.h"
+#include "../SDL_sysjoystick.h"
+#include "SDL_hidapijoystick_c.h"
+#include "SDL_hidapi_rumble.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI_PS4
+
+// Define this if you want to log all packets from the controller
+#if 0
+#define DEBUG_PS4_PROTOCOL
+#endif
+
+// Define this if you want to log calibration data
+#if 0
+#define DEBUG_PS4_CALIBRATION
+#endif
+
+#define BLUETOOTH_DISCONNECT_TIMEOUT_MS 500
+
+#define LOAD16(A, B)       (Sint16)((Uint16)(A) | (((Uint16)(B)) << 8))
+#define LOAD32(A, B, C, D) ((((Uint32)(A)) << 0) |  \
+                            (((Uint32)(B)) << 8) |  \
+                            (((Uint32)(C)) << 16) | \
+                            (((Uint32)(D)) << 24))
+
+enum
+{
+    SDL_GAMEPAD_BUTTON_PS4_TOUCHPAD = 11
+};
+
+typedef enum
+{
+    k_EPS4ReportIdUsbState = 1,
+    k_EPS4ReportIdUsbEffects = 5,
+    k_EPS4ReportIdBluetoothState1 = 17,
+    k_EPS4ReportIdBluetoothState2 = 18,
+    k_EPS4ReportIdBluetoothState3 = 19,
+    k_EPS4ReportIdBluetoothState4 = 20,
+    k_EPS4ReportIdBluetoothState5 = 21,
+    k_EPS4ReportIdBluetoothState6 = 22,
+    k_EPS4ReportIdBluetoothState7 = 23,
+    k_EPS4ReportIdBluetoothState8 = 24,
+    k_EPS4ReportIdBluetoothState9 = 25,
+    k_EPS4ReportIdBluetoothEffects = 17,
+    k_EPS4ReportIdDisconnectMessage = 226,
+} EPS4ReportId;
+
+typedef enum
+{
+    k_ePS4FeatureReportIdGyroCalibration_USB = 0x02,
+    k_ePS4FeatureReportIdCapabilities = 0x03,
+    k_ePS4FeatureReportIdGyroCalibration_BT = 0x05,
+    k_ePS4FeatureReportIdSerialNumber = 0x12,
+} EPS4FeatureReportID;
+
+typedef struct
+{
+    Uint8 ucLeftJoystickX;
+    Uint8 ucLeftJoystickY;
+    Uint8 ucRightJoystickX;
+    Uint8 ucRightJoystickY;
+    Uint8 rgucButtonsHatAndCounter[3];
+    Uint8 ucTriggerLeft;
+    Uint8 ucTriggerRight;
+    Uint8 rgucTimestamp[2];
+    Uint8 _rgucPad0[1];
+    Uint8 rgucGyroX[2];
+    Uint8 rgucGyroY[2];
+    Uint8 rgucGyroZ[2];
+    Uint8 rgucAccelX[2];
+    Uint8 rgucAccelY[2];
+    Uint8 rgucAccelZ[2];
+    Uint8 _rgucPad1[5];
+    Uint8 ucBatteryLevel;
+    Uint8 _rgucPad2[4];
+    Uint8 ucTouchpadCounter1;
+    Uint8 rgucTouchpadData1[3];
+    Uint8 ucTouchpadCounter2;
+    Uint8 rgucTouchpadData2[3];
+} PS4StatePacket_t;
+
+typedef struct
+{
+    Uint8 ucRumbleRight;
+    Uint8 ucRumbleLeft;
+    Uint8 ucLedRed;
+    Uint8 ucLedGreen;
+    Uint8 ucLedBlue;
+    Uint8 ucLedDelayOn;
+    Uint8 ucLedDelayOff;
+    Uint8 _rgucPad0[8];
+    Uint8 ucVolumeLeft;
+    Uint8 ucVolumeRight;
+    Uint8 ucVolumeMic;
+    Uint8 ucVolumeSpeaker;
+} DS4EffectsState_t;
+
+typedef struct
+{
+    Sint16 bias;
+    float scale;
+} IMUCalibrationData;
+
+/* Rumble hint mode:
+ * "0": enhanced features are never used
+ * "1": enhanced features are always used
+ * "auto": enhanced features are advertised to the application, but SDL doesn't touch the controller state unless the application explicitly requests it.
+ */
+typedef enum
+{
+    PS4_ENHANCED_REPORT_HINT_OFF,
+    PS4_ENHANCED_REPORT_HINT_ON,
+    PS4_ENHANCED_REPORT_HINT_AUTO
+} HIDAPI_PS4_EnhancedReportHint;
+
+typedef struct
+{
+    SDL_HIDAPI_Device *device;
+    SDL_Joystick *joystick;
+    bool is_dongle;
+    bool is_nacon_dongle;
+    bool official_controller;
+    bool sensors_supported;
+    bool lightbar_supported;
+    bool vibration_supported;
+    bool touchpad_supported;
+    bool effects_supported;
+    HIDAPI_PS4_EnhancedReportHint enhanced_report_hint;
+    bool enhanced_reports;
+    bool enhanced_mode;
+    bool enhanced_mode_available;
+    Uint8 report_interval;
+    bool report_sensors;
+    bool report_touchpad;
+    bool report_battery;
+    bool hardware_calibration;
+    IMUCalibrationData calibration[6];
+    Uint64 last_packet;
+    int player_index;
+    Uint8 rumble_left;
+    Uint8 rumble_right;
+    bool color_set;
+    Uint8 led_red;
+    Uint8 led_green;
+    Uint8 led_blue;
+    Uint16 gyro_numerator;
+    Uint16 gyro_denominator;
+    Uint16 accel_numerator;
+    Uint16 accel_denominator;
+    Uint64 sensor_ticks;
+    Uint16 last_tick;
+    Uint16 valid_crc_packets; // wrapping counter
+    PS4StatePacket_t last_state;
+} SDL_DriverPS4_Context;
+
+static bool HIDAPI_DriverPS4_InternalSendJoystickEffect(SDL_DriverPS4_Context *ctx, const void *effect, int size, bool application_usage);
+
+static void HIDAPI_DriverPS4_RegisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_PS4, callback, userdata);
+}
+
+static void HIDAPI_DriverPS4_UnregisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_PS4, callback, userdata);
+}
+
+static bool HIDAPI_DriverPS4_IsEnabled(void)
+{
+    return SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_PS4, SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI, SDL_HIDAPI_DEFAULT));
+}
+
+static int ReadFeatureReport(SDL_hid_device *dev, Uint8 report_id, Uint8 *report, size_t length)
+{
+    SDL_memset(report, 0, length);
+    report[0] = report_id;
+    return SDL_hid_get_feature_report(dev, report, length);
+}
+
+static bool HIDAPI_DriverPS4_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)
+{
+    Uint8 data[USB_PACKET_LENGTH];
+    int size;
+
+    if (type == SDL_GAMEPAD_TYPE_PS4) {
+        return true;
+    }
+
+    if (HIDAPI_SupportsPlaystationDetection(vendor_id, product_id)) {
+        if (device && device->dev) {
+            size = ReadFeatureReport(device->dev, k_ePS4FeatureReportIdCapabilities, data, sizeof(data));
+            if (size == 48 && data[2] == 0x27) {
+                // Supported third party controller
+                return true;
+            } else {
+                return false;
+            }
+        } else {
+            // Might be supported by this driver, enumerate and find out
+            return true;
+        }
+    }
+
+    return false;
+}
+
+static void SetLedsForPlayerIndex(DS4EffectsState_t *effects, int player_index)
+{
+    /* This list is the same as what hid-sony.c uses in the Linux kernel.
+       The first 4 values correspond to what the PS4 assigns.
+    */
+    static const Uint8 colors[7][3] = {
+        { 0x00, 0x00, 0x40 }, // Blue
+        { 0x40, 0x00, 0x00 }, // Red
+        { 0x00, 0x40, 0x00 }, // Green
+        { 0x20, 0x00, 0x20 }, // Pink
+        { 0x02, 0x01, 0x00 }, // Orange
+        { 0x00, 0x01, 0x01 }, // Teal
+        { 0x01, 0x01, 0x01 }  // White
+    };
+
+    if (player_index >= 0) {
+        player_index %= SDL_arraysize(colors);
+    } else {
+        player_index = 0;
+    }
+
+    effects->ucLedRed = colors[player_index][0];
+    effects->ucLedGreen = colors[player_index][1];
+    effects->ucLedBlue = colors[player_index][2];
+}
+
+static bool ReadWiredSerial(SDL_HIDAPI_Device *device, char *serial, size_t serial_size)
+{
+    Uint8 data[USB_PACKET_LENGTH];
+    int size;
+
+    size = ReadFeatureReport(device->dev, k_ePS4FeatureReportIdSerialNumber, data, sizeof(data));
+    if (size >= 7 && (data[1] || data[2] || data[3] || data[4] || data[5] || data[6])) {
+        (void)SDL_snprintf(serial, serial_size, "%.2x-%.2x-%.2x-%.2x-%.2x-%.2x",
+                           data[6], data[5], data[4], data[3], data[2], data[1]);
+        return true;
+    }
+    return false;
+}
+
+static bool HIDAPI_DriverPS4_InitDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverPS4_Context *ctx;
+    Uint8 data[USB_PACKET_LENGTH];
+    int size;
+    char serial[18];
+    SDL_JoystickType joystick_type = SDL_JOYSTICK_TYPE_GAMEPAD;
+
+    ctx = (SDL_DriverPS4_Context *)SDL_calloc(1, sizeof(*ctx));
+    if (!ctx) {
+        return false;
+    }
+    ctx->device = device;
+
+    ctx->gyro_numerator = 1;
+    ctx->gyro_denominator = 16;
+    ctx->accel_numerator = 1;
+    ctx->accel_denominator = 8192;
+
+    device->context = ctx;
+
+    if (device->serial && SDL_strlen(device->serial) == 12) {
+        int i, j;
+
+        j = -1;
+        for (i = 0; i < 12; i += 2) {
+            j += 1;
+            SDL_memmove(&serial[j], &device->serial[i], 2);
+            j += 2;
+            serial[j] = '-';
+        }
+        serial[j] = '\0';
+    } else {
+        serial[0] = '\0';
+    }
+
+    // Check for type of connection
+    ctx->is_dongle = (device->vendor_id == USB_VENDOR_SONY && device->product_id == USB_PRODUCT_SONY_DS4_DONGLE);
+    if (ctx->is_dongle) {
+        ReadWiredSerial(device, serial, sizeof(serial));
+        ctx->enhanced_reports = true;
+    } else if (device->vendor_id == USB_VENDOR_SONY && device->product_id == USB_PRODUCT_SONY_DS4_STRIKEPAD) {
+        ctx->enhanced_reports = true;
+
+    } else if (device->vendor_id == USB_VENDOR_SONY) {
+        if (device->is_bluetooth) {
+            // Read a report to see if we're in enhanced mode
+            size = SDL_hid_read_timeout(device->dev, data, sizeof(data), 16);
+#ifdef DEBUG_PS4_PROTOCOL
+            if (size > 0) {
+                HIDAPI_DumpPacket("PS4 first packet: size = %d", data, size);
+            } else {
+                SDL_Log("PS4 first packet: size = %d", size);
+            }
+#endif
+            if (size > 0 &&
+                data[0] >= k_EPS4ReportIdBluetoothState1 &&
+                data[0] <= k_EPS4ReportIdBluetoothState9) {
+                ctx->enhanced_reports = true;
+            }
+        } else {
+            ReadWiredSerial(device, serial, sizeof(serial));
+            ctx->enhanced_reports = true;
+        }
+    } else {
+        // Third party controllers appear to all be wired
+        ctx->enhanced_reports = true;
+    }
+
+    if (device->vendor_id == USB_VENDOR_SONY) {
+        ctx->official_controller = true;
+        ctx->sensors_supported = true;
+        ctx->lightbar_supported = true;
+        ctx->vibration_supported = true;
+        ctx->touchpad_supported = true;
+    } else {
+        // Third party controller capability request
+        size = ReadFeatureReport(device->dev, k_ePS4FeatureReportIdCapabilities, data, sizeof(data));
+        // Get the device capabilities
+        if (size == 48 && data[2] == 0x27) {
+            Uint8 capabilities = data[4];
+            Uint8 device_type = data[5];
+            Uint16 gyro_numerator = LOAD16(data[10], data[11]);
+            Uint16 gyro_denominator = LOAD16(data[12], data[13]);
+            Uint16 accel_numerator = LOAD16(data[14], data[15]);
+            Uint16 accel_denominator = LOAD16(data[16], data[17]);
+
+#ifdef DEBUG_PS4_PROTOCOL
+            HIDAPI_DumpPacket("PS4 capabilities: size = %d", data, size);
+#endif
+            if (capabilities & 0x02) {
+                ctx->sensors_supported = true;
+            }
+            if (capabilities & 0x04) {
+                ctx->lightbar_supported = true;
+            }
+            if (capabilities & 0x08) {
+                ctx->vibration_supported = true;
+            }
+            if (capabilities & 0x40) {
+                ctx->touchpad_supported = true;
+            }
+
+            switch (device_type) {
+            case 0x00:
+                joystick_type = SDL_JOYSTICK_TYPE_GAMEPAD;
+                break;
+            case 0x01:
+                joystick_type = SDL_JOYSTICK_TYPE_GUITAR;
+                break;
+            case 0x02:
+                joystick_type = SDL_JOYSTICK_TYPE_DRUM_KIT;
+                break;
+            case 0x04:
+                joystick_type = SDL_JOYSTICK_TYPE_DANCE_PAD;
+                break;
+            case 0x06:
+                joystick_type = SDL_JOYSTICK_TYPE_WHEEL;
+                break;
+            case 0x07:
+                joystick_type = SDL_JOYSTICK_TYPE_ARCADE_STICK;
+                break;
+            case 0x08:
+                joystick_type = SDL_JOYSTICK_TYPE_FLIGHT_STICK;
+                break;
+            default:
+                joystick_type = SDL_JOYSTICK_TYPE_UNKNOWN;
+                break;
+            }
+
+            if (gyro_numerator && gyro_denominator) {
+                ctx->gyro_numerator = gyro_numerator;
+                ctx->gyro_denominator = gyro_denominator;
+            }
+            if (accel_numerator && accel_denominator) {
+                ctx->accel_numerator = accel_numerator;
+                ctx->accel_denominator = accel_denominator;
+            }
+        } else if (device->vendor_id == USB_VENDOR_RAZER) {
+            // The Razer Raiju doesn't respond to the detection protocol, but has a touchpad and vibration
+            ctx->vibration_supported = true;
+            ctx->touchpad_supported = true;
+        }
+    }
+    ctx->effects_supported = (ctx->lightbar_supported || ctx->vibration_supported);
+
+    if (device->vendor_id == USB_VENDOR_NACON_ALT &&
+        device->product_id == USB_PRODUCT_NACON_REVOLUTION_5_PRO_PS4_WIRELESS) {
+        ctx->is_nacon_dongle = true;
+    }
+
+    if (device->vendor_id == USB_VENDOR_PDP &&
+        (device->product_id == USB_PRODUCT_VICTRIX_FS_PRO ||
+         device->product_id == USB_PRODUCT_VICTRIX_FS_PRO_V2)) {
+        /* The Victrix FS Pro V2 reports that it has lightbar support,
+         * but it doesn't respond to the effects packet, and will hang
+         * on reboot if we send it.
+         */
+        ctx->effects_supported = false;
+    }
+
+    device->joystick_type = joystick_type;
+    device->type = SDL_GAMEPAD_TYPE_PS4;
+    if (ctx->official_controller) {
+        HIDAPI_SetDeviceName(device, "PS4 Controller");
+    }
+    HIDAPI_SetDeviceSerial(device, serial);
+
+    // Prefer the USB device over the Bluetooth device
+    if (device->is_bluetooth) {
+        if (HIDAPI_HasConnectedUSBDevice(device->serial)) {
+            return true;
+        }
+    } else {
+        HIDAPI_DisconnectBluetoothDevice(device->serial);
+    }
+    if ((ctx->is_dongle || ctx->is_nacon_dongle) && serial[0] == '\0') {
+        // Not yet connected
+        return true;
+    }
+    return HIDAPI_JoystickConnected(device, NULL);
+}
+
+static int HIDAPI_DriverPS4_GetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id)
+{
+    return -1;
+}
+
+static bool HIDAPI_DriverPS4_LoadOfficialCalibrationData(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverPS4_Context *ctx = (SDL_DriverPS4_Context *)device->context;
+    int i, tries, size;
+    bool have_data = false;
+    Uint8 data[USB_PACKET_LENGTH];
+
+    if (!ctx->official_controller) {
+#ifdef DEBUG_PS4_CALIBRATION
+        SDL_Log("Not an official controller, ignoring calibration");
+#endif
+        return false;
+    }
+
+    for (tries = 0; tries < 5; ++tries) {
+        // For Bluetooth controllers, this report switches them into advanced report mode
+        size = ReadFeatureReport(device->dev, k_ePS4FeatureReportIdGyroCalibration_USB, data, sizeof(data));
+        if (size < 35) {
+#ifdef DEBUG_PS4_CALIBRATION
+            SDL_Log("Short read of calibration data: %d, ignoring calibration", size);
+#endif
+            return false;
+        }
+
+        if (device->is_bluetooth) {
+            size = ReadFeatureReport(device->dev, k_ePS4FeatureReportIdGyroCalibration_BT, data, sizeof(data));
+            if (size < 35) {
+#ifdef DEBUG_PS4_CALIBRATION
+                SDL_Log("Short read of calibration data: %d, ignoring calibration", size);
+#endif
+                return false;
+            }
+        }
+
+        // In some cases this report returns all zeros. Usually immediately after connection with the PS4 Dongle
+        for (i = 0; i < size; ++i) {
+            if (data[i]) {
+                have_data = true;
+                break;
+            }
+        }
+        if (have_data) {
+            break;
+        }
+
+        SDL_Delay(2);
+    }
+
+    if (have_data) {
+        Sint16 sGyroPitchBias, sGyroYawBias, sGyroRollBias;
+        Sint16 sGyroPitchPlus, sGyroPitchMinus;
+        Sint16 sGyroYawPlus, sGyroYawMinus;
+        Sint16 sGyroRollPlus, sGyroRollMinus;
+        Sint16 sGyroSpeedPlus, sGyroSpeedMinus;
+
+        Sint16 sAccXPlus, sAccXMinus;
+        Sint16 sAccYPlus, sAccYMinus;
+        Sint16 sAccZPlus, sAccZMinus;
+
+        float flNumerator;
+        float flDenominator;
+        Sint16 sRange2g;
+
+#ifdef DEBUG_PS4_CALIBRATION
+        HIDAPI_DumpPacket("PS4 calibration packet: size = %d", data, size);
+#endif
+
+        sGyroPitchBias = LOAD16(data[1], data[2]);
+        sGyroYawBias = LOAD16(data[3], data[4]);
+        sGyroRollBias = LOAD16(data[5], data[6]);
+
+        if (device->is_bluetooth || ctx->is_dongle) {
+            sGyroPitchPlus = LOAD16(data[7], data[8]);
+            sGyroYawPlus = LOAD16(data[9], data[10]);
+            sGyroRollPlus = LOAD16(data[11], data[12]);
+            sGyroPitchMinus = LOAD16(data[13], data[14]);
+            sGyroYawMinus = LOAD16(data[15], data[16]);
+            sGyroRollMinus = LOAD16(data[17], data[18]);
+        } else {
+            sGyroPitchPlus = LOAD16(data[7], data[8]);
+            sGyroPitchMinus = LOAD16(data[9], data[10]);
+            sGyroYawPlus = LOAD16(data[11], data[12]);
+            sGyroYawMinus = LOAD16(data[13], data[14]);
+            sGyroRollPlus = LOAD16(data[15], data[16]);
+            sGyroRollMinus = LOAD16(data[17], data[18]);
+        }
+
+        sGyroSpeedPlus = LOAD16(data[19], data[20]);
+        sGyroSpeedMinus = LOAD16(data[21], data[22]);
+
+        sAccXPlus = LOAD16(data[23], data[24]);
+        sAccXMinus = LOAD16(data[25], data[26]);
+        sAccYPlus = LOAD16(data[27], data[28]);
+        sAccYMinus = LOAD16(data[29], data[30]);
+        sAccZPlus = LOAD16(data[31], data[32]);
+        sAccZMinus = LOAD16(data[33], data[34]);
+
+        flNumerator = (float)(sGyroSpeedPlus + sGyroSpeedMinus) * ctx->gyro_denominator / ctx->gyro_numerator;
+        flDenominator = (float)(SDL_abs(sGyroPitchPlus - sGyroPitchBias) + SDL_abs(sGyroPitchMinus - sGyroPitchBias));
+        if (flDenominator != 0.0f) {
+            ctx->calibration[0].bias = sGyroPitchBias;
+            ctx->calibration[0].scale = flNumerator / flDenominator;
+        }
+
+        flDenominator = (float)(SDL_abs(sGyroYawPlus - sGyroYawBias) + SDL_abs(sGyroYawMinus - sGyroYawBias));
+        if (flDenominator != 0.0f) {
+            ctx->calibration[1].bias = sGyroYawBias;
+            ctx->calibration[1].scale = flNumerator / flDenominator;
+        }
+
+        flDenominator = (float)(SDL_abs(sGyroRollPlus - sGyroRollBias) + SDL_abs(sGyroRollMinus - sGyroRollBias));
+        if (flDenominator != 0.0f) {
+            ctx->calibration[2].bias = sGyroRollBias;
+            ctx->calibration[2].scale = flNumerator / flDenominator;
+        }
+
+        sRange2g = sAccXPlus - sAccXMinus;
+        ctx->calibration[3].bias = sAccXPlus - sRange2g / 2;
+        ctx->calibration[3].scale = (2.0f * ctx->accel_denominator  / ctx->accel_numerator) / sRange2g;
+
+        sRange2g = sAccYPlus - sAccYMinus;
+        ctx->calibration[4].bias = sAccYPlus - sRange2g / 2;
+        ctx->calibration[4].scale = (2.0f * ctx->accel_denominator / ctx->accel_numerator) / sRange2g;
+
+        sRange2g = sAccZPlus - sAccZMinus;
+        ctx->calibration[5].bias = sAccZPlus - sRange2g / 2;
+        ctx->calibration[5].scale = (2.0f * ctx->accel_denominator / ctx->accel_numerator) / sRange2g;
+
+        ctx->hardware_calibration = true;
+        for (i = 0; i < 6; ++i) {
+#ifdef DEBUG_PS4_CALIBRATION
+            SDL_Log("calibration[%d] bias = %d, sensitivity = %f", i, ctx->calibration[i].bias, ctx->calibration[i].scale);
+#endif
+            // Some controllers have a bad calibration
+            if (SDL_abs(ctx->calibration[i].bias) > 1024 || SDL_fabsf(1.0f - ctx->calibration[i].scale) > 0.5f) {
+#ifdef DEBUG_PS4_CALIBRATION
+                SDL_Log("invalid calibration, ignoring");
+#endif
+                ctx->hardware_calibration = false;
+            }
+        }
+    } else {
+#ifdef DEBUG_PS4_CALIBRATION
+        SDL_Log("Calibration data not available");
+#endif
+    }
+    return ctx->hardware_calibration;
+}
+
+static void HIDAPI_DriverPS4_LoadCalibrationData(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverPS4_Context *ctx = (SDL_DriverPS4_Context *)device->context;
+    int i;
+
+    if (!HIDAPI_DriverPS4_LoadOfficialCalibrationData(device)) {
+        for (i = 0; i < SDL_arraysize(ctx->calibration); ++i) {
+            ctx->calibration[i].bias = 0;
+            ctx->calibration[i].scale = 1.0f;
+        }
+    }
+
+    // Scale the raw data to the units expected by SDL
+    for (i = 0; i < SDL_arraysize(ctx->calibration); ++i) {
+        double scale = ctx->calibration[i].scale;
+
+        if (i < 3) {
+            scale *= ((double)ctx->gyro_numerator / ctx->gyro_denominator) * SDL_PI_D / 180.0;
+
+             if (device->vendor_id == USB_VENDOR_SONY &&
+                 device->product_id == USB_PRODUCT_SONY_DS4_STRIKEPAD) {
+                 // The Armor-X Pro seems to only deliver half the rotation it should
+                 scale *= 2.0;
+             }
+        } else {
+            scale *= ((double)ctx->accel_numerator / ctx->accel_denominator) * SDL_STANDARD_GRAVITY;
+
+            if (device->vendor_id == USB_VENDOR_SONY &&
+                device->product_id == USB_PRODUCT_SONY_DS4_STRIKEPAD) {
+                /* The Armor-X Pro seems to only deliver half the acceleration it should,
+                 * and in the opposite direction on all axes */
+                scale *= -2.0;
+            }
+        }
+        ctx->calibration[i].scale = (float)scale;
+    }
+}
+
+static float HIDAPI_DriverPS4_ApplyCalibrationData(SDL_DriverPS4_Context *ctx, int index, Sint16 value)
+{
+    IMUCalibrationData *calibration = &ctx->calibration[index];
+
+    return ((float)value - calibration->bias) * calibration->scale;
+}
+
+static bool HIDAPI_DriverPS4_UpdateEffects(SDL_DriverPS4_Context *ctx, bool application_usage)
+{
+    DS4EffectsState_t effects;
+
+    SDL_zero(effects);
+
+    if (ctx->vibration_supported) {
+        effects.ucRumbleLeft = ctx->rumble_left;
+        effects.ucRumbleRight = ctx->rumble_right;
+    }
+
+    if (ctx->lightbar_supported) {
+        // Populate the LED state with the appropriate color from our lookup table
+        if (ctx->color_set) {
+            effects.ucLedRed = ctx->led_red;
+            effects.ucLedGreen = ctx->led_green;
+            effects.ucLedBlue = ctx->led_blue;
+        } else {
+            SetLedsForPlayerIndex(&effects, ctx->player_index);
+        }
+    }
+    return HIDAPI_DriverPS4_InternalSendJoystickEffect(ctx, &effects, sizeof(effects), application_usage);
+}
+
+static void HIDAPI_DriverPS4_TickleBluetooth(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverPS4_Context *ctx = (SDL_DriverPS4_Context *)device->context;
+
+    if (ctx->enhanced_reports) {
+        // This is just a dummy packet that should have no effect, since we don't set the CRC
+        Uint8 data[78];
+
+        SDL_zeroa(data);
+
+        data[0] = k_EPS4ReportIdBluetoothEffects;
+        data[1] = 0xC0; // Magic value HID + CRC
+
+        if (SDL_HIDAPI_LockRumble()) {
+            SDL_HIDAPI_SendRumbleAndUnlock(device, data, sizeof(data));
+        }
+    } else {
+#if 0 /* The 8BitDo Zero 2 has perfect emulation of a PS4 controller, except it
+       * only sends reports when the state changes, so we can't disconnect here.
+       */
+        // We can't even send an invalid effects packet, or it will put the controller in enhanced mode
+        if (device->num_joysticks > 0) {
+            HIDAPI_JoystickDisconnected(device, device->joysticks[0]);
+        }
+#endif
+    }
+}
+
+static void HIDAPI_DriverPS4_SetEnhancedModeAvailable(SDL_DriverPS4_Context *ctx)
+{
+    if (ctx->enhanced_mode_available) {
+        return;
+    }
+    ctx->enhanced_mode_available = true;
+
+    if (ctx->touchpad_supported) {
+        SDL_PrivateJoystickAddTouchpad(ctx->joystick, 2);
+        ctx->report_touchpad = true;
+    }
+
+    if (ctx->sensors_supported) {
+        SDL_PrivateJoystickAddSensor(ctx->joystick, SDL_SENSOR_GYRO, (float)(1000 / ctx->report_interval));
+        SDL_PrivateJoystickAddSensor(ctx->joystick, SDL_SENSOR_ACCEL, (float)(1000 / ctx->report_interval));
+    }
+
+    if (ctx->official_controller) {
+        ctx->report_battery = true;
+    }
+
+    HIDAPI_UpdateDeviceProperties(ctx->device);
+}
+
+static void HIDAPI_DriverPS4_SetEnhancedMode(SDL_DriverPS4_Context *ctx)
+{
+    HIDAPI_DriverPS4_SetEnhancedModeAvailable(ctx);
+
+    if (!ctx->enhanced_mode) {
+        ctx->enhanced_mode = true;
+
+        // Switch into enhanced report mode
+        HIDAPI_DriverPS4_UpdateEffects(ctx, false);
+    }
+}
+
+static void HIDAPI_DriverPS4_SetEnhancedReportHint(SDL_DriverPS4_Context *ctx, HIDAPI_PS4_EnhancedReportHint enhanced_report_hint)
+{
+    switch (enhanced_report_hint) {
+    case PS4_ENHANCED_REPORT_HINT_OFF:
+        // Nothing to do, enhanced mode is a one-way ticket
+        break;
+    case PS4_ENHANCED_REPORT_HINT_ON:
+        HIDAPI_DriverPS4_SetEnhancedMode(ctx);
+        break;
+    case PS4_ENHANCED_REPORT_HINT_AUTO:
+        HIDAPI_DriverPS4_SetEnhancedModeAvailable(ctx);
+        break;
+    }
+    ctx->enhanced_report_hint = enhanced_report_hint;
+}
+
+static void HIDAPI_DriverPS4_UpdateEnhancedModeOnEnhancedReport(SDL_DriverPS4_Context *ctx)
+{
+    ctx->enhanced_reports = true;
+
+    if (ctx->enhanced_report_hint == PS4_ENHANCED_REPORT_HINT_AUTO) {
+        HIDAPI_DriverPS4_SetEnhancedReportHint(ctx, PS4_ENHANCED_REPORT_HINT_ON);
+    }
+}
+
+static void HIDAPI_DriverPS4_UpdateEnhancedModeOnApplicationUsage(SDL_DriverPS4_Context *ctx)
+{
+    if (ctx->enhanced_report_hint == PS4_ENHANCED_REPORT_HINT_AUTO) {
+        HIDAPI_DriverPS4_SetEnhancedReportHint(ctx, PS4_ENHANCED_REPORT_HINT_ON);
+    }
+}
+
+static void SDLCALL SDL_PS4EnhancedReportsChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
+{
+    SDL_DriverPS4_Context *ctx = (SDL_DriverPS4_Context *)userdata;
+
+    if (ctx->device->is_bluetooth) {
+        if (hint && SDL_strcasecmp(hint, "auto") == 0) {
+            HIDAPI_DriverPS4_SetEnhancedReportHint(ctx, PS4_ENHANCED_REPORT_HINT_AUTO);
+        } else if (SDL_GetStringBoolean(hint, true)) {
+            HIDAPI_DriverPS4_SetEnhancedReportHint(ctx, PS4_ENHANCED_REPORT_HINT_ON);
+        } else {
+            HIDAPI_DriverPS4_SetEnhancedReportHint(ctx, PS4_ENHANCED_REPORT_HINT_OFF);
+        }
+    } else {
+        HIDAPI_DriverPS4_SetEnhancedReportHint(ctx, PS4_ENHANCED_REPORT_HINT_ON);
+    }
+}
+
+static void SDLCALL SDL_PS4ReportIntervalHintChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
+{
+    const int DEFAULT_REPORT_INTERVAL = 4;
+    SDL_DriverPS4_Context *ctx = (SDL_DriverPS4_Context *)userdata;
+    int new_report_interval = DEFAULT_REPORT_INTERVAL;
+
+    if (hint) {
+        int report_interval = SDL_atoi(hint);
+        switch (report_interval) {
+        case 1:
+        case 2:
+        case 4:
+            // Valid values
+            new_report_interval = report_interval;
+            break;
+        default:
+            break;
+        }
+    }
+
+    if (new_report_interval != ctx->report_interval) {
+        ctx->report_interval = (Uint8)new_report_interval;
+
+        HIDAPI_DriverPS4_UpdateEffects(ctx, false);
+        SDL_LockJoysticks();
+        SDL_PrivateJoystickSensorRate(ctx->joystick, SDL_SENSOR_GYRO, (float)(1000 / ctx->report_interval));
+        SDL_PrivateJoystickSensorRate(ctx->joystick, SDL_SENSOR_ACCEL, (float)(1000 / ctx->report_interval));
+        SDL_UnlockJoysticks();
+    }
+}
+
+static void HIDAPI_DriverPS4_SetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id, int player_index)
+{
+    SDL_DriverPS4_Context *ctx = (SDL_DriverPS4_Context *)device->context;
+
+    if (!ctx->joystick) {
+        return;
+    }
+
+    ctx->player_index = player_index;
+
+    // This will set the new LED state based on the new player index
+    // SDL automatically calls this, so it doesn't count as an application action to enable enhanced mode
+    HIDAPI_DriverPS4_UpdateEffects(ctx, false);
+}
+
+static bool HIDAPI_DriverPS4_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverPS4_Context *ctx = (SDL_DriverPS4_Context *)device->context;
+
+    SDL_AssertJoysticksLocked();
+
+    ctx->joystick = joystick;
+    ctx->last_packet = SDL_GetTicks();
+    ctx->report_sensors = false;
+    ctx->report_touchpad = false;
+    ctx->rumble_left = 0;
+    ctx->rumble_right = 0;
+    ctx->color_set = false;
+    SDL_zero(ctx->last_state);
+
+    // Initialize player index (needed for setting LEDs)
+    ctx->player_index = SDL_GetJoystickPlayerIndex(joystick);
+
+    // Initialize the joystick capabilities
+    joystick->nbuttons = 11;
+    if (ctx->touchpad_supported) {
+        joystick->nbuttons += 1;
+    }
+    joystick->naxes = SDL_GAMEPAD_AXIS_COUNT;
+    joystick->nhats = 1;
+
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_PS4_REPORT_INTERVAL,
+                        SDL_PS4ReportIntervalHintChanged, ctx);
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_ENHANCED_REPORTS,
+                        SDL_PS4EnhancedReportsChanged, ctx);
+    return true;
+}
+
+static bool HIDAPI_DriverPS4_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+    SDL_DriverPS4_Context *ctx = (SDL_DriverPS4_Context *)device->context;
+
+    if (!ctx->vibration_supported) {
+        return SDL_Unsupported();
+    }
+
+    ctx->rumble_left = (low_frequency_rumble >> 8);
+    ctx->rumble_right = (high_frequency_rumble >> 8);
+
+    return HIDAPI_DriverPS4_UpdateEffects(ctx, true);
+}
+
+static bool HIDAPI_DriverPS4_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
+{
+    return SDL_Unsupported();
+}
+
+static Uint32 HIDAPI_DriverPS4_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverPS4_Context *ctx = (SDL_DriverPS4_Context *)device->context;
+    Uint32 result = 0;
+
+    if (ctx->enhanced_mode_available) {
+        if (ctx->lightbar_supported) {
+            result |= SDL_JOYSTICK_CAP_RGB_LED;
+        }
+        if (ctx->vibration_supported) {
+            result |= SDL_JOYSTICK_CAP_RUMBLE;
+        }
+    }
+
+    return result;
+}
+
+static bool HIDAPI_DriverPS4_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    SDL_DriverPS4_Context *ctx = (SDL_DriverPS4_Context *)device->context;
+
+    if (!ctx->lightbar_supported) {
+        return SDL_Unsupported();
+    }
+
+    ctx->color_set = true;
+    ctx->led_red = red;
+    ctx->led_green = green;
+    ctx->led_blue = blue;
+
+    return HIDAPI_DriverPS4_UpdateEffects(ctx, true);
+}
+
+static bool HIDAPI_DriverPS4_InternalSendJoystickEffect(SDL_DriverPS4_Context *ctx, const void *effect, int size, bool application_usage)
+{
+    Uint8 data[78];
+    int report_size, offset;
+
+    if (!ctx->effects_supported) {
+        // We shouldn't be sending packets to this controller
+        return SDL_Unsupported();
+    }
+
+    if (!ctx->enhanced_mode) {
+        if (application_usage) {
+            HIDAPI_DriverPS4_UpdateEnhancedModeOnApplicationUsage(ctx);
+        }
+
+        if (!ctx->enhanced_mode) {
+            // We're not in enhanced mode, effects aren't allowed
+            return SDL_Unsupported();
+        }
+    }
+
+    SDL_zeroa(data);
+
+    if (ctx->device->is_bluetooth && ctx->official_controller) {
+        data[0] = k_EPS4ReportIdBluetoothEffects;
+        data[1] = 0xC0 | ctx->report_interval; // Magic value HID + CRC, also sets update interval
+        data[3] = 0x03;        // 0x1 is rumble, 0x2 is lightbar, 0x4 is the blink interval
+
+        report_size = 78;
+        offset = 6;
+    } else {
+        data[0] = k_EPS4ReportIdUsbEffects;
+        data[1] = 0x07; // Magic value
+
+        report_size = 32;
+        offset = 4;
+    }
+
+    SDL_memcpy(&data[offset], effect, SDL_min((sizeof(data) - offset), (size_t)size));
+
+    if (ctx->device->is_bluetooth) {
+        // Bluetooth reports need a CRC at the end of the packet (at least on Linux)
+        Uint8 ubHdr = 0xA2; // hidp header is part of the CRC calculation
+        Uint32 unCRC;
+        unCRC = SDL_crc32(0, &ubHdr, 1);
+        unCRC = SDL_crc32(unCRC, data, (size_t)(report_size - sizeof(unCRC)));
+        SDL_memcpy(&data[report_size - sizeof(unCRC)], &unCRC, sizeof(unCRC));
+    }
+
+    if (SDL_HIDAPI_SendRumble(ctx->device, data, report_size) != report_size) {
+        return SDL_SetError("Couldn't send rumble packet");
+    }
+    return true;
+}
+
+static bool HIDAPI_DriverPS4_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *effect, int size)
+{
+    SDL_DriverPS4_Context *ctx = (SDL_DriverPS4_Context *)device->context;
+
+    return HIDAPI_DriverPS4_InternalSendJoystickEffect(ctx, effect, size, true);
+}
+
+static bool HIDAPI_DriverPS4_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, bool enabled)
+{
+    SDL_DriverPS4_Context *ctx = (SDL_DriverPS4_Context *)device->context;
+
+    HIDAPI_DriverPS4_UpdateEnhancedModeOnApplicationUsage(ctx);
+
+    if (!ctx->sensors_supported || (enabled && !ctx->enhanced_mode)) {
+        return SDL_Unsupported();
+    }
+
+    if (enabled) {
+        HIDAPI_DriverPS4_LoadCalibrationData(device);
+    }
+    ctx->report_sensors = enabled;
+
+    return true;
+}
+
+static void HIDAPI_DriverPS4_HandleStatePacket(SDL_Joystick *joystick, SDL_hid_device *dev, SDL_DriverPS4_Context *ctx, PS4StatePacket_t *packet, int size)
+{
+    static const float TOUCHPAD_SCALEX = 1.0f / 1920;
+    static const float TOUCHPAD_SCALEY = 1.0f / 920; // This is noted as being 944 resolution, but 920 feels better
+    Sint16 axis;
+    bool touchpad_down;
+    int touchpad_x, touchpad_y;
+    Uint64 timestamp = SDL_GetTicksNS();
+
+    if (size > 9 && ctx->report_touchpad && ctx->enhanced_reports) {
+        touchpad_down = ((packet->ucTouchpadCounter1 & 0x80) == 0);
+        touchpad_x = packet->rgucTouchpadData1[0] | (((int)packet->rgucTouchpadData1[1] & 0x0F) << 8);
+        touchpad_y = (packet->rgucTouchpadData1[1] >> 4) | ((int)packet->rgucTouchpadData1[2] << 4);
+        SDL_SendJoystickTouchpad(timestamp, joystick, 0, 0, touchpad_down, touchpad_x * TOUCHPAD_SCALEX, touchpad_y * TOUCHPAD_SCALEY, touchpad_down ? 1.0f : 0.0f);
+
+        touchpad_down = ((packet->ucTouchpadCounter2 & 0x80) == 0);
+        touchpad_x = packet->rgucTouchpadData2[0] | (((int)packet->rgucTouchpadData2[1] & 0x0F) << 8);
+        touchpad_y = (packet->rgucTouchpadData2[1] >> 4) | ((int)packet->rgucTouchpadData2[2] << 4);
+        SDL_SendJoystickTouchpad(timestamp, joystick, 0, 1, touchpad_down, touchpad_x * TOUCHPAD_SCALEX, touchpad_y * TOUCHPAD_SCALEY, touchpad_down ? 1.0f : 0.0f);
+    }
+
+    if (ctx->last_state.rgucButtonsHatAndCounter[0] != packet->rgucButtonsHatAndCounter[0]) {
+        {
+            Uint8 data = (packet->rgucButtonsHatAndCounter[0] >> 4);
+
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_WEST, ((data & 0x01) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SOUTH, ((data & 0x02) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_EAST, ((data & 0x04) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_NORTH, ((data & 0x08) != 0));
+        }
+        {
+            Uint8 hat;
+            Uint8 data = (packet->rgucButtonsHatAndCounter[0] & 0x0F);
+
+            switch (data) {
+            case 0:
+                hat = SDL_HAT_UP;
+                break;
+            case 1:
+                hat = SDL_HAT_RIGHTUP;
+                break;
+            case 2:
+                hat = SDL_HAT_RIGHT;
+                break;
+            case 3:
+                hat = SDL_HAT_RIGHTDOWN;
+                break;
+            case 4:
+                hat = SDL_HAT_DOWN;
+                break;
+            case 5:
+                hat = SDL_HAT_LEFTDOWN;
+                break;
+            case 6:
+                hat = SDL_HAT_LEFT;
+                break;
+            case 7:
+                hat = SDL_HAT_LEFTUP;
+                break;
+            default:
+                hat = SDL_HAT_CENTERED;
+                break;
+            }
+            SDL_SendJoystickHat(timestamp, joystick, 0, hat);
+        }
+    }
+
+    if (ctx->last_state.rgucButtonsHatAndCounter[1] != packet->rgucButtonsHatAndCounter[1]) {
+        Uint8 data = packet->rgucButtonsHatAndCounter[1];
+
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK, ((data & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_STICK, ((data & 0x80) != 0));
+    }
+
+    /* Some fightsticks, ex: Victrix FS Pro will only this these digital trigger bits and not the analog values so this needs to run whenever the
+       trigger is evaluated
+    */
+    if (packet->rgucButtonsHatAndCounter[1] & 0x0C) {
+        Uint8 data = packet->rgucButtonsHatAndCounter[1];
+        packet->ucTriggerLeft = (data & 0x04) && packet->ucTriggerLeft == 0 ? 255 : packet->ucTriggerLeft;
+        packet->ucTriggerRight = (data & 0x08) && packet->ucTriggerRight == 0 ? 255 : packet->ucTriggerRight;
+    }
+
+    if (ctx->last_state.rgucButtonsHatAndCounter[2] != packet->rgucButtonsHatAndCounter[2]) {
+        Uint8 data = (packet->rgucButtonsHatAndCounter[2] & 0x03);
+
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_PS4_TOUCHPAD, ((data & 0x02) != 0));
+    }
+
+    axis = ((int)packet->ucTriggerLeft * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, axis);
+    axis = ((int)packet->ucTriggerRight * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, axis);
+    axis = ((int)packet->ucLeftJoystickX * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, axis);
+    axis = ((int)packet->ucLeftJoystickY * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, axis);
+    axis = ((int)packet->ucRightJoystickX * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, axis);
+    axis = ((int)packet->ucRightJoystickY * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, axis);
+
+    if (size > 9 && ctx->report_battery && ctx->enhanced_reports) {
+        SDL_PowerState state;
+        int percent;
+        Uint8 level = (packet->ucBatteryLevel & 0x0F);
+
+        if (packet->ucBatteryLevel & 0x10) {
+            if (level <= 10) {
+                state = SDL_POWERSTATE_CHARGING;
+                percent = SDL_min(level * 10 + 5, 100);
+            } else if (level == 11) {
+                state = SDL_POWERSTATE_CHARGED;
+                percent = 100;
+            } else {
+                state = SDL_POWERSTATE_UNKNOWN;
+                percent = 0;
+            }
+        } else {
+            state = SDL_POWERSTATE_ON_BATTERY;
+            percent = SDL_min(level * 10 + 5, 100);
+        }
+        SDL_SendJoystickPowerInfo(joystick, state, percent);
+    }
+
+    if (size > 9 && ctx->report_sensors) {
+        Uint16 tick;
+        Uint16 delta;
+        Uint64 sensor_timestamp;
+        float data[3];
+
+        tick = LOAD16(packet->rgucTimestamp[0], packet->rgucTimestamp[1]);
+        if (ctx->last_tick < tick) {
+            delta = (tick - ctx->last_tick);
+        } else {
+            delta = (SDL_MAX_UINT16 - ctx->last_tick + tick + 1);
+        }
+        ctx->sensor_ticks += delta;
+        ctx->last_tick = tick;
+
+        // Sensor timestamp is in 5.33us units
+        sensor_timestamp = (ctx->sensor_ticks * SDL_NS_PER_US * 16) / 3;
+
+        data[0] = HIDAPI_DriverPS4_ApplyCalibrationData(ctx, 0, LOAD16(packet->rgucGyroX[0], packet->rgucGyroX[1]));
+        data[1] = HIDAPI_DriverPS4_ApplyCalibrationData(ctx, 1, LOAD16(packet->rgucGyroY[0], packet->rgucGyroY[1]));
+        data[2] = HIDAPI_DriverPS4_ApplyCalibrationData(ctx, 2, LOAD16(packet->rgucGyroZ[0], packet->rgucGyroZ[1]));
+        SDL_SendJoystickSensor(timestamp, joystick, SDL_SENSOR_GYRO, sensor_timestamp, data, 3);
+
+        data[0] = HIDAPI_DriverPS4_ApplyCalibrationData(ctx, 3, LOAD16(packet->rgucAccelX[0], packet->rgucAccelX[1]));
+        data[1] = HIDAPI_DriverPS4_ApplyCalibrationData(ctx, 4, LOAD16(packet->rgucAccelY[0], packet->rgucAccelY[1]));
+        data[2] = HIDAPI_DriverPS4_ApplyCalibrationData(ctx, 5, LOAD16(packet->rgucAccelZ[0], packet->rgucAccelZ[1]));
+        SDL_SendJoystickSensor(timestamp, joystick, SDL_SENSOR_ACCEL, sensor_timestamp, data, 3);
+    }
+
+    SDL_memcpy(&ctx->last_state, packet, sizeof(ctx->last_state));
+}
+
+static bool VerifyCRC(Uint8 *data, int size)
+{
+    Uint8 ubHdr = 0xA1; // hidp header is part of the CRC calculation
+    Uint32 unCRC, unPacketCRC;
+    Uint8 *packetCRC = data + size - sizeof(unPacketCRC);
+    unCRC = SDL_crc32(0, &ubHdr, 1);
+    unCRC = SDL_crc32(unCRC, data, (size_t)(size - sizeof(unCRC)));
+
+    unPacketCRC = LOAD32(packetCRC[0],
+                         packetCRC[1],
+                         packetCRC[2],
+                         packetCRC[3]);
+    return (unCRC == unPacketCRC);
+}
+
+static bool HIDAPI_DriverPS4_IsPacketValid(SDL_DriverPS4_Context *ctx, Uint8 *data, int size)
+{
+    switch (data[0]) {
+    case k_EPS4ReportIdUsbState:
+        if (size == 10) {
+            // This is non-enhanced mode, this packet is fine
+            return true;
+        }
+
+        if (ctx->is_nacon_dongle && size >= (1 + sizeof(PS4StatePacket_t))) {
+            // The report timestamp doesn't change when the controller isn't connected
+            PS4StatePacket_t *packet = (PS4StatePacket_t *)&data[1];
+            if (SDL_memcmp(packet->rgucTimestamp, ctx->last_state.rgucTimestamp, sizeof(packet->rgucTimestamp)) == 0) {
+                return false;
+            }
+            if (ctx->last_state.rgucAccelX[0] == 0 && ctx->last_state.rgucAccelX[1] == 0 &&
+                ctx->last_state.rgucAccelY[0] == 0 && ctx->last_state.rgucAccelY[1] == 0 &&
+                ctx->last_state.rgucAccelZ[0] == 0 && ctx->last_state.rgucAccelZ[1] == 0) {
+                // We don't have any state to compare yet, go ahead and copy it
+                SDL_memcpy(&ctx->last_state, &data[1], sizeof(PS4StatePacket_t));
+                return false;
+            }
+        }
+
+        /* In the case of a DS4 USB dongle, bit[2] of byte 31 indicates if a DS4 is actually connected (indicated by '0').
+         * For non-dongle, this bit is always 0 (connected).
+         * This is usually the ID over USB, but the DS4v2 that started shipping with the PS4 Slim will also send this
+         * packet over BT with a size of 128
+         */
+        if (size >= 64 && !(data[31] & 0x04)) {
+            return true;
+        }
+        break;
+    case k_EPS4ReportIdBluetoothState1:
+    case k_EPS4ReportIdBluetoothState2:
+    case k_EPS4ReportIdBluetoothState3:
+    case k_EPS4ReportIdBluetoothState4:
+    case k_EPS4ReportIdBluetoothState5:
+    case k_EPS4ReportIdBluetoothState6:
+    case k_EPS4ReportIdBluetoothState7:
+    case k_EPS4ReportIdBluetoothState8:
+    case k_EPS4ReportIdBluetoothState9:
+        // Bluetooth state packets have two additional bytes at the beginning, the first notes if HID data is present
+        if (size >= 78 && (data[1] & 0x80)) {
+            if (VerifyCRC(data, 78)) {
+                ++ctx->valid_crc_packets;
+            } else {
+                if (ctx->valid_crc_packets > 0) {
+                    --ctx->valid_crc_packets;
+                }
+                if (ctx->valid_crc_packets >= 3) {
+                    // We're generally getting valid CRC, but failed one
+                    return false;
+                }
+            }
+            return true;
+        }
+        break;
+    default:
+        break;
+    }
+    return false;
+}
+
+static bool HIDAPI_DriverPS4_UpdateDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverPS4_Context *ctx = (SDL_DriverPS4_Context *)device->context;
+    SDL_Joystick *joystick = NULL;
+    Uint8 data[USB_PACKET_LENGTH * 2];
+    int size;
+    int packet_count = 0;
+    Uint64 now = SDL_GetTicks();
+
+    if (device->num_joysticks > 0) {
+        joystick = SDL_GetJoystickFromID(device->joysticks[0]);
+    }
+
+    while ((size = SDL_hid_read_timeout(device->dev, data, sizeof(data), 0)) > 0) {
+#ifdef DEBUG_PS4_PROTOCOL
+        HIDAPI_DumpPacket("PS4 packet: size = %d", data, size);
+#endif
+        if (!HIDAPI_DriverPS4_IsPacketValid(ctx, data, size)) {
+            continue;
+        }
+
+        ++packet_count;
+        ctx->last_packet = now;
+
+        if (!joystick) {
+            continue;
+        }
+
+        switch (data[0]) {
+        case k_EPS4ReportIdUsbState:
+            HIDAPI_DriverPS4_HandleStatePacket(joystick, device->dev, ctx, (PS4StatePacket_t *)&data[1], size - 1);
+            break;
+        case k_EPS4ReportIdBluetoothState1:
+        case k_EPS4ReportIdBluetoothState2:
+        case k_EPS4ReportIdBluetoothState3:
+        case k_EPS4ReportIdBluetoothState4:
+        case k_EPS4ReportIdBluetoothState5:
+        case k_EPS4ReportIdBluetoothState6:
+        case k_EPS4ReportIdBluetoothState7:
+        case k_EPS4ReportIdBluetoothState8:
+        case k_EPS4ReportIdBluetoothState9:
+            // This is the extended report, we can enable effects now in auto mode
+            HIDAPI_DriverPS4_UpdateEnhancedModeOnEnhancedReport(ctx);
+
+            // Bluetooth state packets have two additional bytes at the beginning, the first notes if HID is present
+            HIDAPI_DriverPS4_HandleStatePacket(joystick, device->dev, ctx, (PS4StatePacket_t *)&data[3], size - 3);
+            break;
+        default:
+#ifdef DEBUG_JOYSTICK
+            SDL_Log("Unknown PS4 packet: 0x%.2x", data[0]);
+#endif
+            break;
+        }
+    }
+
+    if (device->is_bluetooth) {
+        if (packet_count == 0) {
+            // Check to see if it looks like the device disconnected
+            if (now >= (ctx->last_packet + BLUETOOTH_DISCONNECT_TIMEOUT_MS)) {
+                // Send an empty output report to tickle the Bluetooth stack
+                HIDAPI_DriverPS4_TickleBluetooth(device);
+                ctx->last_packet = now;
+            }
+        } else {
+            // Reconnect the Bluetooth device once the USB device is gone
+            if (device->num_joysticks == 0 &&
+                !HIDAPI_HasConnectedUSBDevice(device->serial)) {
+                HIDAPI_JoystickConnected(device, NULL);
+            }
+        }
+    }
+
+    if (ctx->is_dongle || ctx->is_nacon_dongle) {
+        if (packet_count == 0) {
+            if (device->num_joysticks > 0) {
+                // Check to see if it looks like the device disconnected
+                if (now >= (ctx->last_packet + BLUETOOTH_DISCONNECT_TIMEOUT_MS)) {
+                    HIDAPI_JoystickDisconnected(device, device->joysticks[0]);
+                }
+            }
+        } else {
+            if (device->num_joysticks == 0) {
+                char serial[18];
+                size = ReadFeatureReport(device->dev, k_ePS4FeatureReportIdSerialNumber, data, sizeof(data));
+                if (size >= 7 && (data[1] || data[2] || data[3] || data[4] || data[5] || data[6])) {
+                    (void)SDL_snprintf(serial, sizeof(serial), "%.2x-%.2x-%.2x-%.2x-%.2x-%.2x",
+                                       data[6], data[5], data[4], data[3], data[2], data[1]);
+                    HIDAPI_SetDeviceSerial(device, serial);
+                }
+                HIDAPI_JoystickConnected(device, NULL);
+            }
+        }
+    }
+
+    if (packet_count == 0 && size < 0 && device->num_joysticks > 0) {
+        // Read error, device is disconnected
+        HIDAPI_JoystickDisconnected(device, device->joysticks[0]);
+    }
+    return (size >= 0);
+}
+
+static void HIDAPI_DriverPS4_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverPS4_Context *ctx = (SDL_DriverPS4_Context *)device->context;
+
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_PS4_REPORT_INTERVAL,
+                        SDL_PS4ReportIntervalHintChanged, ctx);
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_ENHANCED_REPORTS,
+                        SDL_PS4EnhancedReportsChanged, ctx);
+
+    ctx->joystick = NULL;
+
+    ctx->report_sensors = false;
+    ctx->enhanced_mode = false;
+    ctx->enhanced_mode_available = false;
+}
+
+static void HIDAPI_DriverPS4_FreeDevice(SDL_HIDAPI_Device *device)
+{
+}
+
+SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverPS4 = {
+    SDL_HINT_JOYSTICK_HIDAPI_PS4,
+    true,
+    HIDAPI_DriverPS4_RegisterHints,
+    HIDAPI_DriverPS4_UnregisterHints,
+    HIDAPI_DriverPS4_IsEnabled,
+    HIDAPI_DriverPS4_IsSupportedDevice,
+    HIDAPI_DriverPS4_InitDevice,
+    HIDAPI_DriverPS4_GetDevicePlayerIndex,
+    HIDAPI_DriverPS4_SetDevicePlayerIndex,
+    HIDAPI_DriverPS4_UpdateDevice,
+    HIDAPI_DriverPS4_OpenJoystick,
+    HIDAPI_DriverPS4_RumbleJoystick,
+    HIDAPI_DriverPS4_RumbleJoystickTriggers,
+    HIDAPI_DriverPS4_GetJoystickCapabilities,
+    HIDAPI_DriverPS4_SetJoystickLED,
+    HIDAPI_DriverPS4_SendJoystickEffect,
+    HIDAPI_DriverPS4_SetJoystickSensorsEnabled,
+    HIDAPI_DriverPS4_CloseJoystick,
+    HIDAPI_DriverPS4_FreeDevice,
+};
+
+#endif // SDL_JOYSTICK_HIDAPI_PS4
+
+#endif // SDL_JOYSTICK_HIDAPI
diff --git a/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_ps5.c b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_ps5.c
new file mode 100644
index 0000000..abf59a8
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_ps5.c
@@ -0,0 +1,1624 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI
+
+#include "../../SDL_hints_c.h"
+#include "../SDL_sysjoystick.h"
+#include "SDL_hidapijoystick_c.h"
+#include "SDL_hidapi_rumble.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI_PS5
+
+// Define this if you want to log all packets from the controller
+#if 0
+#define DEBUG_PS5_PROTOCOL
+#endif
+
+// Define this if you want to log calibration data
+#if 0
+#define DEBUG_PS5_CALIBRATION
+#endif
+
+#define GYRO_RES_PER_DEGREE             1024.0f
+#define ACCEL_RES_PER_G                 8192.0f
+#define BLUETOOTH_DISCONNECT_TIMEOUT_MS 500
+
+#define LOAD16(A, B)       (Sint16)((Uint16)(A) | (((Uint16)(B)) << 8))
+#define LOAD32(A, B, C, D) ((((Uint32)(A)) << 0) |  \
+                            (((Uint32)(B)) << 8) |  \
+                            (((Uint32)(C)) << 16) | \
+                            (((Uint32)(D)) << 24))
+
+enum
+{
+    SDL_GAMEPAD_BUTTON_PS5_TOUCHPAD = 11,
+    SDL_GAMEPAD_BUTTON_PS5_MICROPHONE,
+    SDL_GAMEPAD_BUTTON_PS5_LEFT_FUNCTION,
+    SDL_GAMEPAD_BUTTON_PS5_RIGHT_FUNCTION,
+    SDL_GAMEPAD_BUTTON_PS5_LEFT_PADDLE,
+    SDL_GAMEPAD_BUTTON_PS5_RIGHT_PADDLE
+};
+
+typedef enum
+{
+    k_EPS5ReportIdState = 0x01,
+    k_EPS5ReportIdUsbEffects = 0x02,
+    k_EPS5ReportIdBluetoothEffects = 0x31,
+    k_EPS5ReportIdBluetoothState = 0x31,
+} EPS5ReportId;
+
+typedef enum
+{
+    k_EPS5FeatureReportIdCapabilities = 0x03,
+    k_EPS5FeatureReportIdCalibration = 0x05,
+    k_EPS5FeatureReportIdSerialNumber = 0x09,
+    k_EPS5FeatureReportIdFirmwareInfo = 0x20,
+} EPS5FeatureReportId;
+
+typedef struct
+{
+    Uint8 ucLeftJoystickX;
+    Uint8 ucLeftJoystickY;
+    Uint8 ucRightJoystickX;
+    Uint8 ucRightJoystickY;
+    Uint8 rgucButtonsHatAndCounter[3];
+    Uint8 ucTriggerLeft;
+    Uint8 ucTriggerRight;
+} PS5SimpleStatePacket_t;
+
+typedef struct
+{
+    Uint8 ucLeftJoystickX;        // 0
+    Uint8 ucLeftJoystickY;        // 1
+    Uint8 ucRightJoystickX;       // 2
+    Uint8 ucRightJoystickY;       // 3
+    Uint8 ucTriggerLeft;          // 4
+    Uint8 ucTriggerRight;         // 5
+    Uint8 ucCounter;              // 6
+    Uint8 rgucButtonsAndHat[4];   // 7
+    Uint8 rgucPacketSequence[4];  // 11 - 32 bit little endian
+    Uint8 rgucGyroX[2];           // 15
+    Uint8 rgucGyroY[2];           // 17
+    Uint8 rgucGyroZ[2];           // 19
+    Uint8 rgucAccelX[2];          // 21
+    Uint8 rgucAccelY[2];          // 23
+    Uint8 rgucAccelZ[2];          // 25
+    Uint8 rgucSensorTimestamp[4]; // 27 - 16/32 bit little endian
+
+} PS5StatePacketCommon_t;
+
+typedef struct
+{
+    Uint8 ucLeftJoystickX;        // 0
+    Uint8 ucLeftJoystickY;        // 1
+    Uint8 ucRightJoystickX;       // 2
+    Uint8 ucRightJoystickY;       // 3
+    Uint8 ucTriggerLeft;          // 4
+    Uint8 ucTriggerRight;         // 5
+    Uint8 ucCounter;              // 6
+    Uint8 rgucButtonsAndHat[4];   // 7
+    Uint8 rgucPacketSequence[4];  // 11 - 32 bit little endian
+    Uint8 rgucGyroX[2];           // 15
+    Uint8 rgucGyroY[2];           // 17
+    Uint8 rgucGyroZ[2];           // 19
+    Uint8 rgucAccelX[2];          // 21
+    Uint8 rgucAccelY[2];          // 23
+    Uint8 rgucAccelZ[2];          // 25
+    Uint8 rgucSensorTimestamp[4]; // 27 - 32 bit little endian
+    Uint8 ucSensorTemp;           // 31
+    Uint8 ucTouchpadCounter1;     // 32 - high bit clear + counter
+    Uint8 rgucTouchpadData1[3];   // 33 - X/Y, 12 bits per axis
+    Uint8 ucTouchpadCounter2;     // 36 - high bit clear + counter
+    Uint8 rgucTouchpadData2[3];   // 37 - X/Y, 12 bits per axis
+    Uint8 rgucUnknown1[8];        // 40
+    Uint8 rgucTimer2[4];          // 48 - 32 bit little endian
+    Uint8 ucBatteryLevel;         // 52
+    Uint8 ucConnectState;         // 53 - 0x08 = USB, 0x01 = headphone
+
+    // There's more unknown data at the end, and a 32-bit CRC on Bluetooth
+} PS5StatePacket_t;
+
+typedef struct
+{
+    Uint8 ucLeftJoystickX;        // 0
+    Uint8 ucLeftJoystickY;        // 1
+    Uint8 ucRightJoystickX;       // 2
+    Uint8 ucRightJoystickY;       // 3
+    Uint8 ucTriggerLeft;          // 4
+    Uint8 ucTriggerRight;         // 5
+    Uint8 ucCounter;              // 6
+    Uint8 rgucButtonsAndHat[4];   // 7
+    Uint8 rgucPacketSequence[4];  // 11 - 32 bit little endian
+    Uint8 rgucGyroX[2];           // 15
+    Uint8 rgucGyroY[2];           // 17
+    Uint8 rgucGyroZ[2];           // 19
+    Uint8 rgucAccelX[2];          // 21
+    Uint8 rgucAccelY[2];          // 23
+    Uint8 rgucAccelZ[2];          // 25
+    Uint8 rgucSensorTimestamp[2]; // 27 - 16 bit little endian
+    Uint8 ucBatteryLevel;         // 29
+    Uint8 ucUnknown;              // 30
+    Uint8 ucTouchpadCounter1;     // 31 - high bit clear + counter
+    Uint8 rgucTouchpadData1[3];   // 32 - X/Y, 12 bits per axis
+    Uint8 ucTouchpadCounter2;     // 35 - high bit clear + counter
+    Uint8 rgucTouchpadData2[3];   // 36 - X/Y, 12 bits per axis
+
+    // There's more unknown data at the end, and a 32-bit CRC on Bluetooth
+} PS5StatePacketAlt_t;
+
+typedef struct
+{
+    Uint8 ucEnableBits1;              // 0
+    Uint8 ucEnableBits2;              // 1
+    Uint8 ucRumbleRight;              // 2
+    Uint8 ucRumbleLeft;               // 3
+    Uint8 ucHeadphoneVolume;          // 4
+    Uint8 ucSpeakerVolume;            // 5
+    Uint8 ucMicrophoneVolume;         // 6
+    Uint8 ucAudioEnableBits;          // 7
+    Uint8 ucMicLightMode;             // 8
+    Uint8 ucAudioMuteBits;            // 9
+    Uint8 rgucRightTriggerEffect[11]; // 10
+    Uint8 rgucLeftTriggerEffect[11];  // 21
+    Uint8 rgucUnknown1[6];            // 32
+    Uint8 ucEnableBits3;              // 38
+    Uint8 rgucUnknown2[2];            // 39
+    Uint8 ucLedAnim;                  // 41
+    Uint8 ucLedBrightness;            // 42
+    Uint8 ucPadLights;                // 43
+    Uint8 ucLedRed;                   // 44
+    Uint8 ucLedGreen;                 // 45
+    Uint8 ucLedBlue;                  // 46
+} DS5EffectsState_t;
+
+typedef enum
+{
+    k_EDS5EffectRumbleStart = (1 << 0),
+    k_EDS5EffectRumble = (1 << 1),
+    k_EDS5EffectLEDReset = (1 << 2),
+    k_EDS5EffectLED = (1 << 3),
+    k_EDS5EffectPadLights = (1 << 4),
+    k_EDS5EffectMicLight = (1 << 5)
+} EDS5Effect;
+
+typedef enum
+{
+    k_EDS5LEDResetStateNone,
+    k_EDS5LEDResetStatePending,
+    k_EDS5LEDResetStateComplete,
+} EDS5LEDResetState;
+
+typedef struct
+{
+    Sint16 bias;
+    float sensitivity;
+} IMUCalibrationData;
+
+/* Rumble hint mode:
+ * "0": enhanced features are never used
+ * "1": enhanced features are always used
+ * "auto": enhanced features are advertised to the application, but SDL doesn't touch the controller state unless the application explicitly requests it.
+ */
+typedef enum
+{
+    PS5_ENHANCED_REPORT_HINT_OFF,
+    PS5_ENHANCED_REPORT_HINT_ON,
+    PS5_ENHANCED_REPORT_HINT_AUTO
+} HIDAPI_PS5_EnhancedReportHint;
+
+typedef struct
+{
+    SDL_HIDAPI_Device *device;
+    SDL_Joystick *joystick;
+    bool is_nacon_dongle;
+    bool use_alternate_report;
+    bool sensors_supported;
+    bool lightbar_supported;
+    bool vibration_supported;
+    bool playerled_supported;
+    bool touchpad_supported;
+    bool effects_supported;
+    HIDAPI_PS5_EnhancedReportHint enhanced_report_hint;
+    bool enhanced_reports;
+    bool enhanced_mode;
+    bool enhanced_mode_available;
+    bool report_sensors;
+    bool report_touchpad;
+    bool report_battery;
+    bool hardware_calibration;
+    IMUCalibrationData calibration[6];
+    Uint16 firmware_version;
+    Uint64 last_packet;
+    int player_index;
+    bool player_lights;
+    Uint8 rumble_left;
+    Uint8 rumble_right;
+    bool color_set;
+    Uint8 led_red;
+    Uint8 led_green;
+    Uint8 led_blue;
+    EDS5LEDResetState led_reset_state;
+    Uint64 sensor_ticks;
+    Uint32 last_tick;
+    union
+    {
+        PS5SimpleStatePacket_t simple;
+        PS5StatePacketCommon_t state;
+        PS5StatePacketAlt_t alt_state;
+        PS5StatePacket_t full_state;
+        Uint8 data[64];
+    } last_state;
+} SDL_DriverPS5_Context;
+
+static bool HIDAPI_DriverPS5_InternalSendJoystickEffect(SDL_DriverPS5_Context *ctx, const void *effect, int size, bool application_usage);
+
+static void HIDAPI_DriverPS5_RegisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_PS5, callback, userdata);
+}
+
+static void HIDAPI_DriverPS5_UnregisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_PS5, callback, userdata);
+}
+
+static bool HIDAPI_DriverPS5_IsEnabled(void)
+{
+    return SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_PS5, SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI, SDL_HIDAPI_DEFAULT));
+}
+
+static int ReadFeatureReport(SDL_hid_device *dev, Uint8 report_id, Uint8 *report, size_t length)
+{
+    SDL_memset(report, 0, length);
+    report[0] = report_id;
+    return SDL_hid_get_feature_report(dev, report, length);
+}
+
+static bool HIDAPI_DriverPS5_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)
+{
+    Uint8 data[USB_PACKET_LENGTH];
+    int size;
+
+    if (type == SDL_GAMEPAD_TYPE_PS5) {
+        return true;
+    }
+
+    if (HIDAPI_SupportsPlaystationDetection(vendor_id, product_id)) {
+        if (device && device->dev) {
+            size = ReadFeatureReport(device->dev, k_EPS5FeatureReportIdCapabilities, data, sizeof(data));
+            if (size == 48 && data[2] == 0x28) {
+                // Supported third party controller
+                return true;
+            } else {
+                return false;
+            }
+        } else {
+            // Might be supported by this driver, enumerate and find out
+            return true;
+        }
+    }
+    return false;
+}
+
+static void SetLedsForPlayerIndex(DS5EffectsState_t *effects, int player_index)
+{
+    /* This list is the same as what hid-sony.c uses in the Linux kernel.
+       The first 4 values correspond to what the PS4 assigns.
+    */
+    static const Uint8 colors[7][3] = {
+        { 0x00, 0x00, 0x40 }, // Blue
+        { 0x40, 0x00, 0x00 }, // Red
+        { 0x00, 0x40, 0x00 }, // Green
+        { 0x20, 0x00, 0x20 }, // Pink
+        { 0x20, 0x10, 0x00 }, // Orange
+        { 0x00, 0x10, 0x10 }, // Teal
+        { 0x10, 0x10, 0x10 }  // White
+    };
+
+    if (player_index >= 0) {
+        player_index %= SDL_arraysize(colors);
+    } else {
+        player_index = 0;
+    }
+
+    effects->ucLedRed = colors[player_index][0];
+    effects->ucLedGreen = colors[player_index][1];
+    effects->ucLedBlue = colors[player_index][2];
+}
+
+static void SetLightsForPlayerIndex(DS5EffectsState_t *effects, int player_index)
+{
+    static const Uint8 lights[] = {
+        0x04,
+        0x0A,
+        0x15,
+        0x1B,
+        0x1F
+    };
+
+    if (player_index >= 0) {
+        // Bitmask, 0x1F enables all lights, 0x20 changes instantly instead of fade
+        player_index %= SDL_arraysize(lights);
+        effects->ucPadLights = lights[player_index] | 0x20;
+    } else {
+        effects->ucPadLights = 0x00;
+    }
+}
+
+static bool HIDAPI_DriverPS5_InitDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverPS5_Context *ctx;
+    Uint8 data[USB_PACKET_LENGTH * 2];
+    int size;
+    char serial[18];
+    SDL_JoystickType joystick_type = SDL_JOYSTICK_TYPE_GAMEPAD;
+
+    ctx = (SDL_DriverPS5_Context *)SDL_calloc(1, sizeof(*ctx));
+    if (!ctx) {
+        return false;
+    }
+    ctx->device = device;
+
+    device->context = ctx;
+
+    if (device->serial && SDL_strlen(device->serial) == 12) {
+        int i, j;
+
+        j = -1;
+        for (i = 0; i < 12; i += 2) {
+            j += 1;
+            SDL_memmove(&serial[j], &device->serial[i], 2);
+            j += 2;
+            serial[j] = '-';
+        }
+        serial[j] = '\0';
+    } else {
+        serial[0] = '\0';
+    }
+
+    // Read a report to see what mode we're in
+    size = SDL_hid_read_timeout(device->dev, data, sizeof(data), 16);
+#ifdef DEBUG_PS5_PROTOCOL
+    if (size > 0) {
+        HIDAPI_DumpPacket("PS5 first packet: size = %d", data, size);
+    } else {
+        SDL_Log("PS5 first packet: size = %d", size);
+    }
+#endif
+    if (size == 64) {
+        // Connected over USB
+        ctx->enhanced_reports = true;
+    } else if (size > 0 && data[0] == k_EPS5ReportIdBluetoothEffects) {
+        // Connected over Bluetooth, using enhanced reports
+        ctx->enhanced_reports = true;
+    } else {
+        // Connected over Bluetooth, using simple reports (DirectInput enabled)
+    }
+
+    if (device->vendor_id == USB_VENDOR_SONY && ctx->enhanced_reports) {
+        /* Read the serial number (Bluetooth address in reverse byte order)
+           This will also enable enhanced reports over Bluetooth
+        */
+        if (ReadFeatureReport(device->dev, k_EPS5FeatureReportIdSerialNumber, data, sizeof(data)) >= 7) {
+            (void)SDL_snprintf(serial, sizeof(serial), "%.2x-%.2x-%.2x-%.2x-%.2x-%.2x",
+                               data[6], data[5], data[4], data[3], data[2], data[1]);
+        }
+
+        /* Read the firmware version
+           This will also enable enhanced reports over Bluetooth
+        */
+        if (ReadFeatureReport(device->dev, k_EPS5FeatureReportIdFirmwareInfo, data, USB_PACKET_LENGTH) >= 46) {
+            ctx->firmware_version = (Uint16)data[44] | ((Uint16)data[45] << 8);
+        }
+    }
+
+    // Get the device capabilities
+    if (device->vendor_id == USB_VENDOR_SONY) {
+        ctx->sensors_supported = true;
+        ctx->lightbar_supported = true;
+        ctx->vibration_supported = true;
+        ctx->playerled_supported = true;
+        ctx->touchpad_supported = true;
+    } else {
+        // Third party controller capability request
+        size = ReadFeatureReport(device->dev, k_EPS5FeatureReportIdCapabilities, data, sizeof(data));
+        if (size == 48 && data[2] == 0x28) {
+            Uint8 capabilities = data[4];
+            Uint8 capabilities2 = data[20];
+            Uint8 device_type = data[5];
+
+#ifdef DEBUG_PS5_PROTOCOL
+            HIDAPI_DumpPacket("PS5 capabilities: size = %d", data, size);
+#endif
+            if (capabilities & 0x02) {
+                ctx->sensors_supported = true;
+            }
+            if (capabilities & 0x04) {
+                ctx->lightbar_supported = true;
+            }
+            if (capabilities & 0x08) {
+                ctx->vibration_supported = true;
+            }
+            if (capabilities & 0x40) {
+                ctx->touchpad_supported = true;
+            }
+            if (capabilities2 & 0x80) {
+                ctx->playerled_supported = true;
+            }
+
+            switch (device_type) {
+            case 0x00:
+                joystick_type = SDL_JOYSTICK_TYPE_GAMEPAD;
+                break;
+            case 0x01:
+                joystick_type = SDL_JOYSTICK_TYPE_GUITAR;
+                break;
+            case 0x02:
+                joystick_type = SDL_JOYSTICK_TYPE_DRUM_KIT;
+                break;
+            case 0x06:
+                joystick_type = SDL_JOYSTICK_TYPE_WHEEL;
+                break;
+            case 0x07:
+                joystick_type = SDL_JOYSTICK_TYPE_ARCADE_STICK;
+                break;
+            case 0x08:
+                joystick_type = SDL_JOYSTICK_TYPE_FLIGHT_STICK;
+                break;
+            default:
+                joystick_type = SDL_JOYSTICK_TYPE_UNKNOWN;
+                break;
+            }
+
+            ctx->use_alternate_report = true;
+
+            if (device->vendor_id == USB_VENDOR_NACON_ALT &&
+                (device->product_id == USB_PRODUCT_NACON_REVOLUTION_5_PRO_PS5_WIRED ||
+                 device->product_id == USB_PRODUCT_NACON_REVOLUTION_5_PRO_PS5_WIRELESS)) {
+                // This doesn't report vibration capability, but it can do rumble
+                ctx->vibration_supported = true;
+            }
+        } else if (device->vendor_id == USB_VENDOR_RAZER &&
+                   (device->product_id == USB_PRODUCT_RAZER_WOLVERINE_V2_PRO_PS5_WIRED ||
+                    device->product_id == USB_PRODUCT_RAZER_WOLVERINE_V2_PRO_PS5_WIRELESS)) {
+            // The Razer Wolverine V2 Pro doesn't respond to the detection protocol, but has a touchpad and sensors and no vibration
+            ctx->sensors_supported = true;
+            ctx->touchpad_supported = true;
+            ctx->use_alternate_report = true;
+        } else if (device->vendor_id == USB_VENDOR_RAZER &&
+                   device->product_id == USB_PRODUCT_RAZER_KITSUNE) {
+            // The Razer Kitsune doesn't respond to the detection protocol, but has a touchpad
+            joystick_type = SDL_JOYSTICK_TYPE_ARCADE_STICK;
+            ctx->touchpad_supported = true;
+            ctx->use_alternate_report = true;
+        }
+    }
+    ctx->effects_supported = (ctx->lightbar_supported || ctx->vibration_supported || ctx->playerled_supported);
+
+    if (device->vendor_id == USB_VENDOR_NACON_ALT &&
+        device->product_id == USB_PRODUCT_NACON_REVOLUTION_5_PRO_PS5_WIRELESS) {
+        ctx->is_nacon_dongle = true;
+    }
+
+    device->joystick_type = joystick_type;
+    device->type = SDL_GAMEPAD_TYPE_PS5;
+    if (device->vendor_id == USB_VENDOR_SONY) {
+        if (SDL_IsJoystickDualSenseEdge(device->vendor_id, device->product_id)) {
+            HIDAPI_SetDeviceName(device, "DualSense Edge Wireless Controller");
+        } else {
+            HIDAPI_SetDeviceName(device, "DualSense Wireless Controller");
+        }
+    }
+    HIDAPI_SetDeviceSerial(device, serial);
+
+    if (ctx->is_nacon_dongle) {
+        // We don't know if this is connected yet, wait for reports
+        return true;
+    }
+
+    // Prefer the USB device over the Bluetooth device
+    if (device->is_bluetooth) {
+        if (HIDAPI_HasConnectedUSBDevice(device->serial)) {
+            return true;
+        }
+    } else {
+        HIDAPI_DisconnectBluetoothDevice(device->serial);
+    }
+    return HIDAPI_JoystickConnected(device, NULL);
+}
+
+static int HIDAPI_DriverPS5_GetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id)
+{
+    return -1;
+}
+
+static void HIDAPI_DriverPS5_LoadCalibrationData(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverPS5_Context *ctx = (SDL_DriverPS5_Context *)device->context;
+    int i, size;
+    Uint8 data[USB_PACKET_LENGTH];
+
+    size = ReadFeatureReport(device->dev, k_EPS5FeatureReportIdCalibration, data, sizeof(data));
+    if (size < 35) {
+#ifdef DEBUG_PS5_CALIBRATION
+        SDL_Log("Short read of calibration data: %d, ignoring calibration", size);
+#endif
+        return;
+    }
+
+    {
+        Sint16 sGyroPitchBias, sGyroYawBias, sGyroRollBias;
+        Sint16 sGyroPitchPlus, sGyroPitchMinus;
+        Sint16 sGyroYawPlus, sGyroYawMinus;
+        Sint16 sGyroRollPlus, sGyroRollMinus;
+        Sint16 sGyroSpeedPlus, sGyroSpeedMinus;
+
+        Sint16 sAccXPlus, sAccXMinus;
+        Sint16 sAccYPlus, sAccYMinus;
+        Sint16 sAccZPlus, sAccZMinus;
+
+        float flNumerator;
+        Sint16 sRange2g;
+
+#ifdef DEBUG_PS5_CALIBRATION
+        HIDAPI_DumpPacket("PS5 calibration packet: size = %d", data, size);
+#endif
+
+        sGyroPitchBias = LOAD16(data[1], data[2]);
+        sGyroYawBias = LOAD16(data[3], data[4]);
+        sGyroRollBias = LOAD16(data[5], data[6]);
+
+        sGyroPitchPlus = LOAD16(data[7], data[8]);
+        sGyroPitchMinus = LOAD16(data[9], data[10]);
+        sGyroYawPlus = LOAD16(data[11], data[12]);
+        sGyroYawMinus = LOAD16(data[13], data[14]);
+        sGyroRollPlus = LOAD16(data[15], data[16]);
+        sGyroRollMinus = LOAD16(data[17], data[18]);
+
+        sGyroSpeedPlus = LOAD16(data[19], data[20]);
+        sGyroSpeedMinus = LOAD16(data[21], data[22]);
+
+        sAccXPlus = LOAD16(data[23], data[24]);
+        sAccXMinus = LOAD16(data[25], data[26]);
+        sAccYPlus = LOAD16(data[27], data[28]);
+        sAccYMinus = LOAD16(data[29], data[30]);
+        sAccZPlus = LOAD16(data[31], data[32]);
+        sAccZMinus = LOAD16(data[33], data[34]);
+
+        flNumerator = (sGyroSpeedPlus + sGyroSpeedMinus) * GYRO_RES_PER_DEGREE;
+        ctx->calibration[0].bias = sGyroPitchBias;
+        ctx->calibration[0].sensitivity = flNumerator / (sGyroPitchPlus - sGyroPitchMinus);
+
+        ctx->calibration[1].bias = sGyroYawBias;
+        ctx->calibration[1].sensitivity = flNumerator / (sGyroYawPlus - sGyroYawMinus);
+
+        ctx->calibration[2].bias = sGyroRollBias;
+        ctx->calibration[2].sensitivity = flNumerator / (sGyroRollPlus - sGyroRollMinus);
+
+        sRange2g = sAccXPlus - sAccXMinus;
+        ctx->calibration[3].bias = sAccXPlus - sRange2g / 2;
+        ctx->calibration[3].sensitivity = 2.0f * ACCEL_RES_PER_G / (float)sRange2g;
+
+        sRange2g = sAccYPlus - sAccYMinus;
+        ctx->calibration[4].bias = sAccYPlus - sRange2g / 2;
+        ctx->calibration[4].sensitivity = 2.0f * ACCEL_RES_PER_G / (float)sRange2g;
+
+        sRange2g = sAccZPlus - sAccZMinus;
+        ctx->calibration[5].bias = sAccZPlus - sRange2g / 2;
+        ctx->calibration[5].sensitivity = 2.0f * ACCEL_RES_PER_G / (float)sRange2g;
+
+        ctx->hardware_calibration = true;
+        for (i = 0; i < 6; ++i) {
+            float divisor = (i < 3 ? 64.0f : 1.0f);
+#ifdef DEBUG_PS5_CALIBRATION
+            SDL_Log("calibration[%d] bias = %d, sensitivity = %f", i, ctx->calibration[i].bias, ctx->calibration[i].sensitivity);
+#endif
+            // Some controllers have a bad calibration
+            if ((SDL_abs(ctx->calibration[i].bias) > 1024) || (SDL_fabsf(1.0f - ctx->calibration[i].sensitivity / divisor) > 0.5f)) {
+#ifdef DEBUG_PS5_CALIBRATION
+                SDL_Log("invalid calibration, ignoring");
+#endif
+                ctx->hardware_calibration = false;
+            }
+        }
+    }
+}
+
+static float HIDAPI_DriverPS5_ApplyCalibrationData(SDL_DriverPS5_Context *ctx, int index, Sint16 value)
+{
+    float result;
+
+    if (ctx->hardware_calibration) {
+        IMUCalibrationData *calibration = &ctx->calibration[index];
+
+        result = (value - calibration->bias) * calibration->sensitivity;
+    } else if (index < 3) {
+        result = value * 64.f;
+    } else {
+        result = value;
+    }
+
+    // Convert the raw data to the units expected by SDL
+    if (index < 3) {
+        result = (result / GYRO_RES_PER_DEGREE) * SDL_PI_F / 180.0f;
+    } else {
+        result = (result / ACCEL_RES_PER_G) * SDL_STANDARD_GRAVITY;
+    }
+    return result;
+}
+
+static bool HIDAPI_DriverPS5_UpdateEffects(SDL_DriverPS5_Context *ctx, int effect_mask, bool application_usage)
+{
+    DS5EffectsState_t effects;
+
+    // Make sure the Bluetooth connection sequence has completed before sending LED color change
+    if (ctx->device->is_bluetooth && ctx->enhanced_reports &&
+        (effect_mask & (k_EDS5EffectLED | k_EDS5EffectPadLights)) != 0) {
+        if (ctx->led_reset_state != k_EDS5LEDResetStateComplete) {
+            ctx->led_reset_state = k_EDS5LEDResetStatePending;
+            return true;
+        }
+    }
+
+    SDL_zero(effects);
+
+    if (ctx->vibration_supported) {
+        if (ctx->rumble_left || ctx->rumble_right) {
+            if (ctx->firmware_version < 0x0224) {
+                effects.ucEnableBits1 |= 0x01; // Enable rumble emulation
+
+                // Shift to reduce effective rumble strength to match Xbox controllers
+                effects.ucRumbleLeft = ctx->rumble_left >> 1;
+                effects.ucRumbleRight = ctx->rumble_right >> 1;
+            } else {
+                effects.ucEnableBits3 |= 0x04; // Enable improved rumble emulation on 2.24 firmware and newer
+
+                effects.ucRumbleLeft = ctx->rumble_left;
+                effects.ucRumbleRight = ctx->rumble_right;
+            }
+            effects.ucEnableBits1 |= 0x02; // Disable audio haptics
+        } else {
+            // Leaving emulated rumble bits off will restore audio haptics
+        }
+
+        if ((effect_mask & k_EDS5EffectRumbleStart) != 0) {
+            effects.ucEnableBits1 |= 0x02; // Disable audio haptics
+        }
+        if ((effect_mask & k_EDS5EffectRumble) != 0) {
+            // Already handled above
+        }
+    }
+    if (ctx->lightbar_supported) {
+        if ((effect_mask & k_EDS5EffectLEDReset) != 0) {
+            effects.ucEnableBits2 |= 0x08; // Reset LED state
+        }
+        if ((effect_mask & k_EDS5EffectLED) != 0) {
+            effects.ucEnableBits2 |= 0x04; // Enable LED color
+
+            // Populate the LED state with the appropriate color from our lookup table
+            if (ctx->color_set) {
+                effects.ucLedRed = ctx->led_red;
+                effects.ucLedGreen = ctx->led_green;
+                effects.ucLedBlue = ctx->led_blue;
+            } else {
+                SetLedsForPlayerIndex(&effects, ctx->player_index);
+            }
+        }
+    }
+    if (ctx->playerled_supported) {
+        if ((effect_mask & k_EDS5EffectPadLights) != 0) {
+            effects.ucEnableBits2 |= 0x10; // Enable touchpad lights
+
+            if (ctx->player_lights) {
+                SetLightsForPlayerIndex(&effects, ctx->player_index);
+            } else {
+                effects.ucPadLights = 0x00;
+            }
+        }
+    }
+    if ((effect_mask & k_EDS5EffectMicLight) != 0) {
+        effects.ucEnableBits2 |= 0x01; // Enable microphone light
+
+        effects.ucMicLightMode = 0; // Bitmask, 0x00 = off, 0x01 = solid, 0x02 = pulse
+    }
+
+    return HIDAPI_DriverPS5_InternalSendJoystickEffect(ctx, &effects, sizeof(effects), application_usage);
+}
+
+static void HIDAPI_DriverPS5_CheckPendingLEDReset(SDL_DriverPS5_Context *ctx)
+{
+    bool led_reset_complete = false;
+
+    if (ctx->enhanced_reports && ctx->sensors_supported && !ctx->use_alternate_report) {
+        const PS5StatePacketCommon_t *packet = &ctx->last_state.state;
+
+        // Check the timer to make sure the Bluetooth connection LED animation is complete
+        const Uint32 connection_complete = 10200000;
+        Uint32 timestamp = LOAD32(packet->rgucSensorTimestamp[0],
+                                  packet->rgucSensorTimestamp[1],
+                                  packet->rgucSensorTimestamp[2],
+                                  packet->rgucSensorTimestamp[3]);
+        if (timestamp >= connection_complete) {
+            led_reset_complete = true;
+        }
+    } else {
+        // We don't know how to check the timer, just assume it's complete for now
+        led_reset_complete = true;
+    }
+
+    if (led_reset_complete) {
+        HIDAPI_DriverPS5_UpdateEffects(ctx, k_EDS5EffectLEDReset, false);
+
+        ctx->led_reset_state = k_EDS5LEDResetStateComplete;
+
+        HIDAPI_DriverPS5_UpdateEffects(ctx, (k_EDS5EffectLED | k_EDS5EffectPadLights), false);
+    }
+}
+
+static void HIDAPI_DriverPS5_TickleBluetooth(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverPS5_Context *ctx = (SDL_DriverPS5_Context *)device->context;
+
+    if (ctx->enhanced_reports) {
+        // This is just a dummy packet that should have no effect, since we don't set the CRC
+        Uint8 data[78];
+
+        SDL_zeroa(data);
+
+        data[0] = k_EPS5ReportIdBluetoothEffects;
+        data[1] = 0x02; // Magic value
+
+        if (SDL_HIDAPI_LockRumble()) {
+            SDL_HIDAPI_SendRumbleAndUnlock(device, data, sizeof(data));
+        }
+    } else {
+        // We can't even send an invalid effects packet, or it will put the controller in enhanced mode
+        if (device->num_joysticks > 0) {
+            HIDAPI_JoystickDisconnected(device, device->joysticks[0]);
+        }
+    }
+}
+
+static void HIDAPI_DriverPS5_SetEnhancedModeAvailable(SDL_DriverPS5_Context *ctx)
+{
+    if (ctx->enhanced_mode_available) {
+        return;
+    }
+    ctx->enhanced_mode_available = true;
+
+    if (ctx->touchpad_supported) {
+        SDL_PrivateJoystickAddTouchpad(ctx->joystick, 2);
+        ctx->report_touchpad = true;
+    }
+
+    if (ctx->sensors_supported) {
+        if (ctx->device->is_bluetooth) {
+            // Bluetooth sensor update rate appears to be 1000 Hz
+            SDL_PrivateJoystickAddSensor(ctx->joystick, SDL_SENSOR_GYRO, 1000.0f);
+            SDL_PrivateJoystickAddSensor(ctx->joystick, SDL_SENSOR_ACCEL, 1000.0f);
+        } else {
+            SDL_PrivateJoystickAddSensor(ctx->joystick, SDL_SENSOR_GYRO, 250.0f);
+            SDL_PrivateJoystickAddSensor(ctx->joystick, SDL_SENSOR_ACCEL, 250.0f);
+        }
+    }
+
+    ctx->report_battery = true;
+
+    HIDAPI_UpdateDeviceProperties(ctx->device);
+}
+
+static void HIDAPI_DriverPS5_SetEnhancedMode(SDL_DriverPS5_Context *ctx)
+{
+    HIDAPI_DriverPS5_SetEnhancedModeAvailable(ctx);
+
+    if (!ctx->enhanced_mode) {
+        ctx->enhanced_mode = true;
+
+        // Switch into enhanced report mode
+        HIDAPI_DriverPS5_UpdateEffects(ctx, 0, false);
+
+        // Update the light effects
+        HIDAPI_DriverPS5_UpdateEffects(ctx, (k_EDS5EffectLED | k_EDS5EffectPadLights), false);
+    }
+}
+
+static void HIDAPI_DriverPS5_SetEnhancedReportHint(SDL_DriverPS5_Context *ctx, HIDAPI_PS5_EnhancedReportHint enhanced_report_hint)
+{
+    switch (enhanced_report_hint) {
+    case PS5_ENHANCED_REPORT_HINT_OFF:
+        // Nothing to do, enhanced mode is a one-way ticket
+        break;
+    case PS5_ENHANCED_REPORT_HINT_ON:
+        HIDAPI_DriverPS5_SetEnhancedMode(ctx);
+        break;
+    case PS5_ENHANCED_REPORT_HINT_AUTO:
+        HIDAPI_DriverPS5_SetEnhancedModeAvailable(ctx);
+        break;
+    }
+    ctx->enhanced_report_hint = enhanced_report_hint;
+}
+
+static void HIDAPI_DriverPS5_UpdateEnhancedModeOnEnhancedReport(SDL_DriverPS5_Context *ctx)
+{
+    ctx->enhanced_reports = true;
+
+    if (ctx->enhanced_report_hint == PS5_ENHANCED_REPORT_HINT_AUTO) {
+        HIDAPI_DriverPS5_SetEnhancedReportHint(ctx, PS5_ENHANCED_REPORT_HINT_ON);
+    }
+}
+
+static void HIDAPI_DriverPS5_UpdateEnhancedModeOnApplicationUsage(SDL_DriverPS5_Context *ctx)
+{
+    if (ctx->enhanced_report_hint == PS5_ENHANCED_REPORT_HINT_AUTO) {
+        HIDAPI_DriverPS5_SetEnhancedReportHint(ctx, PS5_ENHANCED_REPORT_HINT_ON);
+    }
+}
+
+static void SDLCALL SDL_PS5EnhancedReportsChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
+{
+    SDL_DriverPS5_Context *ctx = (SDL_DriverPS5_Context *)userdata;
+
+    if (ctx->device->is_bluetooth) {
+        if (hint && SDL_strcasecmp(hint, "auto") == 0) {
+            HIDAPI_DriverPS5_SetEnhancedReportHint(ctx, PS5_ENHANCED_REPORT_HINT_AUTO);
+        } else if (SDL_GetStringBoolean(hint, true)) {
+            HIDAPI_DriverPS5_SetEnhancedReportHint(ctx, PS5_ENHANCED_REPORT_HINT_ON);
+        } else {
+            HIDAPI_DriverPS5_SetEnhancedReportHint(ctx, PS5_ENHANCED_REPORT_HINT_OFF);
+        }
+    } else {
+        HIDAPI_DriverPS5_SetEnhancedReportHint(ctx, PS5_ENHANCED_REPORT_HINT_ON);
+    }
+}
+
+static void SDLCALL SDL_PS5PlayerLEDHintChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
+{
+    SDL_DriverPS5_Context *ctx = (SDL_DriverPS5_Context *)userdata;
+    bool player_lights = SDL_GetStringBoolean(hint, true);
+
+    if (player_lights != ctx->player_lights) {
+        ctx->player_lights = player_lights;
+
+        HIDAPI_DriverPS5_UpdateEffects(ctx, k_EDS5EffectPadLights, false);
+    }
+}
+
+static void HIDAPI_DriverPS5_SetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id, int player_index)
+{
+    SDL_DriverPS5_Context *ctx = (SDL_DriverPS5_Context *)device->context;
+
+    if (!ctx->joystick) {
+        return;
+    }
+
+    ctx->player_index = player_index;
+
+    // This will set the new LED state based on the new player index
+    // SDL automatically calls this, so it doesn't count as an application action to enable enhanced mode
+    HIDAPI_DriverPS5_UpdateEffects(ctx, (k_EDS5EffectLED | k_EDS5EffectPadLights), false);
+}
+
+static bool HIDAPI_DriverPS5_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverPS5_Context *ctx = (SDL_DriverPS5_Context *)device->context;
+
+    SDL_AssertJoysticksLocked();
+
+    ctx->joystick = joystick;
+    ctx->last_packet = SDL_GetTicks();
+    ctx->report_sensors = false;
+    ctx->report_touchpad = false;
+    ctx->rumble_left = 0;
+    ctx->rumble_right = 0;
+    ctx->color_set = false;
+    ctx->led_reset_state = k_EDS5LEDResetStateNone;
+    SDL_zero(ctx->last_state);
+
+    // Initialize player index (needed for setting LEDs)
+    ctx->player_index = SDL_GetJoystickPlayerIndex(joystick);
+    ctx->player_lights = SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_PS5_PLAYER_LED, true);
+
+    // Initialize the joystick capabilities
+    if (SDL_IsJoystickDualSenseEdge(device->vendor_id, device->product_id)) {
+        joystick->nbuttons = 17; // paddles and touchpad and microphone
+    } else if (ctx->touchpad_supported) {
+        joystick->nbuttons = 13; // touchpad and microphone
+    } else {
+        joystick->nbuttons = 11;
+    }
+    joystick->naxes = SDL_GAMEPAD_AXIS_COUNT;
+    joystick->nhats = 1;
+    joystick->firmware_version = ctx->firmware_version;
+
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_ENHANCED_REPORTS,
+                        SDL_PS5EnhancedReportsChanged, ctx);
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_PS5_PLAYER_LED,
+                        SDL_PS5PlayerLEDHintChanged, ctx);
+
+    return true;
+}
+
+static bool HIDAPI_DriverPS5_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+    SDL_DriverPS5_Context *ctx = (SDL_DriverPS5_Context *)device->context;
+
+    if (!ctx->vibration_supported) {
+        return SDL_Unsupported();
+    }
+
+    if (!ctx->rumble_left && !ctx->rumble_right) {
+        HIDAPI_DriverPS5_UpdateEffects(ctx, k_EDS5EffectRumbleStart, true);
+    }
+
+    ctx->rumble_left = (low_frequency_rumble >> 8);
+    ctx->rumble_right = (high_frequency_rumble >> 8);
+
+    return HIDAPI_DriverPS5_UpdateEffects(ctx, k_EDS5EffectRumble, true);
+}
+
+static bool HIDAPI_DriverPS5_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
+{
+    return SDL_Unsupported();
+}
+
+static Uint32 HIDAPI_DriverPS5_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverPS5_Context *ctx = (SDL_DriverPS5_Context *)device->context;
+    Uint32 result = 0;
+
+    if (ctx->enhanced_mode_available) {
+        if (ctx->lightbar_supported) {
+            result |= SDL_JOYSTICK_CAP_RGB_LED;
+        }
+        if (ctx->playerled_supported) {
+            result |= SDL_JOYSTICK_CAP_PLAYER_LED;
+        }
+        if (ctx->vibration_supported) {
+            result |= SDL_JOYSTICK_CAP_RUMBLE;
+        }
+    }
+
+    return result;
+}
+
+static bool HIDAPI_DriverPS5_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    SDL_DriverPS5_Context *ctx = (SDL_DriverPS5_Context *)device->context;
+
+    if (!ctx->lightbar_supported) {
+        return SDL_Unsupported();
+    }
+
+    ctx->color_set = true;
+    ctx->led_red = red;
+    ctx->led_green = green;
+    ctx->led_blue = blue;
+
+    return HIDAPI_DriverPS5_UpdateEffects(ctx, k_EDS5EffectLED, true);
+}
+
+static bool HIDAPI_DriverPS5_InternalSendJoystickEffect(SDL_DriverPS5_Context *ctx, const void *effect, int size, bool application_usage)
+{
+    Uint8 data[78];
+    int report_size, offset;
+    Uint8 *pending_data;
+    int *pending_size;
+    int maximum_size;
+
+    if (!ctx->effects_supported) {
+        // We shouldn't be sending packets to this controller
+        return SDL_Unsupported();
+    }
+
+    if (!ctx->enhanced_mode) {
+        if (application_usage) {
+            HIDAPI_DriverPS5_UpdateEnhancedModeOnApplicationUsage(ctx);
+        }
+
+        if (!ctx->enhanced_mode) {
+            // We're not in enhanced mode, effects aren't allowed
+            return SDL_Unsupported();
+        }
+    }
+
+    SDL_zeroa(data);
+
+    if (ctx->device->is_bluetooth) {
+        data[0] = k_EPS5ReportIdBluetoothEffects;
+        data[1] = 0x02; // Magic value
+
+        report_size = 78;
+        offset = 2;
+    } else {
+        data[0] = k_EPS5ReportIdUsbEffects;
+
+        report_size = 48;
+        offset = 1;
+    }
+
+    SDL_memcpy(&data[offset], effect, SDL_min((sizeof(data) - offset), (size_t)size));
+
+    if (ctx->device->is_bluetooth) {
+        // Bluetooth reports need a CRC at the end of the packet (at least on Linux)
+        Uint8 ubHdr = 0xA2; // hidp header is part of the CRC calculation
+        Uint32 unCRC;
+        unCRC = SDL_crc32(0, &ubHdr, 1);
+        unCRC = SDL_crc32(unCRC, data, (size_t)(report_size - sizeof(unCRC)));
+        SDL_memcpy(&data[report_size - sizeof(unCRC)], &unCRC, sizeof(unCRC));
+    }
+
+    if (!SDL_HIDAPI_LockRumble()) {
+        return false;
+    }
+
+    // See if we can update an existing pending request
+    if (SDL_HIDAPI_GetPendingRumbleLocked(ctx->device, &pending_data, &pending_size, &maximum_size)) {
+        DS5EffectsState_t *effects = (DS5EffectsState_t *)&data[offset];
+        DS5EffectsState_t *pending_effects = (DS5EffectsState_t *)&pending_data[offset];
+        if (report_size == *pending_size &&
+            effects->ucEnableBits1 == pending_effects->ucEnableBits1 &&
+            effects->ucEnableBits2 == pending_effects->ucEnableBits2) {
+            // We're simply updating the data for this request
+            SDL_memcpy(pending_data, data, report_size);
+            SDL_HIDAPI_UnlockRumble();
+            return true;
+        }
+    }
+
+    if (SDL_HIDAPI_SendRumbleAndUnlock(ctx->device, data, report_size) != report_size) {
+        return false;
+    }
+
+    return true;
+}
+
+static bool HIDAPI_DriverPS5_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *effect, int size)
+{
+    SDL_DriverPS5_Context *ctx = (SDL_DriverPS5_Context *)device->context;
+
+    return HIDAPI_DriverPS5_InternalSendJoystickEffect(ctx, effect, size, true);
+}
+
+static bool HIDAPI_DriverPS5_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, bool enabled)
+{
+    SDL_DriverPS5_Context *ctx = (SDL_DriverPS5_Context *)device->context;
+
+    HIDAPI_DriverPS5_UpdateEnhancedModeOnApplicationUsage(ctx);
+
+    if (!ctx->sensors_supported || (enabled && !ctx->enhanced_mode)) {
+        return SDL_Unsupported();
+    }
+
+    if (enabled) {
+        HIDAPI_DriverPS5_LoadCalibrationData(device);
+    }
+    ctx->report_sensors = enabled;
+
+    return true;
+}
+
+static void HIDAPI_DriverPS5_HandleSimpleStatePacket(SDL_Joystick *joystick, SDL_hid_device *dev, SDL_DriverPS5_Context *ctx, PS5SimpleStatePacket_t *packet, Uint64 timestamp)
+{
+    Sint16 axis;
+
+    if (ctx->last_state.simple.rgucButtonsHatAndCounter[0] != packet->rgucButtonsHatAndCounter[0]) {
+        {
+            Uint8 data = (packet->rgucButtonsHatAndCounter[0] >> 4);
+
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_WEST, ((data & 0x01) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SOUTH, ((data & 0x02) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_EAST, ((data & 0x04) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_NORTH, ((data & 0x08) != 0));
+        }
+        {
+            Uint8 data = (packet->rgucButtonsHatAndCounter[0] & 0x0F);
+            Uint8 hat;
+
+            switch (data) {
+            case 0:
+                hat = SDL_HAT_UP;
+                break;
+            case 1:
+                hat = SDL_HAT_RIGHTUP;
+                break;
+            case 2:
+                hat = SDL_HAT_RIGHT;
+                break;
+            case 3:
+                hat = SDL_HAT_RIGHTDOWN;
+                break;
+            case 4:
+                hat = SDL_HAT_DOWN;
+                break;
+            case 5:
+                hat = SDL_HAT_LEFTDOWN;
+                break;
+            case 6:
+                hat = SDL_HAT_LEFT;
+                break;
+            case 7:
+                hat = SDL_HAT_LEFTUP;
+                break;
+            default:
+                hat = SDL_HAT_CENTERED;
+                break;
+            }
+            SDL_SendJoystickHat(timestamp, joystick, 0, hat);
+        }
+    }
+
+    if (ctx->last_state.simple.rgucButtonsHatAndCounter[1] != packet->rgucButtonsHatAndCounter[1]) {
+        Uint8 data = packet->rgucButtonsHatAndCounter[1];
+
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK, ((data & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_STICK, ((data & 0x80) != 0));
+    }
+
+    if (ctx->last_state.simple.rgucButtonsHatAndCounter[2] != packet->rgucButtonsHatAndCounter[2]) {
+        Uint8 data = (packet->rgucButtonsHatAndCounter[2] & 0x03);
+
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_PS5_TOUCHPAD, ((data & 0x02) != 0));
+    }
+
+    if (packet->ucTriggerLeft == 0 && (packet->rgucButtonsHatAndCounter[1] & 0x04)) {
+        axis = SDL_JOYSTICK_AXIS_MAX;
+    } else {
+        axis = ((int)packet->ucTriggerLeft * 257) - 32768;
+    }
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, axis);
+    if (packet->ucTriggerRight == 0 && (packet->rgucButtonsHatAndCounter[1] & 0x08)) {
+        axis = SDL_JOYSTICK_AXIS_MAX;
+    } else {
+        axis = ((int)packet->ucTriggerRight * 257) - 32768;
+    }
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, axis);
+    axis = ((int)packet->ucLeftJoystickX * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, axis);
+    axis = ((int)packet->ucLeftJoystickY * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, axis);
+    axis = ((int)packet->ucRightJoystickX * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, axis);
+    axis = ((int)packet->ucRightJoystickY * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, axis);
+
+    SDL_memcpy(&ctx->last_state.simple, packet, sizeof(ctx->last_state.simple));
+}
+
+static void HIDAPI_DriverPS5_HandleStatePacketCommon(SDL_Joystick *joystick, SDL_hid_device *dev, SDL_DriverPS5_Context *ctx, PS5StatePacketCommon_t *packet, Uint64 timestamp)
+{
+    Sint16 axis;
+
+    if (ctx->last_state.state.rgucButtonsAndHat[0] != packet->rgucButtonsAndHat[0]) {
+        {
+            Uint8 data = (packet->rgucButtonsAndHat[0] >> 4);
+
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_WEST, ((data & 0x01) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SOUTH, ((data & 0x02) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_EAST, ((data & 0x04) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_NORTH, ((data & 0x08) != 0));
+        }
+        {
+            Uint8 data = (packet->rgucButtonsAndHat[0] & 0x0F);
+            Uint8 hat;
+
+            switch (data) {
+            case 0:
+                hat = SDL_HAT_UP;
+                break;
+            case 1:
+                hat = SDL_HAT_RIGHTUP;
+                break;
+            case 2:
+                hat = SDL_HAT_RIGHT;
+                break;
+            case 3:
+                hat = SDL_HAT_RIGHTDOWN;
+                break;
+            case 4:
+                hat = SDL_HAT_DOWN;
+                break;
+            case 5:
+                hat = SDL_HAT_LEFTDOWN;
+                break;
+            case 6:
+                hat = SDL_HAT_LEFT;
+                break;
+            case 7:
+                hat = SDL_HAT_LEFTUP;
+                break;
+            default:
+                hat = SDL_HAT_CENTERED;
+                break;
+            }
+            SDL_SendJoystickHat(timestamp, joystick, 0, hat);
+        }
+    }
+
+    if (ctx->last_state.state.rgucButtonsAndHat[1] != packet->rgucButtonsAndHat[1]) {
+        Uint8 data = packet->rgucButtonsAndHat[1];
+
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK, ((data & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_STICK, ((data & 0x80) != 0));
+    }
+
+    if (ctx->last_state.state.rgucButtonsAndHat[2] != packet->rgucButtonsAndHat[2]) {
+        Uint8 data = packet->rgucButtonsAndHat[2];
+
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_PS5_TOUCHPAD, ((data & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_PS5_MICROPHONE, ((data & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_PS5_LEFT_FUNCTION, ((data & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_PS5_RIGHT_FUNCTION, ((data & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_PS5_LEFT_PADDLE, ((data & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_PS5_RIGHT_PADDLE, ((data & 0x80) != 0));
+    }
+
+    if (packet->ucTriggerLeft == 0 && (packet->rgucButtonsAndHat[1] & 0x04)) {
+        axis = SDL_JOYSTICK_AXIS_MAX;
+    } else {
+        axis = ((int)packet->ucTriggerLeft * 257) - 32768;
+    }
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, axis);
+    if (packet->ucTriggerRight == 0 && (packet->rgucButtonsAndHat[1] & 0x08)) {
+        axis = SDL_JOYSTICK_AXIS_MAX;
+    } else {
+        axis = ((int)packet->ucTriggerRight * 257) - 32768;
+    }
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, axis);
+    axis = ((int)packet->ucLeftJoystickX * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, axis);
+    axis = ((int)packet->ucLeftJoystickY * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, axis);
+    axis = ((int)packet->ucRightJoystickX * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, axis);
+    axis = ((int)packet->ucRightJoystickY * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, axis);
+
+    if (ctx->report_sensors) {
+        Uint64 sensor_timestamp;
+        float data[3];
+
+        if (ctx->use_alternate_report) {
+            // 16-bit timestamp
+            Uint32 delta;
+            Uint16 tick = LOAD16(packet->rgucSensorTimestamp[0],
+                                 packet->rgucSensorTimestamp[1]);
+            if (ctx->last_tick < tick) {
+                delta = (tick - ctx->last_tick);
+            } else {
+                delta = (SDL_MAX_UINT16 - ctx->last_tick + tick + 1);
+            }
+            ctx->last_tick = tick;
+            ctx->sensor_ticks += delta;
+
+            // Sensor timestamp is in 1us units
+            sensor_timestamp = SDL_US_TO_NS(ctx->sensor_ticks);
+        } else {
+            // 32-bit timestamp
+            Uint32 delta;
+            Uint32 tick = LOAD32(packet->rgucSensorTimestamp[0],
+                                 packet->rgucSensorTimestamp[1],
+                                 packet->rgucSensorTimestamp[2],
+                                 packet->rgucSensorTimestamp[3]);
+            if (ctx->last_tick < tick) {
+                delta = (tick - ctx->last_tick);
+            } else {
+                delta = (SDL_MAX_UINT32 - ctx->last_tick + tick + 1);
+            }
+            ctx->last_tick = tick;
+            ctx->sensor_ticks += delta;
+
+            // Sensor timestamp is in 0.33us units
+            sensor_timestamp = (ctx->sensor_ticks * SDL_NS_PER_US) / 3;
+        }
+
+        data[0] = HIDAPI_DriverPS5_ApplyCalibrationData(ctx, 0, LOAD16(packet->rgucGyroX[0], packet->rgucGyroX[1]));
+        data[1] = HIDAPI_DriverPS5_ApplyCalibrationData(ctx, 1, LOAD16(packet->rgucGyroY[0], packet->rgucGyroY[1]));
+        data[2] = HIDAPI_DriverPS5_ApplyCalibrationData(ctx, 2, LOAD16(packet->rgucGyroZ[0], packet->rgucGyroZ[1]));
+        SDL_SendJoystickSensor(timestamp, joystick, SDL_SENSOR_GYRO, sensor_timestamp, data, 3);
+
+        data[0] = HIDAPI_DriverPS5_ApplyCalibrationData(ctx, 3, LOAD16(packet->rgucAccelX[0], packet->rgucAccelX[1]));
+        data[1] = HIDAPI_DriverPS5_ApplyCalibrationData(ctx, 4, LOAD16(packet->rgucAccelY[0], packet->rgucAccelY[1]));
+        data[2] = HIDAPI_DriverPS5_ApplyCalibrationData(ctx, 5, LOAD16(packet->rgucAccelZ[0], packet->rgucAccelZ[1]));
+        SDL_SendJoystickSensor(timestamp, joystick, SDL_SENSOR_ACCEL, sensor_timestamp, data, 3);
+    }
+}
+
+static void HIDAPI_DriverPS5_HandleStatePacket(SDL_Joystick *joystick, SDL_hid_device *dev, SDL_DriverPS5_Context *ctx, PS5StatePacket_t *packet, Uint64 timestamp)
+{
+    static const float TOUCHPAD_SCALEX = 1.0f / 1920;
+    static const float TOUCHPAD_SCALEY = 1.0f / 1070;
+    bool touchpad_down;
+    int touchpad_x, touchpad_y;
+
+    if (ctx->report_touchpad) {
+        touchpad_down = ((packet->ucTouchpadCounter1 & 0x80) == 0);
+        touchpad_x = packet->rgucTouchpadData1[0] | (((int)packet->rgucTouchpadData1[1] & 0x0F) << 8);
+        touchpad_y = (packet->rgucTouchpadData1[1] >> 4) | ((int)packet->rgucTouchpadData1[2] << 4);
+        SDL_SendJoystickTouchpad(timestamp, joystick, 0, 0, touchpad_down, touchpad_x * TOUCHPAD_SCALEX, touchpad_y * TOUCHPAD_SCALEY, touchpad_down ? 1.0f : 0.0f);
+
+        touchpad_down = ((packet->ucTouchpadCounter2 & 0x80) == 0);
+        touchpad_x = packet->rgucTouchpadData2[0] | (((int)packet->rgucTouchpadData2[1] & 0x0F) << 8);
+        touchpad_y = (packet->rgucTouchpadData2[1] >> 4) | ((int)packet->rgucTouchpadData2[2] << 4);
+        SDL_SendJoystickTouchpad(timestamp, joystick, 0, 1, touchpad_down, touchpad_x * TOUCHPAD_SCALEX, touchpad_y * TOUCHPAD_SCALEY, touchpad_down ? 1.0f : 0.0f);
+    }
+
+    if (ctx->report_battery) {
+        SDL_PowerState state;
+        int percent;
+        Uint8 status = (packet->ucBatteryLevel >> 4) & 0x0F;
+        Uint8 level = (packet->ucBatteryLevel & 0x0F);
+
+        switch (status) {
+        case 0:
+            state = SDL_POWERSTATE_ON_BATTERY;
+            percent = SDL_min(level * 10 + 5, 100);
+            break;
+        case 1:
+            state = SDL_POWERSTATE_CHARGING;
+            percent = SDL_min(level * 10 + 5, 100);
+            break;
+        case 2:
+            state = SDL_POWERSTATE_CHARGED;
+            percent = 100;
+            break;
+        default:
+            state = SDL_POWERSTATE_UNKNOWN;
+            percent = 0;
+            break;
+        }
+        SDL_SendJoystickPowerInfo(joystick, state, percent);
+    }
+
+    HIDAPI_DriverPS5_HandleStatePacketCommon(joystick, dev, ctx, (PS5StatePacketCommon_t *)packet, timestamp);
+
+    SDL_memcpy(&ctx->last_state, packet, sizeof(ctx->last_state));
+}
+
+static void HIDAPI_DriverPS5_HandleStatePacketAlt(SDL_Joystick *joystick, SDL_hid_device *dev, SDL_DriverPS5_Context *ctx, PS5StatePacketAlt_t *packet, Uint64 timestamp)
+{
+    static const float TOUCHPAD_SCALEX = 1.0f / 1920;
+    static const float TOUCHPAD_SCALEY = 1.0f / 1070;
+    bool touchpad_down;
+    int touchpad_x, touchpad_y;
+
+    if (ctx->report_touchpad) {
+        touchpad_down = ((packet->ucTouchpadCounter1 & 0x80) == 0);
+        touchpad_x = packet->rgucTouchpadData1[0] | (((int)packet->rgucTouchpadData1[1] & 0x0F) << 8);
+        touchpad_y = (packet->rgucTouchpadData1[1] >> 4) | ((int)packet->rgucTouchpadData1[2] << 4);
+        SDL_SendJoystickTouchpad(timestamp, joystick, 0, 0, touchpad_down, touchpad_x * TOUCHPAD_SCALEX, touchpad_y * TOUCHPAD_SCALEY, touchpad_down ? 1.0f : 0.0f);
+
+        touchpad_down = ((packet->ucTouchpadCounter2 & 0x80) == 0);
+        touchpad_x = packet->rgucTouchpadData2[0] | (((int)packet->rgucTouchpadData2[1] & 0x0F) << 8);
+        touchpad_y = (packet->rgucTouchpadData2[1] >> 4) | ((int)packet->rgucTouchpadData2[2] << 4);
+        SDL_SendJoystickTouchpad(timestamp, joystick, 0, 1, touchpad_down, touchpad_x * TOUCHPAD_SCALEX, touchpad_y * TOUCHPAD_SCALEY, touchpad_down ? 1.0f : 0.0f);
+    }
+
+    HIDAPI_DriverPS5_HandleStatePacketCommon(joystick, dev, ctx, (PS5StatePacketCommon_t *)packet, timestamp);
+
+    SDL_memcpy(&ctx->last_state, packet, sizeof(ctx->last_state));
+}
+
+static bool VerifyCRC(Uint8 *data, int size)
+{
+    Uint8 ubHdr = 0xA1; // hidp header is part of the CRC calculation
+    Uint32 unCRC, unPacketCRC;
+    Uint8 *packetCRC = data + size - sizeof(unPacketCRC);
+    unCRC = SDL_crc32(0, &ubHdr, 1);
+    unCRC = SDL_crc32(unCRC, data, (size_t)(size - sizeof(unCRC)));
+
+    unPacketCRC = LOAD32(packetCRC[0],
+                         packetCRC[1],
+                         packetCRC[2],
+                         packetCRC[3]);
+    return (unCRC == unPacketCRC);
+}
+
+static bool HIDAPI_DriverPS5_IsPacketValid(SDL_DriverPS5_Context *ctx, Uint8 *data, int size)
+{
+    switch (data[0]) {
+    case k_EPS5ReportIdState:
+        if (ctx->is_nacon_dongle && size >= (1 + sizeof(PS5StatePacketAlt_t))) {
+            // The report timestamp doesn't change when the controller isn't connected
+            PS5StatePacketAlt_t *packet = (PS5StatePacketAlt_t *)&data[1];
+            if (SDL_memcmp(packet->rgucPacketSequence, ctx->last_state.state.rgucPacketSequence, sizeof(packet->rgucPacketSequence)) == 0) {
+                return false;
+            }
+            if (ctx->last_state.alt_state.rgucAccelX[0] == 0 && ctx->last_state.alt_state.rgucAccelX[1] == 0 &&
+                ctx->last_state.alt_state.rgucAccelY[0] == 0 && ctx->last_state.alt_state.rgucAccelY[1] == 0 &&
+                ctx->last_state.alt_state.rgucAccelZ[0] == 0 && ctx->last_state.alt_state.rgucAccelZ[1] == 0) {
+                // We don't have any state to compare yet, go ahead and copy it
+                SDL_memcpy(&ctx->last_state, &data[1], sizeof(PS5StatePacketAlt_t));
+                return false;
+            }
+        }
+        return true;
+
+    case k_EPS5ReportIdBluetoothState:
+        if (VerifyCRC(data, size)) {
+            return true;
+        }
+        break;
+    default:
+        break;
+    }
+    return false;
+}
+
+static bool HIDAPI_DriverPS5_UpdateDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverPS5_Context *ctx = (SDL_DriverPS5_Context *)device->context;
+    SDL_Joystick *joystick = NULL;
+    Uint8 data[USB_PACKET_LENGTH * 2];
+    int size;
+    int packet_count = 0;
+    Uint64 now = SDL_GetTicks();
+
+    if (device->num_joysticks > 0) {
+        joystick = SDL_GetJoystickFromID(device->joysticks[0]);
+    }
+
+    while ((size = SDL_hid_read_timeout(device->dev, data, sizeof(data), 0)) > 0) {
+        Uint64 timestamp = SDL_GetTicksNS();
+
+#ifdef DEBUG_PS5_PROTOCOL
+        HIDAPI_DumpPacket("PS5 packet: size = %d", data, size);
+#endif
+        if (!HIDAPI_DriverPS5_IsPacketValid(ctx, data, size)) {
+            continue;
+        }
+
+        ++packet_count;
+        ctx->last_packet = now;
+
+        if (!joystick) {
+            continue;
+        }
+
+        switch (data[0]) {
+        case k_EPS5ReportIdState:
+            if (size == 10 || size == 78) {
+                HIDAPI_DriverPS5_HandleSimpleStatePacket(joystick, device->dev, ctx, (PS5SimpleStatePacket_t *)&data[1], timestamp);
+            } else {
+                if (ctx->use_alternate_report) {
+                    HIDAPI_DriverPS5_HandleStatePacketAlt(joystick, device->dev, ctx, (PS5StatePacketAlt_t *)&data[1], timestamp);
+                } else {
+                    HIDAPI_DriverPS5_HandleStatePacket(joystick, device->dev, ctx, (PS5StatePacket_t *)&data[1], timestamp);
+                }
+            }
+            break;
+        case k_EPS5ReportIdBluetoothState:
+            // This is the extended report, we can enable effects now in auto mode
+            HIDAPI_DriverPS5_UpdateEnhancedModeOnEnhancedReport(ctx);
+
+            if (ctx->use_alternate_report) {
+                HIDAPI_DriverPS5_HandleStatePacketAlt(joystick, device->dev, ctx, (PS5StatePacketAlt_t *)&data[2], timestamp);
+            } else {
+                HIDAPI_DriverPS5_HandleStatePacket(joystick, device->dev, ctx, (PS5StatePacket_t *)&data[2], timestamp);
+            }
+            if (ctx->led_reset_state == k_EDS5LEDResetStatePending) {
+                HIDAPI_DriverPS5_CheckPendingLEDReset(ctx);
+            }
+            break;
+        default:
+#ifdef DEBUG_JOYSTICK
+            SDL_Log("Unknown PS5 packet: 0x%.2x", data[0]);
+#endif
+            break;
+        }
+    }
+
+    if (device->is_bluetooth) {
+        if (packet_count == 0) {
+            // Check to see if it looks like the device disconnected
+            if (now >= (ctx->last_packet + BLUETOOTH_DISCONNECT_TIMEOUT_MS)) {
+                // Send an empty output report to tickle the Bluetooth stack
+                HIDAPI_DriverPS5_TickleBluetooth(device);
+                ctx->last_packet = now;
+            }
+        } else {
+            // Reconnect the Bluetooth device once the USB device is gone
+            if (device->num_joysticks == 0 &&
+                !HIDAPI_HasConnectedUSBDevice(device->serial)) {
+                HIDAPI_JoystickConnected(device, NULL);
+            }
+        }
+    }
+
+    if (ctx->is_nacon_dongle) {
+        if (packet_count == 0) {
+            if (device->num_joysticks > 0) {
+                // Check to see if it looks like the device disconnected
+                if (now >= (ctx->last_packet + BLUETOOTH_DISCONNECT_TIMEOUT_MS)) {
+                    HIDAPI_JoystickDisconnected(device, device->joysticks[0]);
+                }
+            }
+        } else {
+            if (device->num_joysticks == 0) {
+                HIDAPI_JoystickConnected(device, NULL);
+            }
+        }
+    }
+
+    if (packet_count == 0 && size < 0 && device->num_joysticks > 0) {
+        // Read error, device is disconnected
+        HIDAPI_JoystickDisconnected(device, device->joysticks[0]);
+    }
+    return (size >= 0);
+}
+
+static void HIDAPI_DriverPS5_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverPS5_Context *ctx = (SDL_DriverPS5_Context *)device->context;
+
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_ENHANCED_REPORTS,
+                        SDL_PS5EnhancedReportsChanged, ctx);
+
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_PS5_PLAYER_LED,
+                        SDL_PS5PlayerLEDHintChanged, ctx);
+
+    ctx->joystick = NULL;
+
+    ctx->report_sensors = false;
+    ctx->enhanced_mode = false;
+    ctx->enhanced_mode_available = false;
+}
+
+static void HIDAPI_DriverPS5_FreeDevice(SDL_HIDAPI_Device *device)
+{
+}
+
+SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverPS5 = {
+    SDL_HINT_JOYSTICK_HIDAPI_PS5,
+    true,
+    HIDAPI_DriverPS5_RegisterHints,
+    HIDAPI_DriverPS5_UnregisterHints,
+    HIDAPI_DriverPS5_IsEnabled,
+    HIDAPI_DriverPS5_IsSupportedDevice,
+    HIDAPI_DriverPS5_InitDevice,
+    HIDAPI_DriverPS5_GetDevicePlayerIndex,
+    HIDAPI_DriverPS5_SetDevicePlayerIndex,
+    HIDAPI_DriverPS5_UpdateDevice,
+    HIDAPI_DriverPS5_OpenJoystick,
+    HIDAPI_DriverPS5_RumbleJoystick,
+    HIDAPI_DriverPS5_RumbleJoystickTriggers,
+    HIDAPI_DriverPS5_GetJoystickCapabilities,
+    HIDAPI_DriverPS5_SetJoystickLED,
+    HIDAPI_DriverPS5_SendJoystickEffect,
+    HIDAPI_DriverPS5_SetJoystickSensorsEnabled,
+    HIDAPI_DriverPS5_CloseJoystick,
+    HIDAPI_DriverPS5_FreeDevice,
+};
+
+#endif // SDL_JOYSTICK_HIDAPI_PS5
+
+#endif // SDL_JOYSTICK_HIDAPI
diff --git a/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_rumble.c b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_rumble.c
new file mode 100644
index 0000000..5fd93dc
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_rumble.c
@@ -0,0 +1,285 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI
+
+// Handle rumble on a separate thread so it doesn't block the application
+
+#include "SDL_hidapijoystick_c.h"
+#include "SDL_hidapi_rumble.h"
+#include "../../thread/SDL_systhread.h"
+
+typedef struct SDL_HIDAPI_RumbleRequest
+{
+    SDL_HIDAPI_Device *device;
+    Uint8 data[2 * USB_PACKET_LENGTH]; // need enough space for the biggest report: dualshock4 is 78 bytes
+    int size;
+    SDL_HIDAPI_RumbleSentCallback callback;
+    void *userdata;
+    struct SDL_HIDAPI_RumbleRequest *prev;
+
+} SDL_HIDAPI_RumbleRequest;
+
+typedef struct SDL_HIDAPI_RumbleContext
+{
+    SDL_AtomicInt initialized;
+    SDL_AtomicInt running;
+    SDL_Thread *thread;
+    SDL_Semaphore *request_sem;
+    SDL_HIDAPI_RumbleRequest *requests_head;
+    SDL_HIDAPI_RumbleRequest *requests_tail;
+} SDL_HIDAPI_RumbleContext;
+
+#ifndef SDL_THREAD_SAFETY_ANALYSIS
+static
+#endif
+SDL_Mutex *SDL_HIDAPI_rumble_lock;
+static SDL_HIDAPI_RumbleContext rumble_context SDL_GUARDED_BY(SDL_HIDAPI_rumble_lock);
+
+static int SDLCALL SDL_HIDAPI_RumbleThread(void *data)
+{
+    SDL_HIDAPI_RumbleContext *ctx = (SDL_HIDAPI_RumbleContext *)data;
+
+    SDL_SetCurrentThreadPriority(SDL_THREAD_PRIORITY_HIGH);
+
+    while (SDL_GetAtomicInt(&ctx->running)) {
+        SDL_HIDAPI_RumbleRequest *request = NULL;
+
+        SDL_WaitSemaphore(ctx->request_sem);
+
+        SDL_LockMutex(SDL_HIDAPI_rumble_lock);
+        request = ctx->requests_tail;
+        if (request) {
+            if (request == ctx->requests_head) {
+                ctx->requests_head = NULL;
+            }
+            ctx->requests_tail = request->prev;
+        }
+        SDL_UnlockMutex(SDL_HIDAPI_rumble_lock);
+
+        if (request) {
+            SDL_LockMutex(request->device->dev_lock);
+            if (request->device->dev) {
+#ifdef DEBUG_RUMBLE
+                HIDAPI_DumpPacket("Rumble packet: size = %d", request->data, request->size);
+#endif
+                SDL_hid_write(request->device->dev, request->data, request->size);
+            }
+            SDL_UnlockMutex(request->device->dev_lock);
+            if (request->callback) {
+                request->callback(request->userdata);
+            }
+            (void)SDL_AtomicDecRef(&request->device->rumble_pending);
+            SDL_free(request);
+
+            // Make sure we're not starving report reads when there's lots of rumble
+            SDL_Delay(10);
+        }
+    }
+    return 0;
+}
+
+static void SDL_HIDAPI_StopRumbleThread(SDL_HIDAPI_RumbleContext *ctx)
+{
+    SDL_HIDAPI_RumbleRequest *request;
+
+    SDL_SetAtomicInt(&ctx->running, false);
+
+    if (ctx->thread) {
+        int result;
+
+        SDL_SignalSemaphore(ctx->request_sem);
+        SDL_WaitThread(ctx->thread, &result);
+        ctx->thread = NULL;
+    }
+
+    SDL_LockMutex(SDL_HIDAPI_rumble_lock);
+    while (ctx->requests_tail) {
+        request = ctx->requests_tail;
+        if (request == ctx->requests_head) {
+            ctx->requests_head = NULL;
+        }
+        ctx->requests_tail = request->prev;
+
+        if (request->callback) {
+            request->callback(request->userdata);
+        }
+        (void)SDL_AtomicDecRef(&request->device->rumble_pending);
+        SDL_free(request);
+    }
+    SDL_UnlockMutex(SDL_HIDAPI_rumble_lock);
+
+    if (ctx->request_sem) {
+        SDL_DestroySemaphore(ctx->request_sem);
+        ctx->request_sem = NULL;
+    }
+
+    if (SDL_HIDAPI_rumble_lock) {
+        SDL_DestroyMutex(SDL_HIDAPI_rumble_lock);
+        SDL_HIDAPI_rumble_lock = NULL;
+    }
+
+    SDL_SetAtomicInt(&ctx->initialized, false);
+}
+
+static bool SDL_HIDAPI_StartRumbleThread(SDL_HIDAPI_RumbleContext *ctx)
+{
+    SDL_HIDAPI_rumble_lock = SDL_CreateMutex();
+    if (!SDL_HIDAPI_rumble_lock) {
+        SDL_HIDAPI_StopRumbleThread(ctx);
+        return false;
+    }
+
+    ctx->request_sem = SDL_CreateSemaphore(0);
+    if (!ctx->request_sem) {
+        SDL_HIDAPI_StopRumbleThread(ctx);
+        return false;
+    }
+
+    SDL_SetAtomicInt(&ctx->running, true);
+    ctx->thread = SDL_CreateThread(SDL_HIDAPI_RumbleThread, "HIDAPI Rumble", ctx);
+    if (!ctx->thread) {
+        SDL_HIDAPI_StopRumbleThread(ctx);
+        return false;
+    }
+    return true;
+}
+
+bool SDL_HIDAPI_LockRumble(void)
+{
+    SDL_HIDAPI_RumbleContext *ctx = &rumble_context;
+
+    if (SDL_CompareAndSwapAtomicInt(&ctx->initialized, false, true)) {
+        if (!SDL_HIDAPI_StartRumbleThread(ctx)) {
+            return false;
+        }
+    }
+
+    SDL_LockMutex(SDL_HIDAPI_rumble_lock);
+    return true;
+}
+
+bool SDL_HIDAPI_GetPendingRumbleLocked(SDL_HIDAPI_Device *device, Uint8 **data, int **size, int *maximum_size)
+{
+    SDL_HIDAPI_RumbleContext *ctx = &rumble_context;
+    SDL_HIDAPI_RumbleRequest *request, *found;
+
+    found = NULL;
+    for (request = ctx->requests_tail; request; request = request->prev) {
+        if (request->device == device) {
+            found = request;
+        }
+    }
+    if (found) {
+        *data = found->data;
+        *size = &found->size;
+        *maximum_size = sizeof(found->data);
+        return true;
+    }
+    return false;
+}
+
+int SDL_HIDAPI_SendRumbleAndUnlock(SDL_HIDAPI_Device *device, const Uint8 *data, int size)
+{
+    return SDL_HIDAPI_SendRumbleWithCallbackAndUnlock(device, data, size, NULL, NULL);
+}
+
+int SDL_HIDAPI_SendRumbleWithCallbackAndUnlock(SDL_HIDAPI_Device *device, const Uint8 *data, int size, SDL_HIDAPI_RumbleSentCallback callback, void *userdata)
+{
+    SDL_HIDAPI_RumbleContext *ctx = &rumble_context;
+    SDL_HIDAPI_RumbleRequest *request;
+
+    if (size > sizeof(request->data)) {
+        SDL_HIDAPI_UnlockRumble();
+        SDL_SetError("Couldn't send rumble, size %d is greater than %d", size, (int)sizeof(request->data));
+        return -1;
+    }
+
+    request = (SDL_HIDAPI_RumbleRequest *)SDL_calloc(1, sizeof(*request));
+    if (!request) {
+        SDL_HIDAPI_UnlockRumble();
+        return -1;
+    }
+    request->device = device;
+    SDL_memcpy(request->data, data, size);
+    request->size = size;
+    request->callback = callback;
+    request->userdata = userdata;
+
+    SDL_AtomicIncRef(&device->rumble_pending);
+
+    if (ctx->requests_head) {
+        ctx->requests_head->prev = request;
+    } else {
+        ctx->requests_tail = request;
+    }
+    ctx->requests_head = request;
+
+    // Make sure we unlock before posting the semaphore so the rumble thread can run immediately
+    SDL_HIDAPI_UnlockRumble();
+
+    SDL_SignalSemaphore(ctx->request_sem);
+
+    return size;
+}
+
+void SDL_HIDAPI_UnlockRumble(void)
+{
+    SDL_UnlockMutex(SDL_HIDAPI_rumble_lock);
+}
+
+int SDL_HIDAPI_SendRumble(SDL_HIDAPI_Device *device, const Uint8 *data, int size)
+{
+    Uint8 *pending_data;
+    int *pending_size;
+    int maximum_size;
+
+    if (size <= 0) {
+        SDL_SetError("Tried to send rumble with invalid size");
+        return -1;
+    }
+
+    if (!SDL_HIDAPI_LockRumble()) {
+        return -1;
+    }
+
+    // check if there is a pending request for the device and update it
+    if (SDL_HIDAPI_GetPendingRumbleLocked(device, &pending_data, &pending_size, &maximum_size) &&
+        size == *pending_size && data[0] == pending_data[0]) {
+        SDL_memcpy(pending_data, data, size);
+        SDL_HIDAPI_UnlockRumble();
+        return size;
+    }
+
+    return SDL_HIDAPI_SendRumbleAndUnlock(device, data, size);
+}
+
+void SDL_HIDAPI_QuitRumble(void)
+{
+    SDL_HIDAPI_RumbleContext *ctx = &rumble_context;
+
+    if (SDL_GetAtomicInt(&ctx->running)) {
+        SDL_HIDAPI_StopRumbleThread(ctx);
+    }
+}
+
+#endif // SDL_JOYSTICK_HIDAPI
diff --git a/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_rumble.h b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_rumble.h
new file mode 100644
index 0000000..ede061e
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_rumble.h
@@ -0,0 +1,42 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI
+
+// Handle rumble on a separate thread so it doesn't block the application
+
+// Advanced API
+#ifdef SDL_THREAD_SAFETY_ANALYSIS
+extern SDL_Mutex *SDL_HIDAPI_rumble_lock;
+#endif
+bool SDL_HIDAPI_LockRumble(void) SDL_TRY_ACQUIRE(0, SDL_HIDAPI_rumble_lock);
+bool SDL_HIDAPI_GetPendingRumbleLocked(SDL_HIDAPI_Device *device, Uint8 **data, int **size, int *maximum_size);
+int SDL_HIDAPI_SendRumbleAndUnlock(SDL_HIDAPI_Device *device, const Uint8 *data, int size) SDL_RELEASE(SDL_HIDAPI_rumble_lock);
+typedef void (*SDL_HIDAPI_RumbleSentCallback)(void *userdata);
+int SDL_HIDAPI_SendRumbleWithCallbackAndUnlock(SDL_HIDAPI_Device *device, const Uint8 *data, int size, SDL_HIDAPI_RumbleSentCallback callback, void *userdata) SDL_RELEASE(SDL_HIDAPI_rumble_lock);
+void SDL_HIDAPI_UnlockRumble(void) SDL_RELEASE(SDL_HIDAPI_rumble_lock);
+
+// Simple API, will replace any pending rumble with the new data
+int SDL_HIDAPI_SendRumble(SDL_HIDAPI_Device *device, const Uint8 *data, int size);
+void SDL_HIDAPI_QuitRumble(void);
+
+#endif // SDL_JOYSTICK_HIDAPI
diff --git a/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_shield.c b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_shield.c
new file mode 100644
index 0000000..10dcea3
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_shield.c
@@ -0,0 +1,578 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI
+
+#include "../SDL_sysjoystick.h"
+#include "SDL_hidapijoystick_c.h"
+#include "SDL_hidapi_rumble.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI_SHIELD
+
+// Define this if you want to log all packets from the controller
+// #define DEBUG_SHIELD_PROTOCOL
+
+#define CMD_BATTERY_STATE 0x07
+#define CMD_RUMBLE        0x39
+#define CMD_CHARGE_STATE  0x3A
+
+// Milliseconds between polls of battery state
+#define BATTERY_POLL_INTERVAL_MS 60000
+
+// Milliseconds between retransmission of rumble to keep motors running
+#define RUMBLE_REFRESH_INTERVAL_MS 500
+
+// Reports that are too small are dropped over Bluetooth
+#define HID_REPORT_SIZE 33
+
+enum
+{
+    SDL_GAMEPAD_BUTTON_SHIELD_SHARE = 11,
+    SDL_GAMEPAD_BUTTON_SHIELD_V103_TOUCHPAD,
+    SDL_GAMEPAD_BUTTON_SHIELD_V103_MINUS,
+    SDL_GAMEPAD_BUTTON_SHIELD_V103_PLUS,
+    SDL_GAMEPAD_NUM_SHIELD_V103_BUTTONS,
+
+    SDL_GAMEPAD_NUM_SHIELD_V104_BUTTONS = SDL_GAMEPAD_BUTTON_SHIELD_SHARE + 1,
+};
+
+typedef enum
+{
+    k_ShieldReportIdControllerState = 0x01,
+    k_ShieldReportIdControllerTouch = 0x02,
+    k_ShieldReportIdCommandResponse = 0x03,
+    k_ShieldReportIdCommandRequest = 0x04,
+} EShieldReportId;
+
+// This same report structure is used for both requests and responses
+typedef struct
+{
+    Uint8 report_id;
+    Uint8 cmd;
+    Uint8 seq_num;
+    Uint8 payload[HID_REPORT_SIZE - 3];
+} ShieldCommandReport_t;
+SDL_COMPILE_TIME_ASSERT(ShieldCommandReport_t, sizeof(ShieldCommandReport_t) == HID_REPORT_SIZE);
+
+typedef struct
+{
+    Uint8 seq_num;
+
+    bool has_charging;
+    Uint8 charging;
+    bool has_battery_level;
+    Uint8 battery_level;
+    Uint64 last_battery_query_time;
+
+    bool rumble_report_pending;
+    bool rumble_update_pending;
+    Uint8 left_motor_amplitude;
+    Uint8 right_motor_amplitude;
+    Uint64 last_rumble_time;
+
+    Uint8 last_state[USB_PACKET_LENGTH];
+} SDL_DriverShield_Context;
+
+static void HIDAPI_DriverShield_RegisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_SHIELD, callback, userdata);
+}
+
+static void HIDAPI_DriverShield_UnregisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_SHIELD, callback, userdata);
+}
+
+static bool HIDAPI_DriverShield_IsEnabled(void)
+{
+    return SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_SHIELD, SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI, SDL_HIDAPI_DEFAULT));
+}
+
+static bool HIDAPI_DriverShield_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)
+{
+    return SDL_IsJoystickNVIDIASHIELDController(vendor_id, product_id);
+}
+
+static bool HIDAPI_DriverShield_InitDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverShield_Context *ctx;
+
+    ctx = (SDL_DriverShield_Context *)SDL_calloc(1, sizeof(*ctx));
+    if (!ctx) {
+        return false;
+    }
+    device->context = ctx;
+
+    HIDAPI_SetDeviceName(device, "NVIDIA SHIELD Controller");
+
+    return HIDAPI_JoystickConnected(device, NULL);
+}
+
+static int HIDAPI_DriverShield_GetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id)
+{
+    return -1;
+}
+
+static void HIDAPI_DriverShield_SetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id, int player_index)
+{
+}
+
+static bool HIDAPI_DriverShield_SendCommand(SDL_HIDAPI_Device *device, Uint8 cmd, const void *data, int size)
+{
+    SDL_DriverShield_Context *ctx = (SDL_DriverShield_Context *)device->context;
+    ShieldCommandReport_t cmd_pkt;
+
+    if (size > sizeof(cmd_pkt.payload)) {
+        return SDL_SetError("Command data exceeds HID report size");
+    }
+
+    if (!SDL_HIDAPI_LockRumble()) {
+        return false;
+    }
+
+    cmd_pkt.report_id = k_ShieldReportIdCommandRequest;
+    cmd_pkt.cmd = cmd;
+    cmd_pkt.seq_num = ctx->seq_num++;
+    if (data) {
+        SDL_memcpy(cmd_pkt.payload, data, size);
+    }
+
+    // Zero unused data in the payload
+    if (size != sizeof(cmd_pkt.payload)) {
+        SDL_memset(&cmd_pkt.payload[size], 0, sizeof(cmd_pkt.payload) - size);
+    }
+
+    if (SDL_HIDAPI_SendRumbleAndUnlock(device, (Uint8 *)&cmd_pkt, sizeof(cmd_pkt)) != sizeof(cmd_pkt)) {
+        return SDL_SetError("Couldn't send command packet");
+    }
+
+    return true;
+}
+
+static bool HIDAPI_DriverShield_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverShield_Context *ctx = (SDL_DriverShield_Context *)device->context;
+
+    SDL_AssertJoysticksLocked();
+
+    ctx->rumble_report_pending = false;
+    ctx->rumble_update_pending = false;
+    ctx->left_motor_amplitude = 0;
+    ctx->right_motor_amplitude = 0;
+    ctx->last_rumble_time = 0;
+    SDL_zeroa(ctx->last_state);
+
+    // Initialize the joystick capabilities
+    if (device->product_id == USB_PRODUCT_NVIDIA_SHIELD_CONTROLLER_V103) {
+        joystick->nbuttons = SDL_GAMEPAD_NUM_SHIELD_V103_BUTTONS;
+        joystick->naxes = SDL_GAMEPAD_AXIS_COUNT;
+        joystick->nhats = 1;
+
+        SDL_PrivateJoystickAddTouchpad(joystick, 1);
+    } else {
+        joystick->nbuttons = SDL_GAMEPAD_NUM_SHIELD_V104_BUTTONS;
+        joystick->naxes = SDL_GAMEPAD_AXIS_COUNT;
+        joystick->nhats = 1;
+    }
+
+    // Request battery and charging info
+    ctx->last_battery_query_time = SDL_GetTicks();
+    HIDAPI_DriverShield_SendCommand(device, CMD_CHARGE_STATE, NULL, 0);
+    HIDAPI_DriverShield_SendCommand(device, CMD_BATTERY_STATE, NULL, 0);
+
+    return true;
+}
+
+static bool HIDAPI_DriverShield_SendNextRumble(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverShield_Context *ctx = (SDL_DriverShield_Context *)device->context;
+    Uint8 rumble_data[3];
+
+    if (!ctx->rumble_update_pending) {
+        return true;
+    }
+
+    rumble_data[0] = 0x01; // enable
+    rumble_data[1] = ctx->left_motor_amplitude;
+    rumble_data[2] = ctx->right_motor_amplitude;
+
+    ctx->rumble_update_pending = false;
+    ctx->last_rumble_time = SDL_GetTicks();
+
+    return HIDAPI_DriverShield_SendCommand(device, CMD_RUMBLE, rumble_data, sizeof(rumble_data));
+}
+
+static bool HIDAPI_DriverShield_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+    if (device->product_id == USB_PRODUCT_NVIDIA_SHIELD_CONTROLLER_V103) {
+        Uint8 rumble_packet[] = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+        rumble_packet[2] = (low_frequency_rumble >> 8);
+        rumble_packet[4] = (high_frequency_rumble >> 8);
+
+        if (SDL_HIDAPI_SendRumble(device, rumble_packet, sizeof(rumble_packet)) != sizeof(rumble_packet)) {
+            return SDL_SetError("Couldn't send rumble packet");
+        }
+        return true;
+
+    } else {
+        SDL_DriverShield_Context *ctx = (SDL_DriverShield_Context *)device->context;
+
+        // The rumble motors are quite intense, so tone down the intensity like the official driver does
+        ctx->left_motor_amplitude = low_frequency_rumble >> 11;
+        ctx->right_motor_amplitude = high_frequency_rumble >> 11;
+        ctx->rumble_update_pending = true;
+
+        if (ctx->rumble_report_pending) {
+            // We will service this after the hardware acknowledges the previous request
+            return true;
+        }
+
+        return HIDAPI_DriverShield_SendNextRumble(device);
+    }
+}
+
+static bool HIDAPI_DriverShield_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
+{
+    return SDL_Unsupported();
+}
+
+static Uint32 HIDAPI_DriverShield_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    return SDL_JOYSTICK_CAP_RUMBLE;
+}
+
+static bool HIDAPI_DriverShield_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverShield_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *data, int size)
+{
+    const Uint8 *data_bytes = (const Uint8 *)data;
+
+    if (size > 1) {
+        // Single command byte followed by a variable length payload
+        return HIDAPI_DriverShield_SendCommand(device, data_bytes[0], &data_bytes[1], size - 1);
+    } else if (size == 1) {
+        // Single command byte with no payload
+        return HIDAPI_DriverShield_SendCommand(device, data_bytes[0], NULL, 0);
+    } else {
+        return SDL_SetError("Effect data must at least contain a command byte");
+    }
+}
+
+static bool HIDAPI_DriverShield_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, bool enabled)
+{
+    return SDL_Unsupported();
+}
+
+static void HIDAPI_DriverShield_HandleStatePacketV103(SDL_Joystick *joystick, SDL_DriverShield_Context *ctx, Uint8 *data, int size)
+{
+    Uint64 timestamp = SDL_GetTicksNS();
+
+    if (ctx->last_state[3] != data[3]) {
+        Uint8 hat;
+
+        switch (data[3]) {
+        case 0:
+            hat = SDL_HAT_UP;
+            break;
+        case 1:
+            hat = SDL_HAT_RIGHTUP;
+            break;
+        case 2:
+            hat = SDL_HAT_RIGHT;
+            break;
+        case 3:
+            hat = SDL_HAT_RIGHTDOWN;
+            break;
+        case 4:
+            hat = SDL_HAT_DOWN;
+            break;
+        case 5:
+            hat = SDL_HAT_LEFTDOWN;
+            break;
+        case 6:
+            hat = SDL_HAT_LEFT;
+            break;
+        case 7:
+            hat = SDL_HAT_LEFTUP;
+            break;
+        default:
+            hat = SDL_HAT_CENTERED;
+            break;
+        }
+        SDL_SendJoystickHat(timestamp, joystick, 0, hat);
+    }
+
+    if (ctx->last_state[1] != data[1]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SOUTH, ((data[1] & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_EAST, ((data[1] & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_WEST, ((data[1] & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_NORTH, ((data[1] & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data[1] & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data[1] & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data[1] & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_STICK, ((data[1] & 0x80) != 0));
+    }
+
+    if (ctx->last_state[2] != data[2]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data[2] & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SHIELD_V103_PLUS, ((data[2] & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SHIELD_V103_MINUS, ((data[2] & 0x10) != 0));
+        //SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data[2] & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK, ((data[2] & 0x40) != 0));
+        //SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SHIELD_SHARE, ((data[2] & 0x80) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data[2] & 0x80) != 0));
+    }
+
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, SDL_Swap16LE(*(Sint16 *)&data[4]) - 0x8000);
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, SDL_Swap16LE(*(Sint16 *)&data[6]) - 0x8000);
+
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, SDL_Swap16LE(*(Sint16 *)&data[8]) - 0x8000);
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, SDL_Swap16LE(*(Sint16 *)&data[10]) - 0x8000);
+
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, SDL_Swap16LE(*(Sint16 *)&data[12]) - 0x8000);
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, SDL_Swap16LE(*(Sint16 *)&data[14]) - 0x8000);
+
+    SDL_memcpy(ctx->last_state, data, SDL_min(size, sizeof(ctx->last_state)));
+}
+
+#undef clamp
+#define clamp(val, min, max) (((val) > (max)) ? (max) : (((val) < (min)) ? (min) : (val)))
+
+static void HIDAPI_DriverShield_HandleTouchPacketV103(SDL_Joystick *joystick, SDL_DriverShield_Context *ctx, const Uint8 *data, int size)
+{
+    bool touchpad_down;
+    float touchpad_x, touchpad_y;
+    Uint64 timestamp = SDL_GetTicksNS();
+
+    SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SHIELD_V103_TOUCHPAD, ((data[1] & 0x01) != 0));
+
+    // It's a triangular pad, but just use the center as the usable touch area
+    touchpad_down = ((data[1] & 0x80) == 0);
+    touchpad_x = clamp((float)(data[2] - 0x70) / 0x50, 0.0f, 1.0f);
+    touchpad_y = clamp((float)(data[4] - 0x40) / 0x15, 0.0f, 1.0f);
+    SDL_SendJoystickTouchpad(timestamp, joystick, 0, 0, touchpad_down, touchpad_x, touchpad_y, touchpad_down ? 1.0f : 0.0f);
+}
+
+static void HIDAPI_DriverShield_HandleStatePacketV104(SDL_Joystick *joystick, SDL_DriverShield_Context *ctx, Uint8 *data, int size)
+{
+    Uint64 timestamp = SDL_GetTicksNS();
+
+    if (size < 23) {
+        return;
+    }
+
+    if (ctx->last_state[2] != data[2]) {
+        Uint8 hat;
+
+        switch (data[2]) {
+        case 0:
+            hat = SDL_HAT_UP;
+            break;
+        case 1:
+            hat = SDL_HAT_RIGHTUP;
+            break;
+        case 2:
+            hat = SDL_HAT_RIGHT;
+            break;
+        case 3:
+            hat = SDL_HAT_RIGHTDOWN;
+            break;
+        case 4:
+            hat = SDL_HAT_DOWN;
+            break;
+        case 5:
+            hat = SDL_HAT_LEFTDOWN;
+            break;
+        case 6:
+            hat = SDL_HAT_LEFT;
+            break;
+        case 7:
+            hat = SDL_HAT_LEFTUP;
+            break;
+        default:
+            hat = SDL_HAT_CENTERED;
+            break;
+        }
+        SDL_SendJoystickHat(timestamp, joystick, 0, hat);
+    }
+
+    if (ctx->last_state[3] != data[3]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SOUTH, ((data[3] & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_EAST, ((data[3] & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_WEST, ((data[3] & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_NORTH, ((data[3] & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data[3] & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data[3] & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data[3] & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_STICK, ((data[3] & 0x80) != 0));
+    }
+
+    if (ctx->last_state[4] != data[4]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data[4] & 0x01) != 0));
+    }
+
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, SDL_Swap16LE(*(Sint16 *)&data[9]) - 0x8000);
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, SDL_Swap16LE(*(Sint16 *)&data[11]) - 0x8000);
+
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, SDL_Swap16LE(*(Sint16 *)&data[13]) - 0x8000);
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, SDL_Swap16LE(*(Sint16 *)&data[15]) - 0x8000);
+
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, SDL_Swap16LE(*(Sint16 *)&data[19]) - 0x8000);
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, SDL_Swap16LE(*(Sint16 *)&data[21]) - 0x8000);
+
+    if (ctx->last_state[17] != data[17]) {
+        //SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SHIELD_SHARE, ((data[17] & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK, ((data[17] & 0x02) != 0));
+        //SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data[17] & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data[17] & 0x01) != 0));
+    }
+
+    SDL_memcpy(ctx->last_state, data, SDL_min(size, sizeof(ctx->last_state)));
+}
+
+static void HIDAPI_DriverShield_UpdatePowerInfo(SDL_Joystick *joystick, SDL_DriverShield_Context *ctx)
+{
+    if (!ctx->has_charging || !ctx->has_battery_level) {
+        return;
+    }
+
+    SDL_PowerState state = ctx->charging ? SDL_POWERSTATE_CHARGING : SDL_POWERSTATE_ON_BATTERY;
+    int percent = ctx->battery_level * 20;
+    SDL_SendJoystickPowerInfo(joystick, state, percent);
+}
+
+static bool HIDAPI_DriverShield_UpdateDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverShield_Context *ctx = (SDL_DriverShield_Context *)device->context;
+    SDL_Joystick *joystick = NULL;
+    Uint8 data[USB_PACKET_LENGTH];
+    int size = 0;
+    ShieldCommandReport_t *cmd_resp_report;
+
+    if (device->num_joysticks > 0) {
+        joystick = SDL_GetJoystickFromID(device->joysticks[0]);
+    } else {
+        return false;
+    }
+
+    while ((size = SDL_hid_read_timeout(device->dev, data, sizeof(data), 0)) > 0) {
+#ifdef DEBUG_SHIELD_PROTOCOL
+        HIDAPI_DumpPacket("NVIDIA SHIELD packet: size = %d", data, size);
+#endif
+
+        // Byte 0 is HID report ID
+        switch (data[0]) {
+        case k_ShieldReportIdControllerState:
+            if (!joystick) {
+                break;
+            }
+            if (size == 16) {
+                HIDAPI_DriverShield_HandleStatePacketV103(joystick, ctx, data, size);
+            } else {
+                HIDAPI_DriverShield_HandleStatePacketV104(joystick, ctx, data, size);
+            }
+            break;
+        case k_ShieldReportIdControllerTouch:
+            if (!joystick) {
+                break;
+            }
+            HIDAPI_DriverShield_HandleTouchPacketV103(joystick, ctx, data, size);
+            break;
+        case k_ShieldReportIdCommandResponse:
+            cmd_resp_report = (ShieldCommandReport_t *)data;
+            switch (cmd_resp_report->cmd) {
+            case CMD_RUMBLE:
+                ctx->rumble_report_pending = false;
+                HIDAPI_DriverShield_SendNextRumble(device);
+                break;
+            case CMD_CHARGE_STATE:
+                ctx->has_charging = true;
+                ctx->charging = cmd_resp_report->payload[0];
+                HIDAPI_DriverShield_UpdatePowerInfo(joystick, ctx);
+                break;
+            case CMD_BATTERY_STATE:
+                ctx->has_battery_level = true;
+                ctx->battery_level = cmd_resp_report->payload[2];
+                HIDAPI_DriverShield_UpdatePowerInfo(joystick, ctx);
+                break;
+            }
+            break;
+        }
+    }
+
+    // Ask for battery state again if we're due for an update
+    if (joystick && SDL_GetTicks() >= (ctx->last_battery_query_time + BATTERY_POLL_INTERVAL_MS)) {
+        ctx->last_battery_query_time = SDL_GetTicks();
+        HIDAPI_DriverShield_SendCommand(device, CMD_BATTERY_STATE, NULL, 0);
+    }
+
+    // Retransmit rumble packets if they've lasted longer than the hardware supports
+    if ((ctx->left_motor_amplitude != 0 || ctx->right_motor_amplitude != 0) &&
+        SDL_GetTicks() >= (ctx->last_rumble_time + RUMBLE_REFRESH_INTERVAL_MS)) {
+        ctx->rumble_update_pending = true;
+        HIDAPI_DriverShield_SendNextRumble(device);
+    }
+
+    if (size < 0) {
+        // Read error, device is disconnected
+        HIDAPI_JoystickDisconnected(device, device->joysticks[0]);
+    }
+    return (size >= 0);
+}
+
+static void HIDAPI_DriverShield_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+}
+
+static void HIDAPI_DriverShield_FreeDevice(SDL_HIDAPI_Device *device)
+{
+}
+
+SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverShield = {
+    SDL_HINT_JOYSTICK_HIDAPI_SHIELD,
+    true,
+    HIDAPI_DriverShield_RegisterHints,
+    HIDAPI_DriverShield_UnregisterHints,
+    HIDAPI_DriverShield_IsEnabled,
+    HIDAPI_DriverShield_IsSupportedDevice,
+    HIDAPI_DriverShield_InitDevice,
+    HIDAPI_DriverShield_GetDevicePlayerIndex,
+    HIDAPI_DriverShield_SetDevicePlayerIndex,
+    HIDAPI_DriverShield_UpdateDevice,
+    HIDAPI_DriverShield_OpenJoystick,
+    HIDAPI_DriverShield_RumbleJoystick,
+    HIDAPI_DriverShield_RumbleJoystickTriggers,
+    HIDAPI_DriverShield_GetJoystickCapabilities,
+    HIDAPI_DriverShield_SetJoystickLED,
+    HIDAPI_DriverShield_SendJoystickEffect,
+    HIDAPI_DriverShield_SetJoystickSensorsEnabled,
+    HIDAPI_DriverShield_CloseJoystick,
+    HIDAPI_DriverShield_FreeDevice,
+};
+
+#endif // SDL_JOYSTICK_HIDAPI_SHIELD
+
+#endif // SDL_JOYSTICK_HIDAPI
diff --git a/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_stadia.c b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_stadia.c
new file mode 100644
index 0000000..487bf41
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_stadia.c
@@ -0,0 +1,324 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI
+
+#include "../SDL_sysjoystick.h"
+#include "SDL_hidapijoystick_c.h"
+#include "SDL_hidapi_rumble.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI_STADIA
+
+// Define this if you want to log all packets from the controller
+// #define DEBUG_STADIA_PROTOCOL
+
+enum
+{
+    SDL_GAMEPAD_BUTTON_STADIA_CAPTURE = 11,
+    SDL_GAMEPAD_BUTTON_STADIA_GOOGLE_ASSISTANT,
+    SDL_GAMEPAD_NUM_STADIA_BUTTONS,
+};
+
+typedef struct
+{
+    bool rumble_supported;
+    Uint8 last_state[USB_PACKET_LENGTH];
+} SDL_DriverStadia_Context;
+
+static void HIDAPI_DriverStadia_RegisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_STADIA, callback, userdata);
+}
+
+static void HIDAPI_DriverStadia_UnregisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_STADIA, callback, userdata);
+}
+
+static bool HIDAPI_DriverStadia_IsEnabled(void)
+{
+    return SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_STADIA, SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI, SDL_HIDAPI_DEFAULT));
+}
+
+static bool HIDAPI_DriverStadia_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)
+{
+    return SDL_IsJoystickGoogleStadiaController(vendor_id, product_id);
+}
+
+static bool HIDAPI_DriverStadia_InitDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverStadia_Context *ctx;
+
+    ctx = (SDL_DriverStadia_Context *)SDL_calloc(1, sizeof(*ctx));
+    if (!ctx) {
+        return false;
+    }
+    device->context = ctx;
+
+    // Check whether rumble is supported
+    {
+        Uint8 rumble_packet[] = { 0x05, 0x00, 0x00, 0x00, 0x00 };
+
+        if (SDL_hid_write(device->dev, rumble_packet, sizeof(rumble_packet)) >= 0) {
+            ctx->rumble_supported = true;
+        }
+    }
+
+    HIDAPI_SetDeviceName(device, "Google Stadia Controller");
+
+    return HIDAPI_JoystickConnected(device, NULL);
+}
+
+static int HIDAPI_DriverStadia_GetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id)
+{
+    return -1;
+}
+
+static void HIDAPI_DriverStadia_SetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id, int player_index)
+{
+}
+
+static bool HIDAPI_DriverStadia_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverStadia_Context *ctx = (SDL_DriverStadia_Context *)device->context;
+
+    SDL_AssertJoysticksLocked();
+
+    SDL_zeroa(ctx->last_state);
+
+    // Initialize the joystick capabilities
+    joystick->nbuttons = SDL_GAMEPAD_NUM_STADIA_BUTTONS;
+    joystick->naxes = SDL_GAMEPAD_AXIS_COUNT;
+    joystick->nhats = 1;
+
+    return true;
+}
+
+static bool HIDAPI_DriverStadia_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+    SDL_DriverStadia_Context *ctx = (SDL_DriverStadia_Context *)device->context;
+
+    if (ctx->rumble_supported) {
+        Uint8 rumble_packet[] = { 0x05, 0x00, 0x00, 0x00, 0x00 };
+
+
+        rumble_packet[1] = (low_frequency_rumble & 0xFF);
+        rumble_packet[2] = (low_frequency_rumble >> 8);
+        rumble_packet[3] = (high_frequency_rumble & 0xFF);
+        rumble_packet[4] = (high_frequency_rumble >> 8);
+
+        if (SDL_HIDAPI_SendRumble(device, rumble_packet, sizeof(rumble_packet)) != sizeof(rumble_packet)) {
+            return SDL_SetError("Couldn't send rumble packet");
+        }
+        return true;
+    } else {
+        return SDL_Unsupported();
+    }
+}
+
+static bool HIDAPI_DriverStadia_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
+{
+    return SDL_Unsupported();
+}
+
+static Uint32 HIDAPI_DriverStadia_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverStadia_Context *ctx = (SDL_DriverStadia_Context *)device->context;
+    Uint32 caps = 0;
+
+    if (ctx->rumble_supported) {
+        caps |= SDL_JOYSTICK_CAP_RUMBLE;
+    }
+    return caps;
+}
+
+static bool HIDAPI_DriverStadia_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverStadia_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *data, int size)
+{
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverStadia_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, bool enabled)
+{
+    return SDL_Unsupported();
+}
+
+static void HIDAPI_DriverStadia_HandleStatePacket(SDL_Joystick *joystick, SDL_DriverStadia_Context *ctx, Uint8 *data, int size)
+{
+    Sint16 axis;
+    Uint64 timestamp = SDL_GetTicksNS();
+
+    // The format is the same but the original FW will send 10 bytes and January '21 FW update will send 11
+    if (size < 10 || data[0] != 0x03) {
+        // We don't know how to handle this report
+        return;
+    }
+
+    if (ctx->last_state[1] != data[1]) {
+        Uint8 hat;
+
+        switch (data[1]) {
+        case 0:
+            hat = SDL_HAT_UP;
+            break;
+        case 1:
+            hat = SDL_HAT_RIGHTUP;
+            break;
+        case 2:
+            hat = SDL_HAT_RIGHT;
+            break;
+        case 3:
+            hat = SDL_HAT_RIGHTDOWN;
+            break;
+        case 4:
+            hat = SDL_HAT_DOWN;
+            break;
+        case 5:
+            hat = SDL_HAT_LEFTDOWN;
+            break;
+        case 6:
+            hat = SDL_HAT_LEFT;
+            break;
+        case 7:
+            hat = SDL_HAT_LEFTUP;
+            break;
+        default:
+            hat = SDL_HAT_CENTERED;
+            break;
+        }
+        SDL_SendJoystickHat(timestamp, joystick, 0, hat);
+    }
+
+    if (ctx->last_state[2] != data[2]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK, ((data[2] & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data[2] & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data[2] & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_STICK, ((data[2] & 0x80) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_STADIA_CAPTURE, ((data[2] & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_STADIA_GOOGLE_ASSISTANT, ((data[2] & 0x02) != 0));
+    }
+
+    if (ctx->last_state[3] != data[3]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SOUTH, ((data[3] & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_EAST, ((data[3] & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_WEST, ((data[3] & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_NORTH, ((data[3] & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data[3] & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data[3] & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data[3] & 0x01) != 0));
+    }
+
+#define READ_STICK_AXIS(offset) \
+    (data[offset] == 0x80 ? 0 : (Sint16)HIDAPI_RemapVal((float)((int)data[offset] - 0x80), 0x01 - 0x80, 0xff - 0x80, SDL_MIN_SINT16, SDL_MAX_SINT16))
+    {
+        axis = READ_STICK_AXIS(4);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, axis);
+        axis = READ_STICK_AXIS(5);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, axis);
+        axis = READ_STICK_AXIS(6);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, axis);
+        axis = READ_STICK_AXIS(7);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, axis);
+    }
+#undef READ_STICK_AXIS
+
+#define READ_TRIGGER_AXIS(offset) \
+    (Sint16)(((int)data[offset] * 257) - 32768)
+    {
+        axis = READ_TRIGGER_AXIS(8);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, axis);
+        axis = READ_TRIGGER_AXIS(9);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, axis);
+    }
+#undef READ_TRIGGER_AXIS
+
+    SDL_memcpy(ctx->last_state, data, SDL_min(size, sizeof(ctx->last_state)));
+}
+
+static bool HIDAPI_DriverStadia_UpdateDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverStadia_Context *ctx = (SDL_DriverStadia_Context *)device->context;
+    SDL_Joystick *joystick = NULL;
+    Uint8 data[USB_PACKET_LENGTH];
+    int size = 0;
+
+    if (device->num_joysticks > 0) {
+        joystick = SDL_GetJoystickFromID(device->joysticks[0]);
+    } else {
+        return false;
+    }
+
+    while ((size = SDL_hid_read_timeout(device->dev, data, sizeof(data), 0)) > 0) {
+#ifdef DEBUG_STADIA_PROTOCOL
+        HIDAPI_DumpPacket("Google Stadia packet: size = %d", data, size);
+#endif
+        if (!joystick) {
+            continue;
+        }
+
+        HIDAPI_DriverStadia_HandleStatePacket(joystick, ctx, data, size);
+    }
+
+    if (size < 0) {
+        // Read error, device is disconnected
+        HIDAPI_JoystickDisconnected(device, device->joysticks[0]);
+    }
+    return (size >= 0);
+}
+
+static void HIDAPI_DriverStadia_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+}
+
+static void HIDAPI_DriverStadia_FreeDevice(SDL_HIDAPI_Device *device)
+{
+}
+
+SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverStadia = {
+    SDL_HINT_JOYSTICK_HIDAPI_STADIA,
+    true,
+    HIDAPI_DriverStadia_RegisterHints,
+    HIDAPI_DriverStadia_UnregisterHints,
+    HIDAPI_DriverStadia_IsEnabled,
+    HIDAPI_DriverStadia_IsSupportedDevice,
+    HIDAPI_DriverStadia_InitDevice,
+    HIDAPI_DriverStadia_GetDevicePlayerIndex,
+    HIDAPI_DriverStadia_SetDevicePlayerIndex,
+    HIDAPI_DriverStadia_UpdateDevice,
+    HIDAPI_DriverStadia_OpenJoystick,
+    HIDAPI_DriverStadia_RumbleJoystick,
+    HIDAPI_DriverStadia_RumbleJoystickTriggers,
+    HIDAPI_DriverStadia_GetJoystickCapabilities,
+    HIDAPI_DriverStadia_SetJoystickLED,
+    HIDAPI_DriverStadia_SendJoystickEffect,
+    HIDAPI_DriverStadia_SetJoystickSensorsEnabled,
+    HIDAPI_DriverStadia_CloseJoystick,
+    HIDAPI_DriverStadia_FreeDevice,
+};
+
+#endif // SDL_JOYSTICK_HIDAPI_STADIA
+
+#endif // SDL_JOYSTICK_HIDAPI
diff --git a/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_steam.c b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_steam.c
new file mode 100644
index 0000000..b48d353
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_steam.c
@@ -0,0 +1,1534 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI
+
+#include "../../SDL_hints_c.h"
+#include "../SDL_sysjoystick.h"
+#include "SDL_hidapijoystick_c.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI_STEAM
+
+// Define this if you want to log all packets from the controller
+// #define DEBUG_STEAM_PROTOCOL
+
+#define SDL_HINT_JOYSTICK_HIDAPI_STEAM_PAIRING_ENABLED    "SDL_JOYSTICK_HIDAPI_STEAM_PAIRING_ENABLED"
+
+#if defined(SDL_PLATFORM_ANDROID) || defined(SDL_PLATFORM_IOS) || defined(SDL_PLATFORM_TVOS)
+// This requires prompting for Bluetooth permissions, so make sure the application really wants it
+#define SDL_HINT_JOYSTICK_HIDAPI_STEAM_DEFAULT  false
+#else
+#define SDL_HINT_JOYSTICK_HIDAPI_STEAM_DEFAULT  SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI, SDL_HIDAPI_DEFAULT)
+#endif
+
+#define PAIRING_STATE_DURATION_SECONDS  60
+
+
+/*****************************************************************************************************/
+
+#include "steam/controller_constants.h"
+#include "steam/controller_structs.h"
+
+enum
+{
+    SDL_GAMEPAD_BUTTON_STEAM_RIGHT_PADDLE = 11,
+    SDL_GAMEPAD_BUTTON_STEAM_LEFT_PADDLE,
+    SDL_GAMEPAD_NUM_STEAM_BUTTONS,
+};
+
+typedef struct SteamControllerStateInternal_t
+{
+    // Controller Type for this Controller State
+    Uint32 eControllerType;
+
+    // If packet num matches that on your prior call, then the controller state hasn't been changed since
+    // your last call and there is no need to process it
+    Uint32 unPacketNum;
+
+    // bit flags for each of the buttons
+    Uint64 ulButtons;
+
+    // Left pad coordinates
+    short sLeftPadX;
+    short sLeftPadY;
+
+    // Right pad coordinates
+    short sRightPadX;
+    short sRightPadY;
+
+    // Center pad coordinates
+    short sCenterPadX;
+    short sCenterPadY;
+
+    // Left analog stick coordinates
+    short sLeftStickX;
+    short sLeftStickY;
+
+    // Right analog stick coordinates
+    short sRightStickX;
+    short sRightStickY;
+
+    unsigned short sTriggerL;
+    unsigned short sTriggerR;
+
+    short sAccelX;
+    short sAccelY;
+    short sAccelZ;
+
+    short sGyroX;
+    short sGyroY;
+    short sGyroZ;
+
+    float sGyroQuatW;
+    float sGyroQuatX;
+    float sGyroQuatY;
+    float sGyroQuatZ;
+
+    short sGyroSteeringAngle;
+
+    unsigned short sBatteryLevel;
+
+    // Pressure sensor data.
+    unsigned short sPressurePadLeft;
+    unsigned short sPressurePadRight;
+
+    unsigned short sPressureBumperLeft;
+    unsigned short sPressureBumperRight;
+
+    // Internal state data
+    short sPrevLeftPad[2];
+    short sPrevLeftStick[2];
+} SteamControllerStateInternal_t;
+
+// Defines for ulButtons in SteamControllerStateInternal_t
+#define STEAM_RIGHT_TRIGGER_MASK           0x00000001
+#define STEAM_LEFT_TRIGGER_MASK            0x00000002
+#define STEAM_RIGHT_BUMPER_MASK            0x00000004
+#define STEAM_LEFT_BUMPER_MASK             0x00000008
+#define STEAM_BUTTON_NORTH_MASK            0x00000010 // Y
+#define STEAM_BUTTON_EAST_MASK             0x00000020 // B
+#define STEAM_BUTTON_WEST_MASK             0x00000040 // X
+#define STEAM_BUTTON_SOUTH_MASK            0x00000080 // A
+#define STEAM_DPAD_UP_MASK                 0x00000100 // DPAD UP
+#define STEAM_DPAD_RIGHT_MASK              0x00000200 // DPAD RIGHT
+#define STEAM_DPAD_LEFT_MASK               0x00000400 // DPAD LEFT
+#define STEAM_DPAD_DOWN_MASK               0x00000800 // DPAD DOWN
+#define STEAM_BUTTON_MENU_MASK             0x00001000 // SELECT
+#define STEAM_BUTTON_STEAM_MASK            0x00002000 // GUIDE
+#define STEAM_BUTTON_ESCAPE_MASK           0x00004000 // START
+#define STEAM_BUTTON_BACK_LEFT_MASK        0x00008000
+#define STEAM_BUTTON_BACK_RIGHT_MASK       0x00010000
+#define STEAM_BUTTON_LEFTPAD_CLICKED_MASK  0x00020000
+#define STEAM_BUTTON_RIGHTPAD_CLICKED_MASK 0x00040000
+#define STEAM_LEFTPAD_FINGERDOWN_MASK      0x00080000
+#define STEAM_RIGHTPAD_FINGERDOWN_MASK     0x00100000
+#define STEAM_JOYSTICK_BUTTON_MASK         0x00400000
+#define STEAM_LEFTPAD_AND_JOYSTICK_MASK    0x00800000
+
+// Look for report version 0x0001, type WIRELESS (3), length >= 1 byte
+#define D0G_IS_VALID_WIRELESS_EVENT(data, len) ((len) >= 5 && (data)[0] == 1 && (data)[1] == 0 && (data)[2] == 3 && (data)[3] >= 1)
+#define D0G_GET_WIRELESS_EVENT_TYPE(data)      ((data)[4])
+#define D0G_WIRELESS_DISCONNECTED              1
+#define D0G_WIRELESS_ESTABLISHED               2
+#define D0G_WIRELESS_NEWLYPAIRED               3
+
+#define D0G_IS_WIRELESS_DISCONNECT(data, len) (D0G_IS_VALID_WIRELESS_EVENT(data, len) && D0G_GET_WIRELESS_EVENT_TYPE(data) == D0G_WIRELESS_DISCONNECTED)
+#define D0G_IS_WIRELESS_CONNECT(data, len)    (D0G_IS_VALID_WIRELESS_EVENT(data, len) && D0G_GET_WIRELESS_EVENT_TYPE(data) != D0G_WIRELESS_DISCONNECTED)
+
+
+#define MAX_REPORT_SEGMENT_PAYLOAD_SIZE 18
+/*
+ * SteamControllerPacketAssembler has to be used when reading output repots from controllers.
+ */
+typedef struct
+{
+    uint8_t uBuffer[MAX_REPORT_SEGMENT_PAYLOAD_SIZE * 8 + 1];
+    int nExpectedSegmentNumber;
+    bool bIsBle;
+} SteamControllerPacketAssembler;
+
+#undef clamp
+#define clamp(val, min, max) (((val) > (max)) ? (max) : (((val) < (min)) ? (min) : (val)))
+
+#undef offsetof
+#define offsetof(s, m) (size_t) & (((s *)0)->m)
+
+#ifdef DEBUG_STEAM_CONTROLLER
+#define DPRINTF(format, ...) printf(format, ##__VA_ARGS__)
+#define HEXDUMP(ptr, len)    hexdump(ptr, len)
+#else
+#define DPRINTF(format, ...)
+#define HEXDUMP(ptr, len)
+#endif
+#define printf SDL_Log
+
+#define MAX_REPORT_SEGMENT_SIZE        (MAX_REPORT_SEGMENT_PAYLOAD_SIZE + 2)
+#define CALC_REPORT_SEGMENT_NUM(index) ((index / MAX_REPORT_SEGMENT_PAYLOAD_SIZE) & 0x07)
+#define REPORT_SEGMENT_DATA_FLAG       0x80
+#define REPORT_SEGMENT_LAST_FLAG       0x40
+#define BLE_REPORT_NUMBER              0x03
+
+#define STEAMCONTROLLER_TRIGGER_MAX_ANALOG 26000
+
+// Enable mouse mode when using the Steam Controller locally
+#undef ENABLE_MOUSE_MODE
+
+// Wireless firmware quirk: the firmware intentionally signals "failure" when performing
+// SET_FEATURE / GET_FEATURE when it actually means "pending radio roundtrip". The only
+// way to make SET_FEATURE / GET_FEATURE work is to loop several times with a sleep. If
+// it takes more than 50ms to get the response for SET_FEATURE / GET_FEATURE, we assume
+// that the controller has failed.
+#define RADIO_WORKAROUND_SLEEP_ATTEMPTS    50
+#define RADIO_WORKAROUND_SLEEP_DURATION_US 500
+
+// This was defined by experimentation. 2000 seemed to work but to give that extra bit of margin, set to 3ms.
+#define CONTROLLER_CONFIGURATION_DELAY_US 3000
+
+static uint8_t GetSegmentHeader(int nSegmentNumber, bool bLastPacket)
+{
+    uint8_t header = REPORT_SEGMENT_DATA_FLAG;
+    header |= nSegmentNumber;
+    if (bLastPacket) {
+        header |= REPORT_SEGMENT_LAST_FLAG;
+    }
+
+    return header;
+}
+
+static void hexdump(const uint8_t *ptr, int len)
+{
+    HIDAPI_DumpPacket("Data", ptr, len);
+}
+
+static void ResetSteamControllerPacketAssembler(SteamControllerPacketAssembler *pAssembler)
+{
+    SDL_memset(pAssembler->uBuffer, 0, sizeof(pAssembler->uBuffer));
+    pAssembler->nExpectedSegmentNumber = 0;
+}
+
+static void InitializeSteamControllerPacketAssembler(SteamControllerPacketAssembler *pAssembler, bool bIsBle)
+{
+    pAssembler->bIsBle = bIsBle;
+    ResetSteamControllerPacketAssembler(pAssembler);
+}
+
+// Returns:
+//     <0 on error
+//     0 on not ready
+//     Complete packet size on completion
+static int WriteSegmentToSteamControllerPacketAssembler(SteamControllerPacketAssembler *pAssembler, const uint8_t *pSegment, int nSegmentLength)
+{
+    if (pAssembler->bIsBle) {
+        uint8_t uSegmentHeader = pSegment[1];
+        int nSegmentNumber = uSegmentHeader & 0x07;
+
+        HEXDUMP(pSegment, nSegmentLength);
+
+        if (pSegment[0] != BLE_REPORT_NUMBER) {
+            // We may get keyboard/mouse input events until controller stops sending them
+            return 0;
+        }
+
+        if (nSegmentLength != MAX_REPORT_SEGMENT_SIZE) {
+            printf("Bad segment size! %d\n", nSegmentLength);
+            hexdump(pSegment, nSegmentLength);
+            ResetSteamControllerPacketAssembler(pAssembler);
+            return -1;
+        }
+
+        DPRINTF("GOT PACKET HEADER = 0x%x\n", uSegmentHeader);
+
+        if (!(uSegmentHeader & REPORT_SEGMENT_DATA_FLAG)) {
+            // We get empty segments, just ignore them
+            return 0;
+        }
+
+        if (nSegmentNumber != pAssembler->nExpectedSegmentNumber) {
+            ResetSteamControllerPacketAssembler(pAssembler);
+
+            if (nSegmentNumber) {
+                // This happens occasionally
+                DPRINTF("Bad segment number, got %d, expected %d\n",
+                        nSegmentNumber, pAssembler->nExpectedSegmentNumber);
+                return -1;
+            }
+        }
+
+        SDL_memcpy(pAssembler->uBuffer + nSegmentNumber * MAX_REPORT_SEGMENT_PAYLOAD_SIZE,
+                   pSegment + 2, // ignore header and report number
+                   MAX_REPORT_SEGMENT_PAYLOAD_SIZE);
+
+        if (uSegmentHeader & REPORT_SEGMENT_LAST_FLAG) {
+            pAssembler->nExpectedSegmentNumber = 0;
+            return (nSegmentNumber + 1) * MAX_REPORT_SEGMENT_PAYLOAD_SIZE;
+        }
+
+        pAssembler->nExpectedSegmentNumber++;
+    } else {
+        // Just pass through
+        SDL_memcpy(pAssembler->uBuffer,
+                   pSegment,
+                   nSegmentLength);
+        return nSegmentLength;
+    }
+
+    return 0;
+}
+
+#define BLE_MAX_READ_RETRIES 8
+
+static int SetFeatureReport(SDL_HIDAPI_Device *dev, const unsigned char uBuffer[65], int nActualDataLen)
+{
+    int nRet = -1;
+
+    DPRINTF("SetFeatureReport %p %p %d\n", dev, uBuffer, nActualDataLen);
+
+    if (dev->is_bluetooth) {
+        int nSegmentNumber = 0;
+        uint8_t uPacketBuffer[MAX_REPORT_SEGMENT_SIZE];
+        const unsigned char *pBufferPtr = uBuffer + 1;
+
+        if (nActualDataLen < 1) {
+            return -1;
+        }
+
+        // Skip report number in data
+        nActualDataLen--;
+
+        while (nActualDataLen > 0) {
+            int nBytesInPacket = nActualDataLen > MAX_REPORT_SEGMENT_PAYLOAD_SIZE ? MAX_REPORT_SEGMENT_PAYLOAD_SIZE : nActualDataLen;
+
+            nActualDataLen -= nBytesInPacket;
+
+            // Construct packet
+            SDL_memset(uPacketBuffer, 0, sizeof(uPacketBuffer));
+            uPacketBuffer[0] = BLE_REPORT_NUMBER;
+            uPacketBuffer[1] = GetSegmentHeader(nSegmentNumber, nActualDataLen == 0);
+            SDL_memcpy(&uPacketBuffer[2], pBufferPtr, nBytesInPacket);
+
+            pBufferPtr += nBytesInPacket;
+            nSegmentNumber++;
+
+            nRet = SDL_hid_send_feature_report(dev->dev, uPacketBuffer, sizeof(uPacketBuffer));
+        }
+    } else {
+        for (int nRetries = 0; nRetries < RADIO_WORKAROUND_SLEEP_ATTEMPTS; nRetries++) {
+            nRet = SDL_hid_send_feature_report(dev->dev, uBuffer, 65);
+            if (nRet >= 0) {
+                break;
+            }
+
+            SDL_DelayNS(RADIO_WORKAROUND_SLEEP_DURATION_US * 1000);
+        }
+    }
+
+    DPRINTF("SetFeatureReport() ret = %d\n", nRet);
+
+    return nRet;
+}
+
+static int GetFeatureReport(SDL_HIDAPI_Device *dev, unsigned char uBuffer[65])
+{
+    int nRet = -1;
+
+    DPRINTF("GetFeatureReport( %p %p )\n", dev, uBuffer);
+
+    if (dev->is_bluetooth) {
+        int nRetries = 0;
+        uint8_t uSegmentBuffer[MAX_REPORT_SEGMENT_SIZE + 1];
+        uint8_t ucBytesToRead = MAX_REPORT_SEGMENT_SIZE;
+        uint8_t ucDataStartOffset = 0;
+
+        SteamControllerPacketAssembler assembler;
+        InitializeSteamControllerPacketAssembler(&assembler, dev->is_bluetooth);
+
+        // On Windows and macOS, BLE devices get 2 copies of the feature report ID, one that is removed by ReadFeatureReport,
+        // and one that's included in the buffer we receive. We pad the bytes to read and skip over the report ID
+        // if necessary.
+#if defined(SDL_PLATFORM_WIN32) || defined(SDL_PLATFORM_MACOS)
+        ++ucBytesToRead;
+        ++ucDataStartOffset;
+#endif
+
+        while (nRetries < BLE_MAX_READ_RETRIES) {
+            SDL_memset(uSegmentBuffer, 0, sizeof(uSegmentBuffer));
+            uSegmentBuffer[0] = BLE_REPORT_NUMBER;
+            nRet = SDL_hid_get_feature_report(dev->dev, uSegmentBuffer, ucBytesToRead);
+
+            DPRINTF("GetFeatureReport ble ret=%d\n", nRet);
+            HEXDUMP(uSegmentBuffer, nRet);
+
+            // Zero retry counter if we got data
+            if (nRet > 2 && (uSegmentBuffer[ucDataStartOffset + 1] & REPORT_SEGMENT_DATA_FLAG)) {
+                nRetries = 0;
+            } else {
+                nRetries++;
+            }
+
+            if (nRet > 0) {
+                int nPacketLength = WriteSegmentToSteamControllerPacketAssembler(&assembler,
+                                                                                 uSegmentBuffer + ucDataStartOffset,
+                                                                                 nRet - ucDataStartOffset);
+
+                if (nPacketLength > 0 && nPacketLength < 65) {
+                    // Leave space for "report number"
+                    uBuffer[0] = 0;
+                    SDL_memcpy(uBuffer + 1, assembler.uBuffer, nPacketLength);
+                    return nPacketLength;
+                }
+            }
+        }
+        printf("Could not get a full ble packet after %d retries\n", nRetries);
+        return -1;
+    } else {
+        SDL_memset(uBuffer, 0, 65);
+
+        for (int nRetries = 0; nRetries < RADIO_WORKAROUND_SLEEP_ATTEMPTS; nRetries++) {
+            nRet = SDL_hid_get_feature_report(dev->dev, uBuffer, 65);
+            if (nRet >= 0) {
+                break;
+            }
+
+            SDL_DelayNS(RADIO_WORKAROUND_SLEEP_DURATION_US * 1000);
+        }
+
+        DPRINTF("GetFeatureReport USB ret=%d\n", nRet);
+        HEXDUMP(uBuffer, nRet);
+    }
+
+    return nRet;
+}
+
+static int ReadResponse(SDL_HIDAPI_Device *dev, uint8_t uBuffer[65], int nExpectedResponse)
+{
+    for (int nRetries = 0; nRetries < 10; nRetries++) {
+        int nRet = GetFeatureReport(dev, uBuffer);
+
+        DPRINTF("ReadResponse( %p %p 0x%x )\n", dev, uBuffer, nExpectedResponse);
+
+        if (nRet < 0) {
+            continue;
+        }
+
+        DPRINTF("ReadResponse got %d bytes of data: ", nRet);
+        HEXDUMP(uBuffer, nRet);
+
+        if (uBuffer[1] != nExpectedResponse) {
+            continue;
+        }
+
+        return nRet;
+    }
+    return -1;
+}
+
+//---------------------------------------------------------------------------
+// Reset steam controller (unmap buttons and pads) and re-fetch capability bits
+//---------------------------------------------------------------------------
+static bool ResetSteamController(SDL_HIDAPI_Device *dev, bool bSuppressErrorSpew, uint32_t *punUpdateRateUS)
+{
+    // Firmware quirk: Set Feature and Get Feature requests always require a 65-byte buffer.
+    unsigned char buf[65];
+    unsigned int i;
+    int res = -1;
+    int nSettings = 0;
+    int nAttributesLength;
+    FeatureReportMsg *msg;
+    uint32_t unUpdateRateUS = 9000; // Good default rate
+
+    DPRINTF("ResetSteamController hid=%p\n", dev);
+
+    buf[0] = 0;
+    buf[1] = ID_GET_ATTRIBUTES_VALUES;
+    res = SetFeatureReport(dev, buf, 2);
+    if (res < 0) {
+        if (!bSuppressErrorSpew) {
+            printf("GET_ATTRIBUTES_VALUES failed for controller %p\n", dev);
+        }
+        return false;
+    }
+
+    // Retrieve GET_ATTRIBUTES_VALUES result
+    // Wireless controller endpoints without a connected controller will return nAttrs == 0
+    res = ReadResponse(dev, buf, ID_GET_ATTRIBUTES_VALUES);
+    if (res < 0 || buf[1] != ID_GET_ATTRIBUTES_VALUES) {
+        HEXDUMP(buf, res);
+        if (!bSuppressErrorSpew) {
+            printf("Bad GET_ATTRIBUTES_VALUES response for controller %p\n", dev);
+        }
+        return false;
+    }
+
+    nAttributesLength = buf[2];
+    if (nAttributesLength > res) {
+        if (!bSuppressErrorSpew) {
+            printf("Bad GET_ATTRIBUTES_VALUES response for controller %p\n", dev);
+        }
+        return false;
+    }
+
+    msg = (FeatureReportMsg *)&buf[1];
+    for (i = 0; i < (int)msg->header.length / sizeof(ControllerAttribute); ++i) {
+        uint8_t unAttribute = msg->payload.getAttributes.attributes[i].attributeTag;
+        uint32_t unValue = msg->payload.getAttributes.attributes[i].attributeValue;
+
+        switch (unAttribute) {
+        case ATTRIB_UNIQUE_ID:
+            break;
+        case ATTRIB_PRODUCT_ID:
+            break;
+        case ATTRIB_CAPABILITIES:
+            break;
+        case ATTRIB_CONNECTION_INTERVAL_IN_US:
+            unUpdateRateUS = unValue;
+            break;
+        default:
+            break;
+        }
+    }
+    if (punUpdateRateUS) {
+        *punUpdateRateUS = unUpdateRateUS;
+    }
+
+    // Clear digital button mappings
+    buf[0] = 0;
+    buf[1] = ID_CLEAR_DIGITAL_MAPPINGS;
+    res = SetFeatureReport(dev, buf, 2);
+    if (res < 0) {
+        if (!bSuppressErrorSpew) {
+            printf("CLEAR_DIGITAL_MAPPINGS failed for controller %p\n", dev);
+        }
+        return false;
+    }
+
+    // Reset the default settings
+    SDL_memset(buf, 0, 65);
+    buf[1] = ID_LOAD_DEFAULT_SETTINGS;
+    buf[2] = 0;
+    res = SetFeatureReport(dev, buf, 3);
+    if (res < 0) {
+        if (!bSuppressErrorSpew) {
+            printf("LOAD_DEFAULT_SETTINGS failed for controller %p\n", dev);
+        }
+        return false;
+    }
+
+    // Apply custom settings - clear trackpad modes (cancel mouse emulation), etc
+#define ADD_SETTING(SETTING, VALUE)                        \
+    buf[3 + nSettings * 3] = SETTING;                      \
+    buf[3 + nSettings * 3 + 1] = ((uint16_t)VALUE) & 0xFF; \
+    buf[3 + nSettings * 3 + 2] = ((uint16_t)VALUE) >> 8;   \
+    ++nSettings;
+
+    SDL_memset(buf, 0, 65);
+    buf[1] = ID_SET_SETTINGS_VALUES;
+    ADD_SETTING(SETTING_WIRELESS_PACKET_VERSION, 2);
+    ADD_SETTING(SETTING_LEFT_TRACKPAD_MODE, TRACKPAD_NONE);
+#ifdef ENABLE_MOUSE_MODE
+    ADD_SETTING(SETTING_RIGHT_TRACKPAD_MODE, TRACKPAD_ABSOLUTE_MOUSE);
+    ADD_SETTING(SETTING_SMOOTH_ABSOLUTE_MOUSE, 1);
+    ADD_SETTING(SETTING_MOMENTUM_MAXIMUM_VELOCITY, 20000); // [0-20000] default 8000
+    ADD_SETTING(SETTING_MOMENTUM_DECAY_AMOUNT, 50);       // [0-50] default 5
+#else
+    ADD_SETTING(SETTING_RIGHT_TRACKPAD_MODE, TRACKPAD_NONE);
+    ADD_SETTING(SETTING_SMOOTH_ABSOLUTE_MOUSE, 0);
+#endif
+    buf[2] = (unsigned char)(nSettings * 3);
+
+    res = SetFeatureReport(dev, buf, 3 + nSettings * 3);
+    if (res < 0) {
+        if (!bSuppressErrorSpew) {
+            printf("SET_SETTINGS failed for controller %p\n", dev);
+        }
+        return false;
+    }
+
+#ifdef ENABLE_MOUSE_MODE
+    // Wait for ID_CLEAR_DIGITAL_MAPPINGS to be processed on the controller
+    bool bMappingsCleared = false;
+    int iRetry;
+    for (iRetry = 0; iRetry < 2; ++iRetry) {
+        SDL_memset(buf, 0, 65);
+        buf[1] = ID_GET_DIGITAL_MAPPINGS;
+        buf[2] = 1; // one byte - requesting from index 0
+        buf[3] = 0;
+        res = SetFeatureReport(dev, buf, 4);
+        if (res < 0) {
+            printf("GET_DIGITAL_MAPPINGS failed for controller %p\n", dev);
+            return false;
+        }
+
+        res = ReadResponse(dev, buf, ID_GET_DIGITAL_MAPPINGS);
+        if (res < 0 || buf[1] != ID_GET_DIGITAL_MAPPINGS) {
+            printf("Bad GET_DIGITAL_MAPPINGS response for controller %p\n", dev);
+            return false;
+        }
+
+        // If the length of the digital mappings result is not 1 (index byte, no mappings) then clearing hasn't executed
+        if (buf[2] == 1 && buf[3] == 0xFF) {
+            bMappingsCleared = true;
+            break;
+        }
+        usleep(CONTROLLER_CONFIGURATION_DELAY_US);
+    }
+
+    if (!bMappingsCleared && !bSuppressErrorSpew) {
+        printf("Warning: CLEAR_DIGITAL_MAPPINGS never completed for controller %p\n", dev);
+    }
+
+    // Set our new mappings
+    SDL_memset(buf, 0, 65);
+    buf[1] = ID_SET_DIGITAL_MAPPINGS;
+    buf[2] = 6; // 2 settings x 3 bytes
+    buf[3] = IO_DIGITAL_BUTTON_RIGHT_TRIGGER;
+    buf[4] = DEVICE_MOUSE;
+    buf[5] = MOUSE_BTN_LEFT;
+    buf[6] = IO_DIGITAL_BUTTON_LEFT_TRIGGER;
+    buf[7] = DEVICE_MOUSE;
+    buf[8] = MOUSE_BTN_RIGHT;
+
+    res = SetFeatureReport(dev, buf, 9);
+    if (res < 0) {
+        if (!bSuppressErrorSpew) {
+            printf("SET_DIGITAL_MAPPINGS failed for controller %p\n", dev);
+        }
+        return false;
+    }
+#endif // ENABLE_MOUSE_MODE
+
+    return true;
+}
+
+//---------------------------------------------------------------------------
+// Read from a Steam Controller
+//---------------------------------------------------------------------------
+static int ReadSteamController(SDL_hid_device *dev, uint8_t *pData, int nDataSize)
+{
+    SDL_memset(pData, 0, nDataSize);
+    pData[0] = BLE_REPORT_NUMBER; // hid_read will also overwrite this with the same value, 0x03
+    return SDL_hid_read(dev, pData, nDataSize);
+}
+
+//---------------------------------------------------------------------------
+// Set Steam Controller pairing state
+//---------------------------------------------------------------------------
+static void SetPairingState(SDL_HIDAPI_Device *dev, bool bEnablePairing)
+{
+    unsigned char buf[65];
+    SDL_memset(buf, 0, 65);
+    buf[1] = ID_ENABLE_PAIRING;
+    buf[2] = 2; // 2 payload bytes: bool + timeout
+    buf[3] = bEnablePairing ? 1 : 0;
+    buf[4] = bEnablePairing ? PAIRING_STATE_DURATION_SECONDS : 0;
+    SetFeatureReport(dev, buf, 5);
+}
+
+//---------------------------------------------------------------------------
+// Commit Steam Controller pairing
+//---------------------------------------------------------------------------
+static void CommitPairing(SDL_HIDAPI_Device *dev)
+{
+    unsigned char buf[65];
+    SDL_memset(buf, 0, 65);
+    buf[1] = ID_DONGLE_COMMIT_DEVICE;
+    SetFeatureReport(dev, buf, 2);
+}
+
+//---------------------------------------------------------------------------
+// Close a Steam Controller
+//---------------------------------------------------------------------------
+static void CloseSteamController(SDL_HIDAPI_Device *dev)
+{
+    // Switch the Steam Controller back to lizard mode so it works with the OS
+    unsigned char buf[65];
+    int nSettings = 0;
+
+    // Reset digital button mappings
+    SDL_memset(buf, 0, 65);
+    buf[1] = ID_SET_DEFAULT_DIGITAL_MAPPINGS;
+    SetFeatureReport(dev, buf, 2);
+
+    // Reset the default settings
+    SDL_memset(buf, 0, 65);
+    buf[1] = ID_LOAD_DEFAULT_SETTINGS;
+    buf[2] = 0;
+    SetFeatureReport(dev, buf, 3);
+
+    // Reset mouse mode for lizard mode
+    SDL_memset(buf, 0, 65);
+    buf[1] = ID_SET_SETTINGS_VALUES;
+    ADD_SETTING(SETTING_RIGHT_TRACKPAD_MODE, TRACKPAD_ABSOLUTE_MOUSE);
+    buf[2] = (unsigned char)(nSettings * 3);
+    SetFeatureReport(dev, buf, 3 + nSettings * 3);
+}
+
+//---------------------------------------------------------------------------
+// Scale and clamp values to a range
+//---------------------------------------------------------------------------
+static float RemapValClamped(float val, float A, float B, float C, float D)
+{
+    if (A == B) {
+        return (val - B) >= 0.0f ? D : C;
+    } else {
+        float cVal = (val - A) / (B - A);
+        cVal = clamp(cVal, 0.0f, 1.0f);
+
+        return C + (D - C) * cVal;
+    }
+}
+
+//---------------------------------------------------------------------------
+// Rotate the pad coordinates
+//---------------------------------------------------------------------------
+static void RotatePad(int *pX, int *pY, float flAngleInRad)
+{
+    int origX = *pX, origY = *pY;
+
+    *pX = (int)(SDL_cosf(flAngleInRad) * origX - SDL_sinf(flAngleInRad) * origY);
+    *pY = (int)(SDL_sinf(flAngleInRad) * origX + SDL_cosf(flAngleInRad) * origY);
+}
+static void RotatePadShort(short *pX, short *pY, float flAngleInRad)
+{
+    int origX = *pX, origY = *pY;
+
+    *pX = (short)(SDL_cosf(flAngleInRad) * origX - SDL_sinf(flAngleInRad) * origY);
+    *pY = (short)(SDL_sinf(flAngleInRad) * origX + SDL_cosf(flAngleInRad) * origY);
+}
+
+//---------------------------------------------------------------------------
+// Format the first part of the state packet
+//---------------------------------------------------------------------------
+static void FormatStatePacketUntilGyro(SteamControllerStateInternal_t *pState, ValveControllerStatePacket_t *pStatePacket)
+{
+    int nLeftPadX;
+    int nLeftPadY;
+    int nRightPadX;
+    int nRightPadY;
+    int nPadOffset;
+
+    // 15 degrees in rad
+    const float flRotationAngle = 0.261799f;
+
+    SDL_memset(pState, 0, offsetof(SteamControllerStateInternal_t, sBatteryLevel));
+
+    // pState->eControllerType = m_eControllerType;
+    pState->eControllerType = 2; // k_eControllerType_SteamController;
+    pState->unPacketNum = pStatePacket->unPacketNum;
+
+    // We have a chunk of trigger data in the packet format here, so zero it out afterwards
+    SDL_memcpy(&pState->ulButtons, &pStatePacket->ButtonTriggerData.ulButtons, 8);
+    pState->ulButtons &= ~0xFFFF000000LL;
+
+    // The firmware uses this bit to tell us what kind of data is packed into the left two axes
+    if (pStatePacket->ButtonTriggerData.ulButtons & STEAM_LEFTPAD_FINGERDOWN_MASK) {
+        // Finger-down bit not set; "left pad" is actually trackpad
+        pState->sLeftPadX = pState->sPrevLeftPad[0] = pStatePacket->sLeftPadX;
+        pState->sLeftPadY = pState->sPrevLeftPad[1] = pStatePacket->sLeftPadY;
+
+        if (pStatePacket->ButtonTriggerData.ulButtons & STEAM_LEFTPAD_AND_JOYSTICK_MASK) {
+            // The controller is interleaving both stick and pad data, both are active
+            pState->sLeftStickX = pState->sPrevLeftStick[0];
+            pState->sLeftStickY = pState->sPrevLeftStick[1];
+        } else {
+            // The stick is not active
+            pState->sPrevLeftStick[0] = 0;
+            pState->sPrevLeftStick[1] = 0;
+        }
+    } else {
+        // Finger-down bit not set; "left pad" is actually joystick
+
+        // XXX there's a firmware bug where sometimes padX is 0 and padY is a large number (actually the battery voltage)
+        // If that happens skip this packet and report last frames stick
+        /*
+                if ( m_eControllerType == k_eControllerType_SteamControllerV2 && pStatePacket->sLeftPadY > 900 ) {
+                    pState->sLeftStickX = pState->sPrevLeftStick[0];
+                    pState->sLeftStickY = pState->sPrevLeftStick[1];
+                } else
+        */
+        {
+            pState->sPrevLeftStick[0] = pState->sLeftStickX = pStatePacket->sLeftPadX;
+            pState->sPrevLeftStick[1] = pState->sLeftStickY = pStatePacket->sLeftPadY;
+        }
+        /*
+                if (m_eControllerType == k_eControllerType_SteamControllerV2) {
+                    UpdateV2JoystickCap(&state);
+                }
+        */
+
+        if (pStatePacket->ButtonTriggerData.ulButtons & STEAM_LEFTPAD_AND_JOYSTICK_MASK) {
+            // The controller is interleaving both stick and pad data, both are active
+            pState->sLeftPadX = pState->sPrevLeftPad[0];
+            pState->sLeftPadY = pState->sPrevLeftPad[1];
+        } else {
+            // The trackpad is not active
+            pState->sPrevLeftPad[0] = 0;
+            pState->sPrevLeftPad[1] = 0;
+
+            // Old controllers send trackpad click for joystick button when trackpad is not active
+            if (pState->ulButtons & STEAM_BUTTON_LEFTPAD_CLICKED_MASK) {
+                pState->ulButtons &= ~STEAM_BUTTON_LEFTPAD_CLICKED_MASK;
+                pState->ulButtons |= STEAM_JOYSTICK_BUTTON_MASK;
+            }
+        }
+    }
+
+    // Fingerdown bit indicates if the packed left axis data was joystick or pad,
+    // but if we are interleaving both, the left finger is definitely on the pad.
+    if (pStatePacket->ButtonTriggerData.ulButtons & STEAM_LEFTPAD_AND_JOYSTICK_MASK) {
+        pState->ulButtons |= STEAM_LEFTPAD_FINGERDOWN_MASK;
+    }
+
+    pState->sRightPadX = pStatePacket->sRightPadX;
+    pState->sRightPadY = pStatePacket->sRightPadY;
+
+    nLeftPadX = pState->sLeftPadX;
+    nLeftPadY = pState->sLeftPadY;
+    nRightPadX = pState->sRightPadX;
+    nRightPadY = pState->sRightPadY;
+
+    RotatePad(&nLeftPadX, &nLeftPadY, -flRotationAngle);
+    RotatePad(&nRightPadX, &nRightPadY, flRotationAngle);
+
+    if (pState->ulButtons & STEAM_LEFTPAD_FINGERDOWN_MASK) {
+        nPadOffset = 1000;
+    } else {
+        nPadOffset = 0;
+    }
+
+    pState->sLeftPadX = (short)clamp(nLeftPadX + nPadOffset, SDL_MIN_SINT16, SDL_MAX_SINT16);
+    pState->sLeftPadY = (short)clamp(nLeftPadY + nPadOffset, SDL_MIN_SINT16, SDL_MAX_SINT16);
+
+    nPadOffset = 0;
+    if (pState->ulButtons & STEAM_RIGHTPAD_FINGERDOWN_MASK) {
+        nPadOffset = 1000;
+    } else {
+        nPadOffset = 0;
+    }
+
+    pState->sRightPadX = (short)clamp(nRightPadX + nPadOffset, SDL_MIN_SINT16, SDL_MAX_SINT16);
+    pState->sRightPadY = (short)clamp(nRightPadY + nPadOffset, SDL_MIN_SINT16, SDL_MAX_SINT16);
+
+    pState->sTriggerL = (unsigned short)RemapValClamped((float)((pStatePacket->ButtonTriggerData.Triggers.nLeft << 7) | pStatePacket->ButtonTriggerData.Triggers.nLeft), 0, STEAMCONTROLLER_TRIGGER_MAX_ANALOG, 0, SDL_MAX_SINT16);
+    pState->sTriggerR = (unsigned short)RemapValClamped((float)((pStatePacket->ButtonTriggerData.Triggers.nRight << 7) | pStatePacket->ButtonTriggerData.Triggers.nRight), 0, STEAMCONTROLLER_TRIGGER_MAX_ANALOG, 0, SDL_MAX_SINT16);
+}
+
+//---------------------------------------------------------------------------
+// Update Steam Controller state from a BLE data packet, returns true if it parsed data
+//---------------------------------------------------------------------------
+static bool UpdateBLESteamControllerState(const uint8_t *pData, int nDataSize, SteamControllerStateInternal_t *pState)
+{
+    const float flRotationAngle = 0.261799f;
+    uint32_t ucOptionDataMask;
+
+    pState->unPacketNum++;
+    ucOptionDataMask = (*pData++ & 0xF0);
+    ucOptionDataMask |= (uint32_t)(*pData++) << 8;
+    if (ucOptionDataMask & k_EBLEButtonChunk1) {
+        SDL_memcpy(&pState->ulButtons, pData, 3);
+        pData += 3;
+    }
+    if (ucOptionDataMask & k_EBLEButtonChunk2) {
+        // The middle 2 bytes of the button bits over the wire are triggers when over the wire and non-SC buttons in the internal controller state packet
+        pState->sTriggerL = (unsigned short)RemapValClamped((float)((pData[0] << 7) | pData[0]), 0, STEAMCONTROLLER_TRIGGER_MAX_ANALOG, 0, SDL_MAX_SINT16);
+        pState->sTriggerR = (unsigned short)RemapValClamped((float)((pData[1] << 7) | pData[1]), 0, STEAMCONTROLLER_TRIGGER_MAX_ANALOG, 0, SDL_MAX_SINT16);
+        pData += 2;
+    }
+    if (ucOptionDataMask & k_EBLEButtonChunk3) {
+        uint8_t *pButtonByte = (uint8_t *)&pState->ulButtons;
+        pButtonByte[5] = *pData++;
+        pButtonByte[6] = *pData++;
+        pButtonByte[7] = *pData++;
+    }
+    if (ucOptionDataMask & k_EBLELeftJoystickChunk) {
+        // This doesn't handle any of the special headcrab stuff for raw joystick which is OK for now since that FW doesn't support
+        // this protocol yet either
+        int nLength = sizeof(pState->sLeftStickX) + sizeof(pState->sLeftStickY);
+        SDL_memcpy(&pState->sLeftStickX, pData, nLength);
+        pData += nLength;
+    }
+    if (ucOptionDataMask & k_EBLELeftTrackpadChunk) {
+        int nLength = sizeof(pState->sLeftPadX) + sizeof(pState->sLeftPadY);
+        int nPadOffset;
+        SDL_memcpy(&pState->sLeftPadX, pData, nLength);
+        if (pState->ulButtons & STEAM_LEFTPAD_FINGERDOWN_MASK) {
+            nPadOffset = 1000;
+        } else {
+            nPadOffset = 0;
+        }
+
+        RotatePadShort(&pState->sLeftPadX, &pState->sLeftPadY, -flRotationAngle);
+        pState->sLeftPadX = (short)clamp(pState->sLeftPadX + nPadOffset, SDL_MIN_SINT16, SDL_MAX_SINT16);
+        pState->sLeftPadY = (short)clamp(pState->sLeftPadY + nPadOffset, SDL_MIN_SINT16, SDL_MAX_SINT16);
+        pData += nLength;
+    }
+    if (ucOptionDataMask & k_EBLERightTrackpadChunk) {
+        int nLength = sizeof(pState->sRightPadX) + sizeof(pState->sRightPadY);
+        int nPadOffset = 0;
+
+        SDL_memcpy(&pState->sRightPadX, pData, nLength);
+
+        if (pState->ulButtons & STEAM_RIGHTPAD_FINGERDOWN_MASK) {
+            nPadOffset = 1000;
+        } else {
+            nPadOffset = 0;
+        }
+
+        RotatePadShort(&pState->sRightPadX, &pState->sRightPadY, flRotationAngle);
+        pState->sRightPadX = (short)clamp(pState->sRightPadX + nPadOffset, SDL_MIN_SINT16, SDL_MAX_SINT16);
+        pState->sRightPadY = (short)clamp(pState->sRightPadY + nPadOffset, SDL_MIN_SINT16, SDL_MAX_SINT16);
+        pData += nLength;
+    }
+    if (ucOptionDataMask & k_EBLEIMUAccelChunk) {
+        int nLength = sizeof(pState->sAccelX) + sizeof(pState->sAccelY) + sizeof(pState->sAccelZ);
+        SDL_memcpy(&pState->sAccelX, pData, nLength);
+        pData += nLength;
+    }
+    if (ucOptionDataMask & k_EBLEIMUGyroChunk) {
+        int nLength = sizeof(pState->sAccelX) + sizeof(pState->sAccelY) + sizeof(pState->sAccelZ);
+        SDL_memcpy(&pState->sGyroX, pData, nLength);
+        pData += nLength;
+    }
+    if (ucOptionDataMask & k_EBLEIMUQuatChunk) {
+        int nLength = sizeof(pState->sGyroQuatW) + sizeof(pState->sGyroQuatX) + sizeof(pState->sGyroQuatY) + sizeof(pState->sGyroQuatZ);
+        SDL_memcpy(&pState->sGyroQuatW, pData, nLength);
+        pData += nLength;
+    }
+    return true;
+}
+
+//---------------------------------------------------------------------------
+// Update Steam Controller state from a data packet, returns true if it parsed data
+//---------------------------------------------------------------------------
+static bool UpdateSteamControllerState(const uint8_t *pData, int nDataSize, SteamControllerStateInternal_t *pState)
+{
+    ValveInReport_t *pInReport = (ValveInReport_t *)pData;
+
+    if (pInReport->header.unReportVersion != k_ValveInReportMsgVersion) {
+        if ((pData[0] & 0x0F) == k_EBLEReportState) {
+            return UpdateBLESteamControllerState(pData, nDataSize, pState);
+        }
+        return false;
+    }
+
+    if ((pInReport->header.ucType != ID_CONTROLLER_STATE) &&
+        (pInReport->header.ucType != ID_CONTROLLER_BLE_STATE)) {
+        return false;
+    }
+
+    if (pInReport->header.ucType == ID_CONTROLLER_STATE) {
+        ValveControllerStatePacket_t *pStatePacket = &pInReport->payload.controllerState;
+
+        // No new data to process; indicate that we received a state packet, but otherwise do nothing.
+        if (pState->unPacketNum == pStatePacket->unPacketNum) {
+            return true;
+        }
+
+        FormatStatePacketUntilGyro(pState, pStatePacket);
+
+        pState->sAccelX = pStatePacket->sAccelX;
+        pState->sAccelY = pStatePacket->sAccelY;
+        pState->sAccelZ = pStatePacket->sAccelZ;
+
+        pState->sGyroQuatW = pStatePacket->sGyroQuatW;
+        pState->sGyroQuatX = pStatePacket->sGyroQuatX;
+        pState->sGyroQuatY = pStatePacket->sGyroQuatY;
+        pState->sGyroQuatZ = pStatePacket->sGyroQuatZ;
+
+        pState->sGyroX = pStatePacket->sGyroX;
+        pState->sGyroY = pStatePacket->sGyroY;
+        pState->sGyroZ = pStatePacket->sGyroZ;
+
+    } else if (pInReport->header.ucType == ID_CONTROLLER_BLE_STATE) {
+        ValveControllerBLEStatePacket_t *pBLEStatePacket = &pInReport->payload.controllerBLEState;
+        ValveControllerStatePacket_t *pStatePacket = &pInReport->payload.controllerState;
+
+        // No new data to process; indicate that we received a state packet, but otherwise do nothing.
+        if (pState->unPacketNum == pStatePacket->unPacketNum) {
+            return true;
+        }
+
+        FormatStatePacketUntilGyro(pState, pStatePacket);
+
+        switch (pBLEStatePacket->ucGyroDataType) {
+        case 1:
+            pState->sGyroQuatW = ((float)pBLEStatePacket->sGyro[0]);
+            pState->sGyroQuatX = ((float)pBLEStatePacket->sGyro[1]);
+            pState->sGyroQuatY = ((float)pBLEStatePacket->sGyro[2]);
+            pState->sGyroQuatZ = ((float)pBLEStatePacket->sGyro[3]);
+            break;
+
+        case 2:
+            pState->sAccelX = pBLEStatePacket->sGyro[0];
+            pState->sAccelY = pBLEStatePacket->sGyro[1];
+            pState->sAccelZ = pBLEStatePacket->sGyro[2];
+            break;
+
+        case 3:
+            pState->sGyroX = pBLEStatePacket->sGyro[0];
+            pState->sGyroY = pBLEStatePacket->sGyro[1];
+            pState->sGyroZ = pBLEStatePacket->sGyro[2];
+            break;
+
+        default:
+            break;
+        }
+    }
+
+    return true;
+}
+
+/*****************************************************************************************************/
+
+typedef struct
+{
+    SDL_HIDAPI_Device *device;
+    bool connected;
+    bool report_sensors;
+    uint32_t update_rate_in_us;
+    Uint64 sensor_timestamp;
+    Uint64 pairing_time;
+
+    SteamControllerPacketAssembler m_assembler;
+    SteamControllerStateInternal_t m_state;
+    SteamControllerStateInternal_t m_last_state;
+} SDL_DriverSteam_Context;
+
+static bool IsDongle(Uint16 product_id)
+{
+    return (product_id == USB_PRODUCT_VALVE_STEAM_CONTROLLER_DONGLE);
+}
+
+static void HIDAPI_DriverSteam_RegisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_STEAM, callback, userdata);
+}
+
+static void HIDAPI_DriverSteam_UnregisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_STEAM, callback, userdata);
+}
+
+static bool HIDAPI_DriverSteam_IsEnabled(void)
+{
+    return SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_STEAM, SDL_HINT_JOYSTICK_HIDAPI_STEAM_DEFAULT);
+}
+
+static bool HIDAPI_DriverSteam_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 (!SDL_IsJoystickSteamController(vendor_id, product_id)) {
+        return false;
+    }
+
+    if (device->is_bluetooth) {
+        return true;
+    }
+
+    if (IsDongle(product_id)) {
+        if (interface_number >= 1 && interface_number <= 4) {
+            // This is one of the wireless controller interfaces
+            return true;
+        }
+    } else {
+        if (interface_number == 2) {
+            // This is the controller interface (not mouse or keyboard)
+            return true;
+        }
+    }
+    return false;
+}
+
+static void HIDAPI_DriverSteam_SetPairingState(SDL_DriverSteam_Context *ctx, bool enabled)
+{
+    // Only have one dongle in pairing mode at a time
+    static SDL_DriverSteam_Context *s_PairingContext = NULL;
+
+    if (enabled && s_PairingContext != NULL) {
+        return;
+    }
+
+    if (!enabled && s_PairingContext != ctx) {
+        return;
+    }
+
+    if (ctx->connected) {
+        return;
+    }
+
+    SetPairingState(ctx->device, enabled);
+
+    if (enabled) {
+        ctx->pairing_time = SDL_GetTicks();
+        s_PairingContext = ctx;
+    } else {
+        ctx->pairing_time = 0;
+        s_PairingContext = NULL;
+    }
+}
+
+static void HIDAPI_DriverSteam_RenewPairingState(SDL_DriverSteam_Context *ctx)
+{
+    Uint64 now = SDL_GetTicks();
+
+    if (now >= ctx->pairing_time + PAIRING_STATE_DURATION_SECONDS * 1000) {
+        SetPairingState(ctx->device, true);
+        ctx->pairing_time = now;
+    }
+}
+
+static void HIDAPI_DriverSteam_CommitPairing(SDL_DriverSteam_Context *ctx)
+{
+    CommitPairing(ctx->device);
+}
+
+static void SDLCALL SDL_PairingEnabledHintChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
+{
+    SDL_DriverSteam_Context *ctx = (SDL_DriverSteam_Context *)userdata;
+    bool enabled = SDL_GetStringBoolean(hint, false);
+
+    HIDAPI_DriverSteam_SetPairingState(ctx, enabled);
+}
+
+static bool HIDAPI_DriverSteam_InitDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverSteam_Context *ctx;
+
+    ctx = (SDL_DriverSteam_Context *)SDL_calloc(1, sizeof(*ctx));
+    if (!ctx) {
+        return false;
+    }
+    ctx->device = device;
+    device->context = ctx;
+
+#ifdef SDL_PLATFORM_WIN32
+    if (device->serial) {
+        // We get a garbage serial number on Windows
+        SDL_free(device->serial);
+        device->serial = NULL;
+    }
+#endif // SDL_PLATFORM_WIN32
+
+    HIDAPI_SetDeviceName(device, "Steam Controller");
+
+    // If this is a wireless dongle, request a wireless state update
+    if (IsDongle(device->product_id)) {
+        unsigned char buf[65];
+        int res;
+
+        buf[0] = 0;
+        buf[1] = ID_DONGLE_GET_WIRELESS_STATE;
+        res = SetFeatureReport(device, buf, 2);
+        if (res < 0) {
+            return SDL_SetError("Failed to send ID_DONGLE_GET_WIRELESS_STATE request");
+        }
+
+        for (int attempt = 0; attempt < 5; ++attempt) {
+            uint8_t data[128];
+
+            res = ReadSteamController(device->dev, data, sizeof(data));
+            if (res == 0) {
+                SDL_Delay(1);
+                continue;
+            }
+            if (res < 0) {
+                break;
+            }
+
+#ifdef DEBUG_STEAM_PROTOCOL
+            HIDAPI_DumpPacket("Initial dongle packet: size = %d", data, res);
+#endif
+
+            if (D0G_IS_WIRELESS_CONNECT(data, res)) {
+                ctx->connected = true;
+                break;
+            } else if (D0G_IS_WIRELESS_DISCONNECT(data, res)) {
+                ctx->connected = false;
+                break;
+            }
+        }
+
+        SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_STEAM_PAIRING_ENABLED,
+                            SDL_PairingEnabledHintChanged, ctx);
+    } else {
+        // Wired and BLE controllers are always connected if HIDAPI can see them
+        ctx->connected = true;
+    }
+
+    if (ctx->connected) {
+        return HIDAPI_JoystickConnected(device, NULL);
+    } else {
+        // We will enumerate any attached controllers in UpdateDevice()
+        return true;
+    }
+}
+
+static int HIDAPI_DriverSteam_GetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id)
+{
+    return -1;
+}
+
+static void HIDAPI_DriverSteam_SetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id, int player_index)
+{
+}
+
+static bool SetHomeLED(SDL_HIDAPI_Device *device, Uint8 value)
+{
+    unsigned char buf[65];
+    int nSettings = 0;
+
+    SDL_memset(buf, 0, 65);
+    buf[1] = ID_SET_SETTINGS_VALUES;
+    ADD_SETTING(SETTING_LED_USER_BRIGHTNESS, value);
+    buf[2] = (unsigned char)(nSettings * 3);
+    if (SetFeatureReport(device, buf, 3 + nSettings * 3) < 0) {
+        return SDL_SetError("Couldn't write feature report");
+    }
+    return true;
+}
+
+static void SDLCALL SDL_HomeLEDHintChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
+{
+    SDL_DriverSteam_Context *ctx = (SDL_DriverSteam_Context *)userdata;
+
+    if (hint && *hint) {
+        int value;
+
+        if (SDL_strchr(hint, '.') != NULL) {
+            value = (int)(100.0f * SDL_atof(hint));
+            if (value > 255) {
+                value = 255;
+            }
+        } else if (SDL_GetStringBoolean(hint, true)) {
+            value = 100;
+        } else {
+            value = 0;
+        }
+        SetHomeLED(ctx->device, (Uint8)value);
+    }
+}
+
+static bool HIDAPI_DriverSteam_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverSteam_Context *ctx = (SDL_DriverSteam_Context *)device->context;
+    float update_rate_in_hz = 0.0f;
+
+    SDL_AssertJoysticksLocked();
+
+    ctx->report_sensors = false;
+    SDL_zero(ctx->m_assembler);
+    SDL_zero(ctx->m_state);
+    SDL_zero(ctx->m_last_state);
+
+    if (!ResetSteamController(device, false, &ctx->update_rate_in_us)) {
+        SDL_SetError("Couldn't reset controller");
+        return false;
+    }
+    if (ctx->update_rate_in_us > 0) {
+        update_rate_in_hz = 1000000.0f / ctx->update_rate_in_us;
+    }
+
+    InitializeSteamControllerPacketAssembler(&ctx->m_assembler, device->is_bluetooth);
+
+    // Initialize the joystick capabilities
+    joystick->nbuttons = SDL_GAMEPAD_NUM_STEAM_BUTTONS;
+    joystick->naxes = SDL_GAMEPAD_AXIS_COUNT;
+    joystick->nhats = 1;
+
+    if (IsDongle(device->product_id)) {
+        joystick->connection_state = SDL_JOYSTICK_CONNECTION_WIRELESS;
+    }
+
+    SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_GYRO, update_rate_in_hz);
+    SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_ACCEL, update_rate_in_hz);
+
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_STEAM_HOME_LED,
+                        SDL_HomeLEDHintChanged, ctx);
+
+    return true;
+}
+
+static bool HIDAPI_DriverSteam_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+    // You should use the full Steam Input API for rumble support
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverSteam_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
+{
+    return SDL_Unsupported();
+}
+
+static Uint32 HIDAPI_DriverSteam_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    // You should use the full Steam Input API for extended capabilities
+    return 0;
+}
+
+static bool HIDAPI_DriverSteam_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    // You should use the full Steam Input API for LED support
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverSteam_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *data, int size)
+{
+    if (size == 65) {
+        if (SetFeatureReport(device, data, size) < 0) {
+            return SDL_SetError("Couldn't write feature report");
+        }
+        return true;
+    }
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverSteam_SetSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, bool enabled)
+{
+    SDL_DriverSteam_Context *ctx = (SDL_DriverSteam_Context *)device->context;
+    unsigned char buf[65];
+    int nSettings = 0;
+
+    SDL_memset(buf, 0, 65);
+    buf[1] = ID_SET_SETTINGS_VALUES;
+    if (enabled) {
+        ADD_SETTING(SETTING_IMU_MODE, SETTING_GYRO_MODE_SEND_RAW_ACCEL | SETTING_GYRO_MODE_SEND_RAW_GYRO);
+    } else {
+        ADD_SETTING(SETTING_IMU_MODE, SETTING_GYRO_MODE_OFF);
+    }
+    buf[2] = (unsigned char)(nSettings * 3);
+    if (SetFeatureReport(device, buf, 3 + nSettings * 3) < 0) {
+        return SDL_SetError("Couldn't write feature report");
+    }
+
+    ctx->report_sensors = enabled;
+
+    return true;
+}
+
+static bool ControllerConnected(SDL_HIDAPI_Device *device, SDL_Joystick **joystick)
+{
+    SDL_DriverSteam_Context *ctx = (SDL_DriverSteam_Context *)device->context;
+
+    if (!HIDAPI_JoystickConnected(device, NULL)) {
+        return false;
+    }
+
+    // We'll automatically accept this controller if we're in pairing mode
+    HIDAPI_DriverSteam_CommitPairing(ctx);
+
+    *joystick = SDL_GetJoystickFromID(device->joysticks[0]);
+    ctx->connected = true;
+    return true;
+}
+
+static void ControllerDisconnected(SDL_HIDAPI_Device *device, SDL_Joystick **joystick)
+{
+    SDL_DriverSteam_Context *ctx = (SDL_DriverSteam_Context *)device->context;
+
+    if (device->joysticks) {
+        HIDAPI_JoystickDisconnected(device, device->joysticks[0]);
+    }
+    ctx->connected = false;
+    *joystick = NULL;
+}
+
+static bool HIDAPI_DriverSteam_UpdateDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverSteam_Context *ctx = (SDL_DriverSteam_Context *)device->context;
+    SDL_Joystick *joystick = NULL;
+
+    if (device->num_joysticks > 0) {
+        joystick = SDL_GetJoystickFromID(device->joysticks[0]);
+    }
+
+    if (ctx->pairing_time) {
+        HIDAPI_DriverSteam_RenewPairingState(ctx);
+    }
+
+    for (;;) {
+        uint8_t data[128];
+        int r, nPacketLength;
+        const Uint8 *pPacket;
+
+        r = ReadSteamController(device->dev, data, sizeof(data));
+        if (r == 0) {
+            break;
+        }
+        if (r < 0) {
+            // Failed to read from controller
+            ControllerDisconnected(device, &joystick);
+            return false;
+        }
+
+#ifdef DEBUG_STEAM_PROTOCOL
+        HIDAPI_DumpPacket("Steam Controller packet: size = %d", data, r);
+#endif
+
+        nPacketLength = WriteSegmentToSteamControllerPacketAssembler(&ctx->m_assembler, data, r);
+        pPacket = ctx->m_assembler.uBuffer;
+
+        if (nPacketLength > 0 && UpdateSteamControllerState(pPacket, nPacketLength, &ctx->m_state)) {
+            Uint64 timestamp = SDL_GetTicksNS();
+
+            if (!ctx->connected) {
+                // Maybe we missed a wireless status packet?
+                ControllerConnected(device, &joystick);
+            }
+
+            if (!joystick) {
+                continue;
+            }
+
+            if (ctx->m_state.ulButtons != ctx->m_last_state.ulButtons) {
+                Uint8 hat = 0;
+
+                SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SOUTH,
+                                          ((ctx->m_state.ulButtons & STEAM_BUTTON_SOUTH_MASK) != 0));
+
+                SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_EAST,
+                                          ((ctx->m_state.ulButtons & STEAM_BUTTON_EAST_MASK) != 0));
+
+                SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_WEST,
+                                          ((ctx->m_state.ulButtons & STEAM_BUTTON_WEST_MASK) != 0));
+
+                SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_NORTH,
+                                          ((ctx->m_state.ulButtons & STEAM_BUTTON_NORTH_MASK) != 0));
+
+                SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER,
+                                          ((ctx->m_state.ulButtons & STEAM_LEFT_BUMPER_MASK) != 0));
+
+                SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER,
+                                          ((ctx->m_state.ulButtons & STEAM_RIGHT_BUMPER_MASK) != 0));
+
+                SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK,
+                                          ((ctx->m_state.ulButtons & STEAM_BUTTON_MENU_MASK) != 0));
+
+                SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START,
+                                          ((ctx->m_state.ulButtons & STEAM_BUTTON_ESCAPE_MASK) != 0));
+
+                SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE,
+                                          ((ctx->m_state.ulButtons & STEAM_BUTTON_STEAM_MASK) != 0));
+
+                SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK,
+                                          ((ctx->m_state.ulButtons & STEAM_JOYSTICK_BUTTON_MASK) != 0));
+                SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_STEAM_LEFT_PADDLE,
+                                          ((ctx->m_state.ulButtons & STEAM_BUTTON_BACK_LEFT_MASK) != 0));
+                SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_STEAM_RIGHT_PADDLE,
+                                          ((ctx->m_state.ulButtons & STEAM_BUTTON_BACK_RIGHT_MASK) != 0));
+
+                SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_STICK,
+                                          ((ctx->m_state.ulButtons & STEAM_BUTTON_RIGHTPAD_CLICKED_MASK) != 0));
+
+                if (ctx->m_state.ulButtons & STEAM_DPAD_UP_MASK) {
+                    hat |= SDL_HAT_UP;
+                }
+                if (ctx->m_state.ulButtons & STEAM_DPAD_DOWN_MASK) {
+                    hat |= SDL_HAT_DOWN;
+                }
+                if (ctx->m_state.ulButtons & STEAM_DPAD_LEFT_MASK) {
+                    hat |= SDL_HAT_LEFT;
+                }
+                if (ctx->m_state.ulButtons & STEAM_DPAD_RIGHT_MASK) {
+                    hat |= SDL_HAT_RIGHT;
+                }
+                SDL_SendJoystickHat(timestamp, joystick, 0, hat);
+            }
+
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, (int)ctx->m_state.sTriggerL * 2 - 32768);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, (int)ctx->m_state.sTriggerR * 2 - 32768);
+
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, ctx->m_state.sLeftStickX);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, ~ctx->m_state.sLeftStickY);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, ctx->m_state.sRightPadX);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, ~ctx->m_state.sRightPadY);
+
+            if (ctx->report_sensors) {
+                float values[3];
+
+                ctx->sensor_timestamp += SDL_US_TO_NS(ctx->update_rate_in_us);
+
+                values[0] = (ctx->m_state.sGyroX / 32768.0f) * (2000.0f * (SDL_PI_F / 180.0f));
+                values[1] = (ctx->m_state.sGyroZ / 32768.0f) * (2000.0f * (SDL_PI_F / 180.0f));
+                values[2] = (ctx->m_state.sGyroY / 32768.0f) * (2000.0f * (SDL_PI_F / 180.0f));
+                SDL_SendJoystickSensor(timestamp, joystick, SDL_SENSOR_GYRO, ctx->sensor_timestamp, values, 3);
+
+                values[0] = (ctx->m_state.sAccelX / 32768.0f) * 2.0f * SDL_STANDARD_GRAVITY;
+                values[1] = (ctx->m_state.sAccelZ / 32768.0f) * 2.0f * SDL_STANDARD_GRAVITY;
+                values[2] = (-ctx->m_state.sAccelY / 32768.0f) * 2.0f * SDL_STANDARD_GRAVITY;
+                SDL_SendJoystickSensor(timestamp, joystick, SDL_SENSOR_ACCEL, ctx->sensor_timestamp, values, 3);
+            }
+
+            ctx->m_last_state = ctx->m_state;
+        } else if (!ctx->connected && D0G_IS_WIRELESS_CONNECT(pPacket, nPacketLength)) {
+            ControllerConnected(device, &joystick);
+        } else if (ctx->connected && D0G_IS_WIRELESS_DISCONNECT(pPacket, nPacketLength)) {
+            ControllerDisconnected(device, &joystick);
+        }
+    }
+    return true;
+}
+
+static void HIDAPI_DriverSteam_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverSteam_Context *ctx = (SDL_DriverSteam_Context *)device->context;
+
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_STEAM_HOME_LED,
+                           SDL_HomeLEDHintChanged, ctx);
+
+    CloseSteamController(device);
+}
+
+static void HIDAPI_DriverSteam_FreeDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverSteam_Context *ctx = (SDL_DriverSteam_Context *)device->context;
+
+    if (IsDongle(device->product_id)) {
+        SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_STEAM_PAIRING_ENABLED,
+                               SDL_PairingEnabledHintChanged, ctx);
+
+        HIDAPI_DriverSteam_SetPairingState(ctx, false);
+    }
+}
+
+SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverSteam = {
+    SDL_HINT_JOYSTICK_HIDAPI_STEAM,
+    true,
+    HIDAPI_DriverSteam_RegisterHints,
+    HIDAPI_DriverSteam_UnregisterHints,
+    HIDAPI_DriverSteam_IsEnabled,
+    HIDAPI_DriverSteam_IsSupportedDevice,
+    HIDAPI_DriverSteam_InitDevice,
+    HIDAPI_DriverSteam_GetDevicePlayerIndex,
+    HIDAPI_DriverSteam_SetDevicePlayerIndex,
+    HIDAPI_DriverSteam_UpdateDevice,
+    HIDAPI_DriverSteam_OpenJoystick,
+    HIDAPI_DriverSteam_RumbleJoystick,
+    HIDAPI_DriverSteam_RumbleJoystickTriggers,
+    HIDAPI_DriverSteam_GetJoystickCapabilities,
+    HIDAPI_DriverSteam_SetJoystickLED,
+    HIDAPI_DriverSteam_SendJoystickEffect,
+    HIDAPI_DriverSteam_SetSensorsEnabled,
+    HIDAPI_DriverSteam_CloseJoystick,
+    HIDAPI_DriverSteam_FreeDevice,
+};
+
+#endif // SDL_JOYSTICK_HIDAPI_STEAM
+
+#endif // SDL_JOYSTICK_HIDAPI
diff --git a/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_steam_hori.c b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_steam_hori.c
new file mode 100644
index 0000000..0cd192d
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_steam_hori.c
@@ -0,0 +1,415 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI
+
+#include "../SDL_sysjoystick.h"
+#include "SDL_hidapijoystick_c.h"
+#include "SDL_hidapi_rumble.h"
+#include "../SDL_joystick_c.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI_STEAM_HORI
+
+/* Define this if you want to log all packets from the controller */
+/*#define DEBUG_HORI_PROTOCOL*/
+
+#define LOAD16(A, B) (Sint16)((Uint16)(A) | (((Uint16)(B)) << 8))
+
+enum
+{
+    SDL_GAMEPAD_BUTTON_HORI_QAM = 11,
+    SDL_GAMEPAD_BUTTON_HORI_FR,
+    SDL_GAMEPAD_BUTTON_HORI_FL,
+    SDL_GAMEPAD_BUTTON_HORI_M1,
+    SDL_GAMEPAD_BUTTON_HORI_M2,
+    SDL_GAMEPAD_BUTTON_HORI_JOYSTICK_TOUCH_L,
+    SDL_GAMEPAD_BUTTON_HORI_JOYSTICK_TOUCH_R,
+    SDL_GAMEPAD_NUM_HORI_BUTTONS
+};
+
+typedef struct
+{
+    Uint8 last_state[USB_PACKET_LENGTH];
+    Uint64 sensor_ticks;
+    Uint32 last_tick;
+    bool wireless;
+    bool serial_needs_init;
+} SDL_DriverSteamHori_Context;
+
+static bool HIDAPI_DriverSteamHori_UpdateDevice(SDL_HIDAPI_Device *device);
+
+static void HIDAPI_DriverSteamHori_RegisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_STEAM_HORI, callback, userdata);
+}
+
+static void HIDAPI_DriverSteamHori_UnregisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_STEAM_HORI, callback, userdata);
+}
+
+static bool HIDAPI_DriverSteamHori_IsEnabled(void)
+{
+    return SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_STEAM_HORI, SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI, SDL_HIDAPI_DEFAULT));
+}
+
+static bool HIDAPI_DriverSteamHori_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)
+{
+    return SDL_IsJoystickHoriSteamController(vendor_id, product_id);
+}
+
+static bool HIDAPI_DriverSteamHori_InitDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverSteamHori_Context *ctx;
+
+    ctx = (SDL_DriverSteamHori_Context *)SDL_calloc(1, sizeof(*ctx));
+    if (!ctx) {
+        return false;
+    }
+
+    device->context = ctx;
+    ctx->serial_needs_init = true;
+
+    HIDAPI_SetDeviceName(device, "Wireless HORIPAD For Steam");
+
+    return HIDAPI_JoystickConnected(device, NULL);
+}
+
+static int HIDAPI_DriverSteamHori_GetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id)
+{
+    return -1;
+}
+
+static void HIDAPI_DriverSteamHori_SetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id, int player_index)
+{
+}
+
+static bool HIDAPI_DriverSteamHori_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverSteamHori_Context *ctx = (SDL_DriverSteamHori_Context *)device->context;
+
+    SDL_AssertJoysticksLocked();
+
+    SDL_zeroa(ctx->last_state);
+
+    /* Initialize the joystick capabilities */
+    joystick->nbuttons = SDL_GAMEPAD_NUM_HORI_BUTTONS;
+    joystick->naxes = SDL_GAMEPAD_AXIS_COUNT;
+        joystick->nhats = 1;
+
+        ctx->wireless = device->product_id == USB_PRODUCT_HORI_STEAM_CONTROLLER_BT;
+
+        if (ctx->wireless && device->serial) {
+                joystick->serial = SDL_strdup(device->serial);
+                ctx->serial_needs_init = false;
+        } else if (!ctx->wireless) {
+                // Need to actual read from the device to init the serial
+                HIDAPI_DriverSteamHori_UpdateDevice(device);
+        }
+       
+    SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_GYRO, 250.0f);
+    SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_ACCEL, 250.0f);
+
+    return true;
+}
+
+static bool HIDAPI_DriverSteamHori_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+    // Device doesn't support rumble
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverSteamHori_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
+{
+    return SDL_Unsupported();
+}
+
+static Uint32 HIDAPI_DriverSteamHori_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    return 0;
+}
+
+static bool HIDAPI_DriverSteamHori_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverSteamHori_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *data, int size)
+{
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverSteamHori_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, bool enabled)
+{
+    return true;
+}
+
+#undef clamp
+#define clamp(val, min, max) (((val) > (max)) ? (max) : (((val) < (min)) ? (min) : (val)))
+
+#ifndef DEG2RAD
+#define DEG2RAD(x) ((float)(x) * (float)(SDL_PI_F / 180.f))
+#endif
+
+//---------------------------------------------------------------------------
+// Scale and clamp values to a range
+//---------------------------------------------------------------------------
+static float RemapValClamped(float val, float A, float B, float C, float D)
+{
+    if (A == B) {
+        return (val - B) >= 0.0f ? D : C;
+    } else {
+        float cVal = (val - A) / (B - A);
+        cVal = clamp(cVal, 0.0f, 1.0f);
+
+        return C + (D - C) * cVal;
+    }
+}
+
+#define REPORT_HEADER_USB 0x07
+#define REPORT_HEADER_BT  0x00
+
+static void HIDAPI_DriverSteamHori_HandleStatePacket(SDL_Joystick *joystick, SDL_DriverSteamHori_Context *ctx, Uint8 *data, int size)
+{
+    Sint16 axis;
+    Uint64 timestamp = SDL_GetTicksNS();
+
+    // Make sure it's gamepad state and not OTA FW update info
+    if (data[0] != REPORT_HEADER_USB && data[0] != REPORT_HEADER_BT) {
+        /* We don't know how to handle this report */
+        return;
+    }
+
+    #define READ_STICK_AXIS(offset) \
+    (data[offset] == 0x80 ? 0 : (Sint16)HIDAPI_RemapVal((float)((int)data[offset] - 0x80), -0x80, 0xff - 0x80, SDL_MIN_SINT16, SDL_MAX_SINT16))
+    {
+        axis = READ_STICK_AXIS(1);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, axis);
+        axis = READ_STICK_AXIS(2);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, axis);
+        axis = READ_STICK_AXIS(3);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, axis);
+        axis = READ_STICK_AXIS(4);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, axis);
+    }
+#undef READ_STICK_AXIS
+
+    if (ctx->last_state[5] != data[5]) {
+        Uint8 hat;
+
+        switch (data[5] & 0xF) {
+        case 0:
+            hat = SDL_HAT_UP;
+            break;
+        case 1:
+            hat = SDL_HAT_RIGHTUP;
+            break;
+        case 2:
+            hat = SDL_HAT_RIGHT;
+            break;
+        case 3:
+            hat = SDL_HAT_RIGHTDOWN;
+            break;
+        case 4:
+            hat = SDL_HAT_DOWN;
+            break;
+        case 5:
+            hat = SDL_HAT_LEFTDOWN;
+            break;
+        case 6:
+            hat = SDL_HAT_LEFT;
+            break;
+        case 7:
+            hat = SDL_HAT_LEFTUP;
+            break;
+        default:
+            hat = SDL_HAT_CENTERED;
+            break;
+        }
+        SDL_SendJoystickHat(timestamp, joystick, 0, hat);
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SOUTH, ((data[5] & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_EAST, ((data[5] & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_HORI_QAM, ((data[5] & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_WEST, ((data[5] & 0x80) != 0));
+
+    }
+
+    if (ctx->last_state[6] != data[6]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_NORTH, ((data[6] & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_HORI_M1 /* M1 */, ((data[6] & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data[6] & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data[6] & 0x08) != 0));
+
+        // TODO: can we handle the digital trigger mode? The data seems to come through analog regardless of the trigger state
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK, ((data[6] & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data[6] & 0x80) != 0));
+    }
+
+    if (ctx->last_state[7] != data[7]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data[7] & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data[7] & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_STICK, ((data[7] & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_HORI_M2, ((data[7] & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_HORI_JOYSTICK_TOUCH_L, ((data[7] & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_HORI_JOYSTICK_TOUCH_R, ((data[7] & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_HORI_FR, ((data[7] & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_HORI_FL, ((data[7] & 0x80) != 0));
+    }
+
+        if (!ctx->wireless && ctx->serial_needs_init) {
+        char serial[18];
+                (void)SDL_snprintf(serial, sizeof(serial), "%.2x-%.2x-%.2x-%.2x-%.2x-%.2x",
+                                                                data[38], data[39], data[40], data[41], data[42], data[43]);
+
+                joystick->serial = SDL_strdup(serial);
+        ctx->serial_needs_init = false;
+    }
+
+#define READ_TRIGGER_AXIS(offset) \
+    (Sint16)(((int)data[offset] * 257) - 32768)
+    {
+        axis = READ_TRIGGER_AXIS(8);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, axis);
+        axis = READ_TRIGGER_AXIS(9);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, axis);
+    }
+#undef READ_TRIGGER_AXIS
+
+    if (1) {
+        Uint64 sensor_timestamp;
+        float imu_data[3];
+
+        /* 16-bit timestamp */
+        Uint32 delta;
+        Uint16 tick = LOAD16(data[10],
+                             data[11]);
+        if (ctx->last_tick < tick) {
+            delta = (tick - ctx->last_tick);
+        } else {
+            delta = (SDL_MAX_UINT16 - ctx->last_tick + tick + 1);
+        }
+
+        ctx->last_tick = tick;
+        ctx->sensor_ticks += delta;
+
+        /* Sensor timestamp is in 1us units, but there seems to be some issues with the values reported from the device */
+        sensor_timestamp = timestamp; // if the values were good we woudl call SDL_US_TO_NS(ctx->sensor_ticks);
+
+        const float accelScale = SDL_STANDARD_GRAVITY * 8 / 32768.0f;
+        const float gyroScale = DEG2RAD(2048);
+
+        imu_data[1] = RemapValClamped(-1.0f * LOAD16(data[12], data[13]), INT16_MIN, INT16_MAX, -gyroScale, gyroScale);
+        imu_data[2] = RemapValClamped(-1.0f * LOAD16(data[14], data[15]), INT16_MIN, INT16_MAX, -gyroScale, gyroScale);
+        imu_data[0] = RemapValClamped(-1.0f * LOAD16(data[16], data[17]), INT16_MIN, INT16_MAX, -gyroScale, gyroScale);
+                
+
+        SDL_SendJoystickSensor(timestamp, joystick, SDL_SENSOR_GYRO, sensor_timestamp, imu_data, 3);
+
+      //  SDL_Log("%u %f, %f, %f ", data[0], imu_data[0], imu_data[1], imu_data[2] );
+        imu_data[2] = LOAD16(data[18], data[19]) * accelScale;
+        imu_data[1] = -1 * LOAD16(data[20], data[21]) * accelScale;
+        imu_data[0] = LOAD16(data[22], data[23]) * accelScale;
+        SDL_SendJoystickSensor(timestamp, joystick, SDL_SENSOR_ACCEL, sensor_timestamp, imu_data, 3);
+    }
+
+    if (ctx->last_state[24] != data[24]) {
+        bool bCharging = (data[24] & 0x10) != 0;
+        int percent = (data[24] & 0xF) * 10;
+                SDL_PowerState state;
+         if (bCharging) {
+            state = SDL_POWERSTATE_CHARGING;
+        } else if (ctx->wireless) {
+             state = SDL_POWERSTATE_ON_BATTERY;
+        } else {
+            state = SDL_POWERSTATE_CHARGED;
+        }
+
+        SDL_SendJoystickPowerInfo(joystick, state, percent);
+    }
+
+    SDL_memcpy(ctx->last_state, data, SDL_min(size, sizeof(ctx->last_state)));
+}
+
+static bool HIDAPI_DriverSteamHori_UpdateDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverSteamHori_Context *ctx = (SDL_DriverSteamHori_Context *)device->context;
+    SDL_Joystick *joystick = NULL;
+    Uint8 data[USB_PACKET_LENGTH];
+    int size = 0;
+
+    if (device->num_joysticks > 0) {
+        joystick = SDL_GetJoystickFromID(device->joysticks[0]);
+    } else {
+        return false;
+    }
+
+    while ((size = SDL_hid_read_timeout(device->dev, data, sizeof(data), 0)) > 0) {
+#ifdef DEBUG_HORI_PROTOCOL
+        HIDAPI_DumpPacket("Google Hori packet: size = %d", data, size);
+#endif
+        if (!joystick) {
+            continue;
+        }
+
+        HIDAPI_DriverSteamHori_HandleStatePacket(joystick, ctx, data, size);
+    }
+
+    if (size < 0) {
+        /* Read error, device is disconnected */
+        HIDAPI_JoystickDisconnected(device, device->joysticks[0]);
+    }
+    return (size >= 0);
+}
+
+static void HIDAPI_DriverSteamHori_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+}
+
+static void HIDAPI_DriverSteamHori_FreeDevice(SDL_HIDAPI_Device *device)
+{
+}
+
+SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverSteamHori = {
+    SDL_HINT_JOYSTICK_HIDAPI_STEAM_HORI,
+    true,
+    HIDAPI_DriverSteamHori_RegisterHints,
+    HIDAPI_DriverSteamHori_UnregisterHints,
+    HIDAPI_DriverSteamHori_IsEnabled,
+    HIDAPI_DriverSteamHori_IsSupportedDevice,
+    HIDAPI_DriverSteamHori_InitDevice,
+    HIDAPI_DriverSteamHori_GetDevicePlayerIndex,
+    HIDAPI_DriverSteamHori_SetDevicePlayerIndex,
+    HIDAPI_DriverSteamHori_UpdateDevice,
+    HIDAPI_DriverSteamHori_OpenJoystick,
+    HIDAPI_DriverSteamHori_RumbleJoystick,
+    HIDAPI_DriverSteamHori_RumbleJoystickTriggers,
+    HIDAPI_DriverSteamHori_GetJoystickCapabilities,
+    HIDAPI_DriverSteamHori_SetJoystickLED,
+    HIDAPI_DriverSteamHori_SendJoystickEffect,
+    HIDAPI_DriverSteamHori_SetJoystickSensorsEnabled,
+    HIDAPI_DriverSteamHori_CloseJoystick,
+    HIDAPI_DriverSteamHori_FreeDevice,
+};
+
+#endif /* SDL_JOYSTICK_HIDAPI_STEAM_HORI */
+
+#endif /* SDL_JOYSTICK_HIDAPI */
diff --git a/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_steamdeck.c b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_steamdeck.c
new file mode 100644
index 0000000..75a13cc
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_steamdeck.c
@@ -0,0 +1,451 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 2023 Max Maisel <max.maisel@posteo.de>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI
+
+#include "../SDL_sysjoystick.h"
+#include "SDL_hidapijoystick_c.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI_STEAMDECK
+
+/*****************************************************************************************************/
+
+#include "steam/controller_constants.h"
+#include "steam/controller_structs.h"
+
+enum
+{
+    SDL_GAMEPAD_BUTTON_STEAM_DECK_QAM = 11,
+    SDL_GAMEPAD_BUTTON_STEAM_DECK_RIGHT_PADDLE1,
+    SDL_GAMEPAD_BUTTON_STEAM_DECK_LEFT_PADDLE1,
+    SDL_GAMEPAD_BUTTON_STEAM_DECK_RIGHT_PADDLE2,
+    SDL_GAMEPAD_BUTTON_STEAM_DECK_LEFT_PADDLE2,
+    SDL_GAMEPAD_NUM_STEAM_DECK_BUTTONS,
+};
+
+typedef enum
+{
+    STEAMDECK_LBUTTON_R2            = 0x00000001,
+    STEAMDECK_LBUTTON_L2            = 0x00000002,
+    STEAMDECK_LBUTTON_R             = 0x00000004,
+    STEAMDECK_LBUTTON_L             = 0x00000008,
+    STEAMDECK_LBUTTON_Y             = 0x00000010,
+    STEAMDECK_LBUTTON_B             = 0x00000020,
+    STEAMDECK_LBUTTON_X             = 0x00000040,
+    STEAMDECK_LBUTTON_A             = 0x00000080,
+    STEAMDECK_LBUTTON_DPAD_UP       = 0x00000100,
+    STEAMDECK_LBUTTON_DPAD_RIGHT    = 0x00000200,
+    STEAMDECK_LBUTTON_DPAD_LEFT     = 0x00000400,
+    STEAMDECK_LBUTTON_DPAD_DOWN     = 0x00000800,
+    STEAMDECK_LBUTTON_VIEW          = 0x00001000,
+    STEAMDECK_LBUTTON_STEAM         = 0x00002000,
+    STEAMDECK_LBUTTON_MENU          = 0x00004000,
+    STEAMDECK_LBUTTON_L5            = 0x00008000,
+    STEAMDECK_LBUTTON_R5            = 0x00010000,
+    STEAMDECK_LBUTTON_LEFT_PAD      = 0x00020000,
+    STEAMDECK_LBUTTON_RIGHT_PAD     = 0x00040000,
+    STEAMDECK_LBUTTON_L3            = 0x00400000,
+    STEAMDECK_LBUTTON_R3            = 0x04000000,
+
+    STEAMDECK_HBUTTON_L4            = 0x00000200,
+    STEAMDECK_HBUTTON_R4            = 0x00000400,
+    STEAMDECK_HBUTTON_QAM           = 0x00040000,
+} SteamDeckButtons;
+
+typedef struct
+{
+    Uint32 update_rate_us;
+    Uint32 sensor_timestamp_us;
+    Uint64 last_button_state;
+    Uint8 watchdog_counter;
+} SDL_DriverSteamDeck_Context;
+
+static bool DisableDeckLizardMode(SDL_hid_device *dev)
+{
+    int rc;
+    Uint8 buffer[HID_FEATURE_REPORT_BYTES + 1] = { 0 };
+    FeatureReportMsg *msg = (FeatureReportMsg *)(buffer + 1);
+
+    msg->header.type = ID_CLEAR_DIGITAL_MAPPINGS;
+
+    rc = SDL_hid_send_feature_report(dev, buffer, sizeof(buffer));
+    if (rc != sizeof(buffer))
+        return false;
+
+    msg->header.type = ID_SET_SETTINGS_VALUES;
+    msg->header.length = 5 * sizeof(ControllerSetting);
+    msg->payload.setSettingsValues.settings[0].settingNum = SETTING_SMOOTH_ABSOLUTE_MOUSE;
+    msg->payload.setSettingsValues.settings[0].settingValue = 0;
+    msg->payload.setSettingsValues.settings[1].settingNum = SETTING_LEFT_TRACKPAD_MODE;
+    msg->payload.setSettingsValues.settings[1].settingValue = TRACKPAD_NONE;
+    msg->payload.setSettingsValues.settings[2].settingNum = SETTING_RIGHT_TRACKPAD_MODE; // disable mouse
+    msg->payload.setSettingsValues.settings[2].settingValue = TRACKPAD_NONE;
+    msg->payload.setSettingsValues.settings[3].settingNum = SETTING_LEFT_TRACKPAD_CLICK_PRESSURE; // disable clicky pad
+    msg->payload.setSettingsValues.settings[3].settingValue = 0xFFFF;
+    msg->payload.setSettingsValues.settings[4].settingNum = SETTING_RIGHT_TRACKPAD_CLICK_PRESSURE; // disable clicky pad
+    msg->payload.setSettingsValues.settings[4].settingValue = 0xFFFF;
+
+    rc = SDL_hid_send_feature_report(dev, buffer, sizeof(buffer));
+    if (rc != sizeof(buffer))
+        return false;
+
+    // There may be a lingering report read back after changing settings.
+    // Discard it.
+    SDL_hid_get_feature_report(dev, buffer, sizeof(buffer));
+
+    return true;
+}
+
+static bool FeedDeckLizardWatchdog(SDL_hid_device *dev)
+{
+    int rc;
+    Uint8 buffer[HID_FEATURE_REPORT_BYTES + 1] = { 0 };
+    FeatureReportMsg *msg = (FeatureReportMsg *)(buffer + 1);
+
+    msg->header.type = ID_CLEAR_DIGITAL_MAPPINGS;
+
+    rc = SDL_hid_send_feature_report(dev, buffer, sizeof(buffer));
+    if (rc != sizeof(buffer))
+        return false;
+
+    msg->header.type = ID_SET_SETTINGS_VALUES;
+    msg->header.length = 1 * sizeof(ControllerSetting);
+    msg->payload.setSettingsValues.settings[0].settingNum = SETTING_RIGHT_TRACKPAD_MODE;
+    msg->payload.setSettingsValues.settings[0].settingValue = TRACKPAD_NONE;
+
+    rc = SDL_hid_send_feature_report(dev, buffer, sizeof(buffer));
+    if (rc != sizeof(buffer))
+        return false;
+
+    // There may be a lingering report read back after changing settings.
+    // Discard it.
+    SDL_hid_get_feature_report(dev, buffer, sizeof(buffer));
+
+    return true;
+}
+
+static void HIDAPI_DriverSteamDeck_HandleState(SDL_HIDAPI_Device *device,
+                                               SDL_Joystick *joystick,
+                                               ValveInReport_t *pInReport)
+{
+    float values[3];
+    SDL_DriverSteamDeck_Context *ctx = (SDL_DriverSteamDeck_Context *)device->context;
+    Uint64 timestamp = SDL_GetTicksNS();
+
+    if (pInReport->payload.deckState.ulButtons != ctx->last_button_state) {
+        Uint8 hat = 0;
+
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SOUTH,
+                               ((pInReport->payload.deckState.ulButtonsL & STEAMDECK_LBUTTON_A) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_EAST,
+                               ((pInReport->payload.deckState.ulButtonsL & STEAMDECK_LBUTTON_B) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_WEST,
+                               ((pInReport->payload.deckState.ulButtonsL & STEAMDECK_LBUTTON_X) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_NORTH,
+                               ((pInReport->payload.deckState.ulButtonsL & STEAMDECK_LBUTTON_Y) != 0));
+
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER,
+                               ((pInReport->payload.deckState.ulButtonsL & STEAMDECK_LBUTTON_L) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER,
+                               ((pInReport->payload.deckState.ulButtonsL & STEAMDECK_LBUTTON_R) != 0));
+
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK,
+                               ((pInReport->payload.deckState.ulButtonsL & STEAMDECK_LBUTTON_VIEW) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START,
+                               ((pInReport->payload.deckState.ulButtonsL & STEAMDECK_LBUTTON_MENU) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE,
+                               ((pInReport->payload.deckState.ulButtonsL & STEAMDECK_LBUTTON_STEAM) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_STEAM_DECK_QAM,
+                               ((pInReport->payload.deckState.ulButtonsH & STEAMDECK_HBUTTON_QAM) != 0));
+
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK,
+                               ((pInReport->payload.deckState.ulButtonsL & STEAMDECK_LBUTTON_L3) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_STICK,
+                               ((pInReport->payload.deckState.ulButtonsL & STEAMDECK_LBUTTON_R3) != 0));
+
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_STEAM_DECK_RIGHT_PADDLE1,
+                               ((pInReport->payload.deckState.ulButtonsH & STEAMDECK_HBUTTON_R4) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_STEAM_DECK_LEFT_PADDLE1,
+                               ((pInReport->payload.deckState.ulButtonsH & STEAMDECK_HBUTTON_L4) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_STEAM_DECK_RIGHT_PADDLE2,
+                               ((pInReport->payload.deckState.ulButtonsL & STEAMDECK_LBUTTON_R5) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_STEAM_DECK_LEFT_PADDLE2,
+                               ((pInReport->payload.deckState.ulButtonsL & STEAMDECK_LBUTTON_L5) != 0));
+
+        if (pInReport->payload.deckState.ulButtonsL & STEAMDECK_LBUTTON_DPAD_UP) {
+            hat |= SDL_HAT_UP;
+        }
+        if (pInReport->payload.deckState.ulButtonsL & STEAMDECK_LBUTTON_DPAD_DOWN) {
+            hat |= SDL_HAT_DOWN;
+        }
+        if (pInReport->payload.deckState.ulButtonsL & STEAMDECK_LBUTTON_DPAD_LEFT) {
+            hat |= SDL_HAT_LEFT;
+        }
+        if (pInReport->payload.deckState.ulButtonsL & STEAMDECK_LBUTTON_DPAD_RIGHT) {
+            hat |= SDL_HAT_RIGHT;
+        }
+        SDL_SendJoystickHat(timestamp, joystick, 0, hat);
+
+        ctx->last_button_state = pInReport->payload.deckState.ulButtons;
+    }
+
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER,
+                         (int)pInReport->payload.deckState.sTriggerRawL * 2 - 32768);
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER,
+                         (int)pInReport->payload.deckState.sTriggerRawR * 2 - 32768);
+
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX,
+                         pInReport->payload.deckState.sLeftStickX);
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY,
+                         -pInReport->payload.deckState.sLeftStickY);
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX,
+                         pInReport->payload.deckState.sRightStickX);
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY,
+                         -pInReport->payload.deckState.sRightStickY);
+
+    ctx->sensor_timestamp_us += ctx->update_rate_us;
+
+    values[0] = (pInReport->payload.deckState.sGyroX / 32768.0f) * (2000.0f * (SDL_PI_F / 180.0f));
+    values[1] = (pInReport->payload.deckState.sGyroZ / 32768.0f) * (2000.0f * (SDL_PI_F / 180.0f));
+    values[2] = (-pInReport->payload.deckState.sGyroY / 32768.0f) * (2000.0f * (SDL_PI_F / 180.0f));
+    SDL_SendJoystickSensor(timestamp, joystick, SDL_SENSOR_GYRO, ctx->sensor_timestamp_us, values, 3);
+
+    values[0] = (pInReport->payload.deckState.sAccelX / 32768.0f) * 2.0f * SDL_STANDARD_GRAVITY;
+    values[1] = (pInReport->payload.deckState.sAccelZ / 32768.0f) * 2.0f * SDL_STANDARD_GRAVITY;
+    values[2] = (-pInReport->payload.deckState.sAccelY / 32768.0f) * 2.0f * SDL_STANDARD_GRAVITY;
+    SDL_SendJoystickSensor(timestamp, joystick, SDL_SENSOR_ACCEL, ctx->sensor_timestamp_us, values, 3);
+}
+
+/*****************************************************************************************************/
+
+static void HIDAPI_DriverSteamDeck_RegisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_STEAMDECK, callback, userdata);
+}
+
+static void HIDAPI_DriverSteamDeck_UnregisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_STEAMDECK, callback, userdata);
+}
+
+static bool HIDAPI_DriverSteamDeck_IsEnabled(void)
+{
+    return SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_STEAMDECK,
+                              SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI, SDL_HIDAPI_DEFAULT));
+}
+
+static bool HIDAPI_DriverSteamDeck_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)
+{
+    return SDL_IsJoystickSteamDeck(vendor_id, product_id);
+}
+
+static bool HIDAPI_DriverSteamDeck_InitDevice(SDL_HIDAPI_Device *device)
+{
+    int size;
+    Uint8 data[64];
+    SDL_DriverSteamDeck_Context *ctx;
+
+    ctx = (SDL_DriverSteamDeck_Context *)SDL_calloc(1, sizeof(*ctx));
+    if (ctx == NULL) {
+        return false;
+    }
+
+    // Always 1kHz according to USB descriptor, but actually about 4 ms.
+    ctx->update_rate_us = 4000;
+
+    device->context = ctx;
+
+    // Read a report to see if this is the correct endpoint.
+    // Mouse, Keyboard and Controller have the same VID/PID but
+    // only the controller hidraw device receives hid reports.
+    size = SDL_hid_read_timeout(device->dev, data, sizeof(data), 16);
+    if (size == 0)
+        return false;
+
+    if (!DisableDeckLizardMode(device->dev))
+        return false;
+
+    HIDAPI_SetDeviceName(device, "Steam Deck");
+
+    return HIDAPI_JoystickConnected(device, NULL);
+}
+
+static int HIDAPI_DriverSteamDeck_GetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id)
+{
+    return -1;
+}
+
+static void HIDAPI_DriverSteamDeck_SetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id, int player_index)
+{
+}
+
+static bool HIDAPI_DriverSteamDeck_UpdateDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverSteamDeck_Context *ctx = (SDL_DriverSteamDeck_Context *)device->context;
+    SDL_Joystick *joystick = NULL;
+    int r;
+    uint8_t data[64];
+    ValveInReport_t *pInReport = (ValveInReport_t *)data;
+
+    if (device->num_joysticks > 0) {
+        joystick = SDL_GetJoystickFromID(device->joysticks[0]);
+        if (joystick == NULL) {
+            return false;
+        }
+    } else {
+        return false;
+    }
+
+    if (ctx->watchdog_counter++ > 200) {
+        ctx->watchdog_counter = 0;
+        if (!FeedDeckLizardWatchdog(device->dev))
+            return false;
+    }
+
+    SDL_memset(data, 0, sizeof(data));
+
+    do {
+        r = SDL_hid_read(device->dev, data, sizeof(data));
+
+        if (r < 0) {
+            // Failed to read from controller
+            HIDAPI_JoystickDisconnected(device, device->joysticks[0]);
+            return false;
+        } else if (r == 64 &&
+                   pInReport->header.unReportVersion == k_ValveInReportMsgVersion &&
+                   pInReport->header.ucType == ID_CONTROLLER_DECK_STATE &&
+                   pInReport->header.ucLength == 64) {
+            HIDAPI_DriverSteamDeck_HandleState(device, joystick, pInReport);
+        }
+    } while (r > 0);
+
+    return true;
+}
+
+static bool HIDAPI_DriverSteamDeck_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverSteamDeck_Context *ctx = (SDL_DriverSteamDeck_Context *)device->context;
+    float update_rate_in_hz = 1.0f / (float)(ctx->update_rate_us) * 1.0e6f;
+
+    SDL_AssertJoysticksLocked();
+
+    // Initialize the joystick capabilities
+    joystick->nbuttons = SDL_GAMEPAD_NUM_STEAM_DECK_BUTTONS;
+    joystick->naxes = SDL_GAMEPAD_AXIS_COUNT;
+    joystick->nhats = 1;
+
+    SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_GYRO, update_rate_in_hz);
+    SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_ACCEL, update_rate_in_hz);
+
+    return true;
+}
+
+static bool HIDAPI_DriverSteamDeck_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+    int rc;
+    Uint8 buffer[HID_FEATURE_REPORT_BYTES + 1] = { 0 };
+    FeatureReportMsg *msg = (FeatureReportMsg *)(buffer + 1);
+
+    msg->header.type = ID_TRIGGER_RUMBLE_CMD;
+    msg->payload.simpleRumble.unRumbleType = 0;
+    msg->payload.simpleRumble.unIntensity = HAPTIC_INTENSITY_SYSTEM;
+    msg->payload.simpleRumble.unLeftMotorSpeed = low_frequency_rumble;
+    msg->payload.simpleRumble.unRightMotorSpeed = high_frequency_rumble;
+    msg->payload.simpleRumble.nLeftGain = 2;
+    msg->payload.simpleRumble.nRightGain = 0;
+
+    rc = SDL_hid_send_feature_report(device->dev, buffer, sizeof(buffer));
+    if (rc != sizeof(buffer))
+        return false;
+    return true;
+}
+
+static bool HIDAPI_DriverSteamDeck_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
+{
+    return SDL_Unsupported();
+}
+
+static Uint32 HIDAPI_DriverSteamDeck_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    return SDL_JOYSTICK_CAP_RUMBLE;
+}
+
+static bool HIDAPI_DriverSteamDeck_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverSteamDeck_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *data, int size)
+{
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverSteamDeck_SetSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, bool enabled)
+{
+    // On steam deck, sensors are enabled by default. Nothing to do here.
+    return true;
+}
+
+static void HIDAPI_DriverSteamDeck_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    // Lizard mode id automatically re-enabled by watchdog. Nothing to do here.
+}
+
+static void HIDAPI_DriverSteamDeck_FreeDevice(SDL_HIDAPI_Device *device)
+{
+}
+
+SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverSteamDeck = {
+    SDL_HINT_JOYSTICK_HIDAPI_STEAMDECK,
+    true,
+    HIDAPI_DriverSteamDeck_RegisterHints,
+    HIDAPI_DriverSteamDeck_UnregisterHints,
+    HIDAPI_DriverSteamDeck_IsEnabled,
+    HIDAPI_DriverSteamDeck_IsSupportedDevice,
+    HIDAPI_DriverSteamDeck_InitDevice,
+    HIDAPI_DriverSteamDeck_GetDevicePlayerIndex,
+    HIDAPI_DriverSteamDeck_SetDevicePlayerIndex,
+    HIDAPI_DriverSteamDeck_UpdateDevice,
+    HIDAPI_DriverSteamDeck_OpenJoystick,
+    HIDAPI_DriverSteamDeck_RumbleJoystick,
+    HIDAPI_DriverSteamDeck_RumbleJoystickTriggers,
+    HIDAPI_DriverSteamDeck_GetJoystickCapabilities,
+    HIDAPI_DriverSteamDeck_SetJoystickLED,
+    HIDAPI_DriverSteamDeck_SendJoystickEffect,
+    HIDAPI_DriverSteamDeck_SetSensorsEnabled,
+    HIDAPI_DriverSteamDeck_CloseJoystick,
+    HIDAPI_DriverSteamDeck_FreeDevice,
+};
+
+#endif // SDL_JOYSTICK_HIDAPI_STEAMDECK
+
+#endif // SDL_JOYSTICK_HIDAPI
diff --git a/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_switch.c b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_switch.c
new file mode 100644
index 0000000..0e7b823
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_switch.c
@@ -0,0 +1,2859 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+/* This driver supports the Nintendo Switch Pro controller.
+   Code and logic contributed by Valve Corporation under the SDL zlib license.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI
+
+#include "../../SDL_hints_c.h"
+#include "../SDL_sysjoystick.h"
+#include "SDL_hidapijoystick_c.h"
+#include "SDL_hidapi_rumble.h"
+#include "SDL_hidapi_nintendo.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI_SWITCH
+
+// Define this if you want to log all packets from the controller
+// #define DEBUG_SWITCH_PROTOCOL
+
+// Define this to get log output for rumble logic
+// #define DEBUG_RUMBLE
+
+/* The initialization sequence doesn't appear to work correctly on Windows unless
+   the reads and writes are on the same thread.
+
+   ... and now I can't reproduce this, so I'm leaving it in, but disabled for now.
+ */
+// #define SWITCH_SYNCHRONOUS_WRITES
+
+/* How often you can write rumble commands to the controller.
+   If you send commands more frequently than this, you can turn off the controller
+   in Bluetooth mode, or the motors can miss the command in USB mode.
+ */
+#define RUMBLE_WRITE_FREQUENCY_MS 30
+
+// How often you have to refresh a long duration rumble to keep the motors running
+#define RUMBLE_REFRESH_FREQUENCY_MS 50
+
+#define SWITCH_GYRO_SCALE  14.2842f
+#define SWITCH_ACCEL_SCALE 4096.f
+
+#define SWITCH_GYRO_SCALE_OFFSET  13371.0f
+#define SWITCH_GYRO_SCALE_MULT    936.0f
+#define SWITCH_ACCEL_SCALE_OFFSET 16384.0f
+#define SWITCH_ACCEL_SCALE_MULT   4.0f
+
+enum
+{
+    SDL_GAMEPAD_BUTTON_SWITCH_SHARE = 11,
+    SDL_GAMEPAD_BUTTON_SWITCH_RIGHT_PADDLE1,
+    SDL_GAMEPAD_BUTTON_SWITCH_LEFT_PADDLE1,
+    SDL_GAMEPAD_BUTTON_SWITCH_RIGHT_PADDLE2,
+    SDL_GAMEPAD_BUTTON_SWITCH_LEFT_PADDLE2,
+    SDL_GAMEPAD_NUM_SWITCH_BUTTONS,
+};
+
+typedef enum
+{
+    k_eSwitchInputReportIDs_SubcommandReply = 0x21,
+    k_eSwitchInputReportIDs_FullControllerState = 0x30,
+    k_eSwitchInputReportIDs_FullControllerAndMcuState = 0x31,
+    k_eSwitchInputReportIDs_SimpleControllerState = 0x3F,
+    k_eSwitchInputReportIDs_CommandAck = 0x81,
+} ESwitchInputReportIDs;
+
+typedef enum
+{
+    k_eSwitchOutputReportIDs_RumbleAndSubcommand = 0x01,
+    k_eSwitchOutputReportIDs_Rumble = 0x10,
+    k_eSwitchOutputReportIDs_Proprietary = 0x80,
+} ESwitchOutputReportIDs;
+
+typedef enum
+{
+    k_eSwitchSubcommandIDs_BluetoothManualPair = 0x01,
+    k_eSwitchSubcommandIDs_RequestDeviceInfo = 0x02,
+    k_eSwitchSubcommandIDs_SetInputReportMode = 0x03,
+    k_eSwitchSubcommandIDs_SetHCIState = 0x06,
+    k_eSwitchSubcommandIDs_SPIFlashRead = 0x10,
+    k_eSwitchSubcommandIDs_SetPlayerLights = 0x30,
+    k_eSwitchSubcommandIDs_SetHomeLight = 0x38,
+    k_eSwitchSubcommandIDs_EnableIMU = 0x40,
+    k_eSwitchSubcommandIDs_SetIMUSensitivity = 0x41,
+    k_eSwitchSubcommandIDs_EnableVibration = 0x48,
+} ESwitchSubcommandIDs;
+
+typedef enum
+{
+    k_eSwitchProprietaryCommandIDs_Status = 0x01,
+    k_eSwitchProprietaryCommandIDs_Handshake = 0x02,
+    k_eSwitchProprietaryCommandIDs_HighSpeed = 0x03,
+    k_eSwitchProprietaryCommandIDs_ForceUSB = 0x04,
+    k_eSwitchProprietaryCommandIDs_ClearUSB = 0x05,
+    k_eSwitchProprietaryCommandIDs_ResetMCU = 0x06,
+} ESwitchProprietaryCommandIDs;
+
+#define k_unSwitchOutputPacketDataLength 49
+#define k_unSwitchMaxOutputPacketLength  64
+#define k_unSwitchBluetoothPacketLength  k_unSwitchOutputPacketDataLength
+#define k_unSwitchUSBPacketLength        k_unSwitchMaxOutputPacketLength
+
+#define k_unSPIStickFactoryCalibrationStartOffset 0x603D
+#define k_unSPIStickFactoryCalibrationEndOffset   0x604E
+#define k_unSPIStickFactoryCalibrationLength      (k_unSPIStickFactoryCalibrationEndOffset - k_unSPIStickFactoryCalibrationStartOffset + 1)
+
+#define k_unSPIStickUserCalibrationStartOffset 0x8010
+#define k_unSPIStickUserCalibrationEndOffset   0x8025
+#define k_unSPIStickUserCalibrationLength      (k_unSPIStickUserCalibrationEndOffset - k_unSPIStickUserCalibrationStartOffset + 1)
+
+#define k_unSPIIMUScaleStartOffset 0x6020
+#define k_unSPIIMUScaleEndOffset   0x6037
+#define k_unSPIIMUScaleLength      (k_unSPIIMUScaleEndOffset - k_unSPIIMUScaleStartOffset + 1)
+
+#define k_unSPIIMUUserScaleStartOffset 0x8026
+#define k_unSPIIMUUserScaleEndOffset   0x8039
+#define k_unSPIIMUUserScaleLength      (k_unSPIIMUUserScaleEndOffset - k_unSPIIMUUserScaleStartOffset + 1)
+
+#pragma pack(1)
+typedef struct
+{
+    Uint8 rgucButtons[2];
+    Uint8 ucStickHat;
+    Uint8 rgucJoystickLeft[2];
+    Uint8 rgucJoystickRight[2];
+} SwitchInputOnlyControllerStatePacket_t;
+
+typedef struct
+{
+    Uint8 rgucButtons[2];
+    Uint8 ucStickHat;
+    Sint16 sJoystickLeft[2];
+    Sint16 sJoystickRight[2];
+} SwitchSimpleStatePacket_t;
+
+typedef struct
+{
+    Uint8 ucCounter;
+    Uint8 ucBatteryAndConnection;
+    Uint8 rgucButtons[3];
+    Uint8 rgucJoystickLeft[3];
+    Uint8 rgucJoystickRight[3];
+    Uint8 ucVibrationCode;
+} SwitchControllerStatePacket_t;
+
+typedef struct
+{
+    SwitchControllerStatePacket_t controllerState;
+
+    struct
+    {
+        Sint16 sAccelX;
+        Sint16 sAccelY;
+        Sint16 sAccelZ;
+
+        Sint16 sGyroX;
+        Sint16 sGyroY;
+        Sint16 sGyroZ;
+    } imuState[3];
+} SwitchStatePacket_t;
+
+typedef struct
+{
+    Uint32 unAddress;
+    Uint8 ucLength;
+} SwitchSPIOpData_t;
+
+typedef struct
+{
+    SwitchControllerStatePacket_t m_controllerState;
+
+    Uint8 ucSubcommandAck;
+    Uint8 ucSubcommandID;
+
+#define k_unSubcommandDataBytes 35
+    union
+    {
+        Uint8 rgucSubcommandData[k_unSubcommandDataBytes];
+
+        struct
+        {
+            SwitchSPIOpData_t opData;
+            Uint8 rgucReadData[k_unSubcommandDataBytes - sizeof(SwitchSPIOpData_t)];
+        } spiReadData;
+
+        struct
+        {
+            Uint8 rgucFirmwareVersion[2];
+            Uint8 ucDeviceType;
+            Uint8 ucFiller1;
+            Uint8 rgucMACAddress[6];
+            Uint8 ucFiller2;
+            Uint8 ucColorLocation;
+        } deviceInfo;
+
+        struct
+        {
+            SwitchSPIOpData_t opData;
+            Uint8 rgucLeftCalibration[9];
+            Uint8 rgucRightCalibration[9];
+        } stickFactoryCalibration;
+
+        struct
+        {
+            SwitchSPIOpData_t opData;
+            Uint8 rgucLeftMagic[2];
+            Uint8 rgucLeftCalibration[9];
+            Uint8 rgucRightMagic[2];
+            Uint8 rgucRightCalibration[9];
+        } stickUserCalibration;
+    };
+} SwitchSubcommandInputPacket_t;
+
+typedef struct
+{
+    Uint8 ucPacketType;
+    Uint8 ucCommandID;
+    Uint8 ucFiller;
+
+    Uint8 ucDeviceType;
+    Uint8 rgucMACAddress[6];
+} SwitchProprietaryStatusPacket_t;
+
+typedef struct
+{
+    Uint8 rgucData[4];
+} SwitchRumbleData_t;
+
+typedef struct
+{
+    Uint8 ucPacketType;
+    Uint8 ucPacketNumber;
+    SwitchRumbleData_t rumbleData[2];
+} SwitchCommonOutputPacket_t;
+
+typedef struct
+{
+    SwitchCommonOutputPacket_t commonData;
+
+    Uint8 ucSubcommandID;
+    Uint8 rgucSubcommandData[k_unSwitchOutputPacketDataLength - sizeof(SwitchCommonOutputPacket_t) - 1];
+} SwitchSubcommandOutputPacket_t;
+
+typedef struct
+{
+    Uint8 ucPacketType;
+    Uint8 ucProprietaryID;
+
+    Uint8 rgucProprietaryData[k_unSwitchOutputPacketDataLength - 1 - 1];
+} SwitchProprietaryOutputPacket_t;
+#pragma pack()
+
+/* Enhanced report hint mode:
+ * "0": enhanced features are never used
+ * "1": enhanced features are always used
+ * "auto": enhanced features are advertised to the application, but SDL doesn't touch the controller state unless the application explicitly requests it.
+ */
+typedef enum
+{
+    SWITCH_ENHANCED_REPORT_HINT_OFF,
+    SWITCH_ENHANCED_REPORT_HINT_ON,
+    SWITCH_ENHANCED_REPORT_HINT_AUTO
+} HIDAPI_Switch_EnhancedReportHint;
+
+typedef struct
+{
+    SDL_HIDAPI_Device *device;
+    SDL_Joystick *joystick;
+    bool m_bInputOnly;
+    bool m_bUseButtonLabels;
+    bool m_bPlayerLights;
+    int m_nPlayerIndex;
+    bool m_bSyncWrite;
+    int m_nMaxWriteAttempts;
+    ESwitchDeviceInfoControllerType m_eControllerType;
+    Uint8 m_nInitialInputMode;
+    Uint8 m_nCurrentInputMode;
+    Uint8 m_rgucMACAddress[6];
+    Uint8 m_nCommandNumber;
+    HIDAPI_Switch_EnhancedReportHint m_eEnhancedReportHint;
+    bool m_bEnhancedMode;
+    bool m_bEnhancedModeAvailable;
+    SwitchCommonOutputPacket_t m_RumblePacket;
+    Uint8 m_rgucReadBuffer[k_unSwitchMaxOutputPacketLength];
+    bool m_bRumbleActive;
+    Uint64 m_ulRumbleSent;
+    bool m_bRumblePending;
+    bool m_bRumbleZeroPending;
+    Uint32 m_unRumblePending;
+    bool m_bSensorsSupported;
+    bool m_bReportSensors;
+    bool m_bHasSensorData;
+    Uint64 m_ulLastInput;
+    Uint64 m_ulLastIMUReset;
+    Uint64 m_ulIMUSampleTimestampNS;
+    Uint32 m_unIMUSamples;
+    Uint64 m_ulIMUUpdateIntervalNS;
+    Uint64 m_ulTimestampNS;
+    bool m_bVerticalMode;
+
+    SwitchInputOnlyControllerStatePacket_t m_lastInputOnlyState;
+    SwitchSimpleStatePacket_t m_lastSimpleState;
+    SwitchStatePacket_t m_lastFullState;
+
+    struct StickCalibrationData
+    {
+        struct
+        {
+            Sint16 sCenter;
+            Sint16 sMin;
+            Sint16 sMax;
+        } axis[2];
+    } m_StickCalData[2];
+
+    struct StickExtents
+    {
+        struct
+        {
+            Sint16 sMin;
+            Sint16 sMax;
+        } axis[2];
+    } m_StickExtents[2], m_SimpleStickExtents[2];
+
+    struct IMUScaleData
+    {
+        float fAccelScaleX;
+        float fAccelScaleY;
+        float fAccelScaleZ;
+
+        float fGyroScaleX;
+        float fGyroScaleY;
+        float fGyroScaleZ;
+    } m_IMUScaleData;
+} SDL_DriverSwitch_Context;
+
+static int ReadInput(SDL_DriverSwitch_Context *ctx)
+{
+    int result;
+
+    // Make sure we don't try to read at the same time a write is happening
+    if (SDL_GetAtomicInt(&ctx->device->rumble_pending) > 0) {
+        return 0;
+    }
+
+    result = SDL_hid_read_timeout(ctx->device->dev, ctx->m_rgucReadBuffer, sizeof(ctx->m_rgucReadBuffer), 0);
+
+    // See if we can guess the initial input mode
+    if (result > 0 && !ctx->m_bInputOnly && !ctx->m_nInitialInputMode) {
+        switch (ctx->m_rgucReadBuffer[0]) {
+        case k_eSwitchInputReportIDs_FullControllerState:
+        case k_eSwitchInputReportIDs_FullControllerAndMcuState:
+        case k_eSwitchInputReportIDs_SimpleControllerState:
+            ctx->m_nInitialInputMode = ctx->m_rgucReadBuffer[0];
+            break;
+        default:
+            break;
+        }
+    }
+    return result;
+}
+
+static int WriteOutput(SDL_DriverSwitch_Context *ctx, const Uint8 *data, int size)
+{
+#ifdef SWITCH_SYNCHRONOUS_WRITES
+    return SDL_hid_write(ctx->device->dev, data, size);
+#else
+    // Use the rumble thread for general asynchronous writes
+    if (!SDL_HIDAPI_LockRumble()) {
+        return -1;
+    }
+    return SDL_HIDAPI_SendRumbleAndUnlock(ctx->device, data, size);
+#endif // SWITCH_SYNCHRONOUS_WRITES
+}
+
+static SwitchSubcommandInputPacket_t *ReadSubcommandReply(SDL_DriverSwitch_Context *ctx, ESwitchSubcommandIDs expectedID)
+{
+    // Average response time for messages is ~30ms
+    Uint64 endTicks = SDL_GetTicks() + 100;
+
+    int nRead = 0;
+    while ((nRead = ReadInput(ctx)) != -1) {
+        if (nRead > 0) {
+            if (ctx->m_rgucReadBuffer[0] == k_eSwitchInputReportIDs_SubcommandReply) {
+                SwitchSubcommandInputPacket_t *reply = (SwitchSubcommandInputPacket_t *)&ctx->m_rgucReadBuffer[1];
+                if (reply->ucSubcommandID == expectedID && (reply->ucSubcommandAck & 0x80)) {
+                    return reply;
+                }
+            }
+        } else {
+            SDL_Delay(1);
+        }
+
+        if (SDL_GetTicks() >= endTicks) {
+            break;
+        }
+    }
+    return NULL;
+}
+
+static bool ReadProprietaryReply(SDL_DriverSwitch_Context *ctx, ESwitchProprietaryCommandIDs expectedID)
+{
+    // Average response time for messages is ~30ms
+    Uint64 endTicks = SDL_GetTicks() + 100;
+
+    int nRead = 0;
+    while ((nRead = ReadInput(ctx)) != -1) {
+        if (nRead > 0) {
+            if (ctx->m_rgucReadBuffer[0] == k_eSwitchInputReportIDs_CommandAck && ctx->m_rgucReadBuffer[1] == expectedID) {
+                return true;
+            }
+        } else {
+            SDL_Delay(1);
+        }
+
+        if (SDL_GetTicks() >= endTicks) {
+            break;
+        }
+    }
+    return false;
+}
+
+static void ConstructSubcommand(SDL_DriverSwitch_Context *ctx, ESwitchSubcommandIDs ucCommandID, const Uint8 *pBuf, Uint8 ucLen, SwitchSubcommandOutputPacket_t *outPacket)
+{
+    SDL_memset(outPacket, 0, sizeof(*outPacket));
+
+    outPacket->commonData.ucPacketType = k_eSwitchOutputReportIDs_RumbleAndSubcommand;
+    outPacket->commonData.ucPacketNumber = ctx->m_nCommandNumber;
+
+    SDL_memcpy(outPacket->commonData.rumbleData, ctx->m_RumblePacket.rumbleData, sizeof(ctx->m_RumblePacket.rumbleData));
+
+    outPacket->ucSubcommandID = ucCommandID;
+    if (pBuf) {
+        SDL_memcpy(outPacket->rgucSubcommandData, pBuf, ucLen);
+    }
+
+    ctx->m_nCommandNumber = (ctx->m_nCommandNumber + 1) & 0xF;
+}
+
+static bool WritePacket(SDL_DriverSwitch_Context *ctx, void *pBuf, Uint8 ucLen)
+{
+    Uint8 rgucBuf[k_unSwitchMaxOutputPacketLength];
+    const size_t unWriteSize = ctx->device->is_bluetooth ? k_unSwitchBluetoothPacketLength : k_unSwitchUSBPacketLength;
+
+    if (ucLen > k_unSwitchOutputPacketDataLength) {
+        return false;
+    }
+
+    if (ucLen < unWriteSize) {
+        SDL_memcpy(rgucBuf, pBuf, ucLen);
+        SDL_memset(rgucBuf + ucLen, 0, unWriteSize - ucLen);
+        pBuf = rgucBuf;
+        ucLen = (Uint8)unWriteSize;
+    }
+    if (ctx->m_bSyncWrite) {
+        return SDL_hid_write(ctx->device->dev, (Uint8 *)pBuf, ucLen) >= 0;
+    } else {
+        return WriteOutput(ctx, (Uint8 *)pBuf, ucLen) >= 0;
+    }
+}
+
+static bool WriteSubcommand(SDL_DriverSwitch_Context *ctx, ESwitchSubcommandIDs ucCommandID, const Uint8 *pBuf, Uint8 ucLen, SwitchSubcommandInputPacket_t **ppReply)
+{
+    SwitchSubcommandInputPacket_t *reply = NULL;
+    int nTries;
+
+    for (nTries = 1; !reply && nTries <= ctx->m_nMaxWriteAttempts; ++nTries) {
+        SwitchSubcommandOutputPacket_t commandPacket;
+        ConstructSubcommand(ctx, ucCommandID, pBuf, ucLen, &commandPacket);
+
+        if (!WritePacket(ctx, &commandPacket, sizeof(commandPacket))) {
+            continue;
+        }
+
+        reply = ReadSubcommandReply(ctx, ucCommandID);
+    }
+
+    if (ppReply) {
+        *ppReply = reply;
+    }
+    return reply != NULL;
+}
+
+static bool WriteProprietary(SDL_DriverSwitch_Context *ctx, ESwitchProprietaryCommandIDs ucCommand, Uint8 *pBuf, Uint8 ucLen, bool waitForReply)
+{
+    int nTries;
+
+    for (nTries = 1; nTries <= ctx->m_nMaxWriteAttempts; ++nTries) {
+        SwitchProprietaryOutputPacket_t packet;
+
+        if ((!pBuf && ucLen > 0) || ucLen > sizeof(packet.rgucProprietaryData)) {
+            return false;
+        }
+
+        SDL_zero(packet);
+        packet.ucPacketType = k_eSwitchOutputReportIDs_Proprietary;
+        packet.ucProprietaryID = ucCommand;
+        if (pBuf) {
+            SDL_memcpy(packet.rgucProprietaryData, pBuf, ucLen);
+        }
+
+        if (!WritePacket(ctx, &packet, sizeof(packet))) {
+            continue;
+        }
+
+        if (!waitForReply || ReadProprietaryReply(ctx, ucCommand)) {
+            // SDL_Log("Succeeded%s after %d tries", ctx->m_bSyncWrite ? " (sync)" : "", nTries);
+            return true;
+        }
+    }
+    // SDL_Log("Failed%s after %d tries", ctx->m_bSyncWrite ? " (sync)" : "", nTries);
+    return false;
+}
+
+static Uint8 EncodeRumbleHighAmplitude(Uint16 amplitude)
+{
+    /* More information about these values can be found here:
+     * https://github.com/dekuNukem/Nintendo_Switch_Reverse_Engineering/blob/master/rumble_data_table.md
+     */
+    Uint16 hfa[101][2] = { { 0, 0x0 }, { 514, 0x2 }, { 775, 0x4 }, { 921, 0x6 }, { 1096, 0x8 }, { 1303, 0x0a }, { 1550, 0x0c }, { 1843, 0x0e }, { 2192, 0x10 }, { 2606, 0x12 }, { 3100, 0x14 }, { 3686, 0x16 }, { 4383, 0x18 }, { 5213, 0x1a }, { 6199, 0x1c }, { 7372, 0x1e }, { 7698, 0x20 }, { 8039, 0x22 }, { 8395, 0x24 }, { 8767, 0x26 }, { 9155, 0x28 }, { 9560, 0x2a }, { 9984, 0x2c }, { 10426, 0x2e }, { 10887, 0x30 }, { 11369, 0x32 }, { 11873, 0x34 }, { 12398, 0x36 }, { 12947, 0x38 }, { 13520, 0x3a }, { 14119, 0x3c }, { 14744, 0x3e }, { 15067, 0x40 }, { 15397, 0x42 }, { 15734, 0x44 }, { 16079, 0x46 }, { 16431, 0x48 }, { 16790, 0x4a }, { 17158, 0x4c }, { 17534, 0x4e }, { 17918, 0x50 }, { 18310, 0x52 }, { 18711, 0x54 }, { 19121, 0x56 }, { 19540, 0x58 }, { 19967, 0x5a }, { 20405, 0x5c }, { 20851, 0x5e }, { 21308, 0x60 }, { 21775, 0x62 }, { 22251, 0x64 }, { 22739, 0x66 }, { 23236, 0x68 }, { 23745, 0x6a }, { 24265, 0x6c }, { 24797, 0x6e }, { 25340, 0x70 }, { 25894, 0x72 }, { 26462, 0x74 }, { 27041, 0x76 }, { 27633, 0x78 }, { 28238, 0x7a }, { 28856, 0x7c }, { 29488, 0x7e }, { 30134, 0x80 }, { 30794, 0x82 }, { 31468, 0x84 }, { 32157, 0x86 }, { 32861, 0x88 }, { 33581, 0x8a }, { 34316, 0x8c }, { 35068, 0x8e }, { 35836, 0x90 }, { 36620, 0x92 }, { 37422, 0x94 }, { 38242, 0x96 }, { 39079, 0x98 }, { 39935, 0x9a }, { 40809, 0x9c }, { 41703, 0x9e }, { 42616, 0xa0 }, { 43549, 0xa2 }, { 44503, 0xa4 }, { 45477, 0xa6 }, { 46473, 0xa8 }, { 47491, 0xaa }, { 48531, 0xac }, { 49593, 0xae }, { 50679, 0xb0 }, { 51789, 0xb2 }, { 52923, 0xb4 }, { 54082, 0xb6 }, { 55266, 0xb8 }, { 56476, 0xba }, { 57713, 0xbc }, { 58977, 0xbe }, { 60268, 0xc0 }, { 61588, 0xc2 }, { 62936, 0xc4 }, { 64315, 0xc6 }, { 65535, 0xc8 } };
+    int index = 0;
+    for (; index < 101; index++) {
+        if (amplitude <= hfa[index][0]) {
+            return (Uint8)hfa[index][1];
+        }
+    }
+    return (Uint8)hfa[100][1];
+}
+
+static Uint16 EncodeRumbleLowAmplitude(Uint16 amplitude)
+{
+    /* More information about these values can be found here:
+     * https://github.com/dekuNukem/Nintendo_Switch_Reverse_Engineering/blob/master/rumble_data_table.md
+     */
+    Uint16 lfa[101][2] = { { 0, 0x0040 }, { 514, 0x8040 }, { 775, 0x0041 }, { 921, 0x8041 }, { 1096, 0x0042 }, { 1303, 0x8042 }, { 1550, 0x0043 }, { 1843, 0x8043 }, { 2192, 0x0044 }, { 2606, 0x8044 }, { 3100, 0x0045 }, { 3686, 0x8045 }, { 4383, 0x0046 }, { 5213, 0x8046 }, { 6199, 0x0047 }, { 7372, 0x8047 }, { 7698, 0x0048 }, { 8039, 0x8048 }, { 8395, 0x0049 }, { 8767, 0x8049 }, { 9155, 0x004a }, { 9560, 0x804a }, { 9984, 0x004b }, { 10426, 0x804b }, { 10887, 0x004c }, { 11369, 0x804c }, { 11873, 0x004d }, { 12398, 0x804d }, { 12947, 0x004e }, { 13520, 0x804e }, { 14119, 0x004f }, { 14744, 0x804f }, { 15067, 0x0050 }, { 15397, 0x8050 }, { 15734, 0x0051 }, { 16079, 0x8051 }, { 16431, 0x0052 }, { 16790, 0x8052 }, { 17158, 0x0053 }, { 17534, 0x8053 }, { 17918, 0x0054 }, { 18310, 0x8054 }, { 18711, 0x0055 }, { 19121, 0x8055 }, { 19540, 0x0056 }, { 19967, 0x8056 }, { 20405, 0x0057 }, { 20851, 0x8057 }, { 21308, 0x0058 }, { 21775, 0x8058 }, { 22251, 0x0059 }, { 22739, 0x8059 }, { 23236, 0x005a }, { 23745, 0x805a }, { 24265, 0x005b }, { 24797, 0x805b }, { 25340, 0x005c }, { 25894, 0x805c }, { 26462, 0x005d }, { 27041, 0x805d }, { 27633, 0x005e }, { 28238, 0x805e }, { 28856, 0x005f }, { 29488, 0x805f }, { 30134, 0x0060 }, { 30794, 0x8060 }, { 31468, 0x0061 }, { 32157, 0x8061 }, { 32861, 0x0062 }, { 33581, 0x8062 }, { 34316, 0x0063 }, { 35068, 0x8063 }, { 35836, 0x0064 }, { 36620, 0x8064 }, { 37422, 0x0065 }, { 38242, 0x8065 }, { 39079, 0x0066 }, { 39935, 0x8066 }, { 40809, 0x0067 }, { 41703, 0x8067 }, { 42616, 0x0068 }, { 43549, 0x8068 }, { 44503, 0x0069 }, { 45477, 0x8069 }, { 46473, 0x006a }, { 47491, 0x806a }, { 48531, 0x006b }, { 49593, 0x806b }, { 50679, 0x006c }, { 51789, 0x806c }, { 52923, 0x006d }, { 54082, 0x806d }, { 55266, 0x006e }, { 56476, 0x806e }, { 57713, 0x006f }, { 58977, 0x806f }, { 60268, 0x0070 }, { 61588, 0x8070 }, { 62936, 0x0071 }, { 64315, 0x8071 }, { 65535, 0x0072 } };
+    int index = 0;
+    for (; index < 101; index++) {
+        if (amplitude <= lfa[index][0]) {
+            return lfa[index][1];
+        }
+    }
+    return lfa[100][1];
+}
+
+static void SetNeutralRumble(SwitchRumbleData_t *pRumble)
+{
+    pRumble->rgucData[0] = 0x00;
+    pRumble->rgucData[1] = 0x01;
+    pRumble->rgucData[2] = 0x40;
+    pRumble->rgucData[3] = 0x40;
+}
+
+static void EncodeRumble(SwitchRumbleData_t *pRumble, Uint16 usHighFreq, Uint8 ucHighFreqAmp, Uint8 ucLowFreq, Uint16 usLowFreqAmp)
+{
+    if (ucHighFreqAmp > 0 || usLowFreqAmp > 0) {
+        // High-band frequency and low-band amplitude are actually nine-bits each so they
+        // take a bit from the high-band amplitude and low-band frequency bytes respectively
+        pRumble->rgucData[0] = usHighFreq & 0xFF;
+        pRumble->rgucData[1] = ucHighFreqAmp | ((usHighFreq >> 8) & 0x01);
+
+        pRumble->rgucData[2] = ucLowFreq | ((usLowFreqAmp >> 8) & 0x80);
+        pRumble->rgucData[3] = usLowFreqAmp & 0xFF;
+
+#ifdef DEBUG_RUMBLE
+        SDL_Log("Freq: %.2X %.2X  %.2X, Amp: %.2X  %.2X %.2X",
+                usHighFreq & 0xFF, ((usHighFreq >> 8) & 0x01), ucLowFreq,
+                ucHighFreqAmp, ((usLowFreqAmp >> 8) & 0x80), usLowFreqAmp & 0xFF);
+#endif
+    } else {
+        SetNeutralRumble(pRumble);
+    }
+}
+
+static bool WriteRumble(SDL_DriverSwitch_Context *ctx)
+{
+    /* Write into m_RumblePacket rather than a temporary buffer to allow the current rumble state
+     * to be retained for subsequent rumble or subcommand packets sent to the controller
+     */
+    ctx->m_RumblePacket.ucPacketType = k_eSwitchOutputReportIDs_Rumble;
+    ctx->m_RumblePacket.ucPacketNumber = ctx->m_nCommandNumber;
+    ctx->m_nCommandNumber = (ctx->m_nCommandNumber + 1) & 0xF;
+
+    // Refresh the rumble state periodically
+    ctx->m_ulRumbleSent = SDL_GetTicks();
+
+    return WritePacket(ctx, (Uint8 *)&ctx->m_RumblePacket, sizeof(ctx->m_RumblePacket));
+}
+
+static ESwitchDeviceInfoControllerType CalculateControllerType(SDL_DriverSwitch_Context *ctx, ESwitchDeviceInfoControllerType eControllerType)
+{
+    SDL_HIDAPI_Device *device = ctx->device;
+
+    // The N64 controller reports as a Pro controller over USB
+    if (eControllerType == k_eSwitchDeviceInfoControllerType_ProController &&
+        device->product_id == USB_PRODUCT_NINTENDO_N64_CONTROLLER) {
+        eControllerType = k_eSwitchDeviceInfoControllerType_N64;
+    }
+
+    if (eControllerType == k_eSwitchDeviceInfoControllerType_Unknown) {
+        // This might be a Joy-Con that's missing from a charging grip slot
+        if (device->product_id == USB_PRODUCT_NINTENDO_SWITCH_JOYCON_GRIP) {
+            if (device->interface_number == 1) {
+                eControllerType = k_eSwitchDeviceInfoControllerType_JoyConLeft;
+            } else {
+                eControllerType = k_eSwitchDeviceInfoControllerType_JoyConRight;
+            }
+        }
+    }
+    return eControllerType;
+}
+
+static bool BReadDeviceInfo(SDL_DriverSwitch_Context *ctx)
+{
+    SwitchSubcommandInputPacket_t *reply = NULL;
+
+    if (ctx->device->is_bluetooth) {
+        if (WriteSubcommand(ctx, k_eSwitchSubcommandIDs_RequestDeviceInfo, NULL, 0, &reply)) {
+            // Byte 2: Controller ID (1=LJC, 2=RJC, 3=Pro)
+            ctx->m_eControllerType = CalculateControllerType(ctx, (ESwitchDeviceInfoControllerType)reply->deviceInfo.ucDeviceType);
+
+            // Bytes 4-9: MAC address (big-endian)
+            SDL_memcpy(ctx->m_rgucMACAddress, reply->deviceInfo.rgucMACAddress, sizeof(ctx->m_rgucMACAddress));
+
+            return true;
+        }
+    } else {
+        if (WriteProprietary(ctx, k_eSwitchProprietaryCommandIDs_Status, NULL, 0, true)) {
+            SwitchProprietaryStatusPacket_t *status = (SwitchProprietaryStatusPacket_t *)&ctx->m_rgucReadBuffer[0];
+            size_t i;
+
+            ctx->m_eControllerType = CalculateControllerType(ctx, (ESwitchDeviceInfoControllerType)status->ucDeviceType);
+
+            for (i = 0; i < sizeof(ctx->m_rgucMACAddress); ++i) {
+                ctx->m_rgucMACAddress[i] = status->rgucMACAddress[sizeof(ctx->m_rgucMACAddress) - i - 1];
+            }
+
+            return true;
+        }
+    }
+    return false;
+}
+
+static bool BTrySetupUSB(SDL_DriverSwitch_Context *ctx)
+{
+    /* We have to send a connection handshake to the controller when communicating over USB
+     * before we're able to send it other commands. Luckily this command is not supported
+     * over Bluetooth, so we can use the controller's lack of response as a way to
+     * determine if the connection is over USB or Bluetooth
+     */
+    if (!WriteProprietary(ctx, k_eSwitchProprietaryCommandIDs_Handshake, NULL, 0, true)) {
+        return false;
+    }
+    if (!WriteProprietary(ctx, k_eSwitchProprietaryCommandIDs_HighSpeed, NULL, 0, true)) {
+        // The 8BitDo M30 and SF30 Pro don't respond to this command, but otherwise work correctly
+        // return false;
+    }
+    if (!WriteProprietary(ctx, k_eSwitchProprietaryCommandIDs_Handshake, NULL, 0, true)) {
+        // This fails on the right Joy-Con when plugged into the charging grip
+        // return false;
+    }
+    if (!WriteProprietary(ctx, k_eSwitchProprietaryCommandIDs_ForceUSB, NULL, 0, false)) {
+        return false;
+    }
+    return true;
+}
+
+static bool SetVibrationEnabled(SDL_DriverSwitch_Context *ctx, Uint8 enabled)
+{
+    return WriteSubcommand(ctx, k_eSwitchSubcommandIDs_EnableVibration, &enabled, sizeof(enabled), NULL);
+}
+static bool SetInputMode(SDL_DriverSwitch_Context *ctx, Uint8 input_mode)
+{
+#ifdef FORCE_SIMPLE_REPORTS
+    input_mode = k_eSwitchInputReportIDs_SimpleControllerState;
+#endif
+#ifdef FORCE_FULL_REPORTS
+    input_mode = k_eSwitchInputReportIDs_FullControllerState;
+#endif
+
+    if (input_mode == ctx->m_nCurrentInputMode) {
+        return true;
+    } else {
+        ctx->m_nCurrentInputMode = input_mode;
+
+        return WriteSubcommand(ctx, k_eSwitchSubcommandIDs_SetInputReportMode, &input_mode, sizeof(input_mode), NULL);
+    }
+}
+
+static bool SetHomeLED(SDL_DriverSwitch_Context *ctx, Uint8 brightness)
+{
+    Uint8 ucLedIntensity = 0;
+    Uint8 rgucBuffer[4];
+
+    if (brightness > 0) {
+        if (brightness < 65) {
+            ucLedIntensity = (brightness + 5) / 10;
+        } else {
+            ucLedIntensity = (Uint8)SDL_ceilf(0xF * SDL_powf((float)brightness / 100.f, 2.13f));
+        }
+    }
+
+    rgucBuffer[0] = (0x0 << 4) | 0x1;                    // 0 mini cycles (besides first), cycle duration 8ms
+    rgucBuffer[1] = ((ucLedIntensity & 0xF) << 4) | 0x0; // LED start intensity (0x0-0xF), 0 cycles (LED stays on at start intensity after first cycle)
+    rgucBuffer[2] = ((ucLedIntensity & 0xF) << 4) | 0x0; // First cycle LED intensity, 0x0 intensity for second cycle
+    rgucBuffer[3] = (0x0 << 4) | 0x0;                    // 8ms fade transition to first cycle, 8ms first cycle LED duration
+
+    return WriteSubcommand(ctx, k_eSwitchSubcommandIDs_SetHomeLight, rgucBuffer, sizeof(rgucBuffer), NULL);
+}
+
+static void SDLCALL SDL_HomeLEDHintChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
+{
+    SDL_DriverSwitch_Context *ctx = (SDL_DriverSwitch_Context *)userdata;
+
+    if (hint && *hint) {
+        int value;
+
+        if (SDL_strchr(hint, '.') != NULL) {
+            value = (int)(100.0f * SDL_atof(hint));
+            if (value > 255) {
+                value = 255;
+            }
+        } else if (SDL_GetStringBoolean(hint, true)) {
+            value = 100;
+        } else {
+            value = 0;
+        }
+        SetHomeLED(ctx, (Uint8)value);
+    }
+}
+
+static void UpdateSlotLED(SDL_DriverSwitch_Context *ctx)
+{
+    if (!ctx->m_bInputOnly) {
+        Uint8 led_data = 0;
+
+        if (ctx->m_bPlayerLights && ctx->m_nPlayerIndex >= 0) {
+            led_data = (1 << (ctx->m_nPlayerIndex % 4));
+        }
+        WriteSubcommand(ctx, k_eSwitchSubcommandIDs_SetPlayerLights, &led_data, sizeof(led_data), NULL);
+    }
+}
+
+static void SDLCALL SDL_PlayerLEDHintChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
+{
+    SDL_DriverSwitch_Context *ctx = (SDL_DriverSwitch_Context *)userdata;
+    bool bPlayerLights = SDL_GetStringBoolean(hint, true);
+
+    if (bPlayerLights != ctx->m_bPlayerLights) {
+        ctx->m_bPlayerLights = bPlayerLights;
+
+        UpdateSlotLED(ctx);
+        HIDAPI_UpdateDeviceProperties(ctx->device);
+    }
+}
+
+static void GetInitialInputMode(SDL_DriverSwitch_Context *ctx)
+{
+    if (!ctx->m_nInitialInputMode) {
+        // This will set the initial input mode if it can
+        ReadInput(ctx);
+    }
+}
+
+static Uint8 GetDefaultInputMode(SDL_DriverSwitch_Context *ctx)
+{
+    Uint8 input_mode;
+
+    // Determine the desired input mode
+    if (ctx->m_nInitialInputMode) {
+        input_mode = ctx->m_nInitialInputMode;
+    } else {
+        if (ctx->device->is_bluetooth) {
+            input_mode = k_eSwitchInputReportIDs_SimpleControllerState;
+        } else {
+            input_mode = k_eSwitchInputReportIDs_FullControllerState;
+        }
+    }
+
+    switch (ctx->m_eEnhancedReportHint) {
+    case SWITCH_ENHANCED_REPORT_HINT_OFF:
+        input_mode = k_eSwitchInputReportIDs_SimpleControllerState;
+        break;
+    case SWITCH_ENHANCED_REPORT_HINT_ON:
+        if (input_mode == k_eSwitchInputReportIDs_SimpleControllerState) {
+            input_mode = k_eSwitchInputReportIDs_FullControllerState;
+        }
+        break;
+    case SWITCH_ENHANCED_REPORT_HINT_AUTO:
+        /* Joy-Con controllers switch their thumbsticks into D-pad mode in simple mode,
+         * so let's enable full controller state for them.
+         */
+        if (ctx->device->vendor_id == USB_VENDOR_NINTENDO &&
+            (ctx->device->product_id == USB_PRODUCT_NINTENDO_SWITCH_JOYCON_LEFT ||
+             ctx->device->product_id == USB_PRODUCT_NINTENDO_SWITCH_JOYCON_RIGHT)) {
+            input_mode = k_eSwitchInputReportIDs_FullControllerState;
+        }
+        break;
+    }
+
+    // Wired controllers break if they are put into simple controller state
+    if (input_mode == k_eSwitchInputReportIDs_SimpleControllerState &&
+        !ctx->device->is_bluetooth) {
+        input_mode = k_eSwitchInputReportIDs_FullControllerState;
+    }
+    return input_mode;
+}
+
+static Uint8 GetSensorInputMode(SDL_DriverSwitch_Context *ctx)
+{
+    Uint8 input_mode;
+
+    // Determine the desired input mode
+    if (!ctx->m_nInitialInputMode ||
+        ctx->m_nInitialInputMode == k_eSwitchInputReportIDs_SimpleControllerState) {
+        input_mode = k_eSwitchInputReportIDs_FullControllerState;
+    } else {
+        input_mode = ctx->m_nInitialInputMode;
+    }
+    return input_mode;
+}
+
+static void UpdateInputMode(SDL_DriverSwitch_Context *ctx)
+{
+    Uint8 input_mode;
+
+    if (ctx->m_bReportSensors) {
+        input_mode = GetSensorInputMode(ctx);
+    } else {
+        input_mode = GetDefaultInputMode(ctx);
+    }
+    SetInputMode(ctx, input_mode);
+}
+
+static void SetEnhancedModeAvailable(SDL_DriverSwitch_Context *ctx)
+{
+    if (ctx->m_bEnhancedModeAvailable) {
+        return;
+    }
+    ctx->m_bEnhancedModeAvailable = true;
+
+    if (ctx->m_bSensorsSupported) {
+        // Use the right sensor in the combined Joy-Con pair
+        if (!ctx->device->parent ||
+            ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_JoyConRight) {
+            SDL_PrivateJoystickAddSensor(ctx->joystick, SDL_SENSOR_GYRO, 200.0f);
+            SDL_PrivateJoystickAddSensor(ctx->joystick, SDL_SENSOR_ACCEL, 200.0f);
+        }
+        if (ctx->device->parent &&
+            ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_JoyConLeft) {
+            SDL_PrivateJoystickAddSensor(ctx->joystick, SDL_SENSOR_GYRO_L, 200.0f);
+            SDL_PrivateJoystickAddSensor(ctx->joystick, SDL_SENSOR_ACCEL_L, 200.0f);
+        }
+        if (ctx->device->parent &&
+            ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_JoyConRight) {
+            SDL_PrivateJoystickAddSensor(ctx->joystick, SDL_SENSOR_GYRO_R, 200.0f);
+            SDL_PrivateJoystickAddSensor(ctx->joystick, SDL_SENSOR_ACCEL_R, 200.0f);
+        }
+    }
+}
+
+static void SetEnhancedReportHint(SDL_DriverSwitch_Context *ctx, HIDAPI_Switch_EnhancedReportHint eEnhancedReportHint)
+{
+    ctx->m_eEnhancedReportHint = eEnhancedReportHint;
+
+    switch (eEnhancedReportHint) {
+    case SWITCH_ENHANCED_REPORT_HINT_OFF:
+        ctx->m_bEnhancedMode = false;
+        break;
+    case SWITCH_ENHANCED_REPORT_HINT_ON:
+        SetEnhancedModeAvailable(ctx);
+        ctx->m_bEnhancedMode = true;
+        break;
+    case SWITCH_ENHANCED_REPORT_HINT_AUTO:
+        SetEnhancedModeAvailable(ctx);
+        break;
+    }
+
+    UpdateInputMode(ctx);
+}
+
+static void UpdateEnhancedModeOnEnhancedReport(SDL_DriverSwitch_Context *ctx)
+{
+    if (ctx->m_eEnhancedReportHint == SWITCH_ENHANCED_REPORT_HINT_AUTO) {
+        SetEnhancedReportHint(ctx, SWITCH_ENHANCED_REPORT_HINT_ON);
+    }
+}
+
+static void UpdateEnhancedModeOnApplicationUsage(SDL_DriverSwitch_Context *ctx)
+{
+    if (ctx->m_eEnhancedReportHint == SWITCH_ENHANCED_REPORT_HINT_AUTO) {
+        SetEnhancedReportHint(ctx, SWITCH_ENHANCED_REPORT_HINT_ON);
+    }
+}
+
+static void SDLCALL SDL_EnhancedReportsChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
+{
+    SDL_DriverSwitch_Context *ctx = (SDL_DriverSwitch_Context *)userdata;
+
+    if (hint && SDL_strcasecmp(hint, "auto") == 0) {
+        SetEnhancedReportHint(ctx, SWITCH_ENHANCED_REPORT_HINT_AUTO);
+    } else if (SDL_GetStringBoolean(hint, true)) {
+        SetEnhancedReportHint(ctx, SWITCH_ENHANCED_REPORT_HINT_ON);
+    } else {
+        SetEnhancedReportHint(ctx, SWITCH_ENHANCED_REPORT_HINT_OFF);
+    }
+}
+
+static bool SetIMUEnabled(SDL_DriverSwitch_Context *ctx, bool enabled)
+{
+    Uint8 imu_data = enabled ? 1 : 0;
+    return WriteSubcommand(ctx, k_eSwitchSubcommandIDs_EnableIMU, &imu_data, sizeof(imu_data), NULL);
+}
+
+static bool LoadStickCalibration(SDL_DriverSwitch_Context *ctx)
+{
+    Uint8 *pLeftStickCal;
+    Uint8 *pRightStickCal;
+    size_t stick, axis;
+    SwitchSubcommandInputPacket_t *user_reply = NULL;
+    SwitchSubcommandInputPacket_t *factory_reply = NULL;
+    SwitchSPIOpData_t readUserParams;
+    SwitchSPIOpData_t readFactoryParams;
+
+    // Read User Calibration Info
+    readUserParams.unAddress = k_unSPIStickUserCalibrationStartOffset;
+    readUserParams.ucLength = k_unSPIStickUserCalibrationLength;
+
+    // This isn't readable on all controllers, so ignore failure
+    WriteSubcommand(ctx, k_eSwitchSubcommandIDs_SPIFlashRead, (uint8_t *)&readUserParams, sizeof(readUserParams), &user_reply);
+
+    // Read Factory Calibration Info
+    readFactoryParams.unAddress = k_unSPIStickFactoryCalibrationStartOffset;
+    readFactoryParams.ucLength = k_unSPIStickFactoryCalibrationLength;
+
+    const int MAX_ATTEMPTS = 3;
+    for (int attempt = 0; ; ++attempt) {
+        if (!WriteSubcommand(ctx, k_eSwitchSubcommandIDs_SPIFlashRead, (uint8_t *)&readFactoryParams, sizeof(readFactoryParams), &factory_reply)) {
+            return false;
+        }
+
+        if (factory_reply->stickFactoryCalibration.opData.unAddress == k_unSPIStickFactoryCalibrationStartOffset) {
+            // We successfully read the calibration data
+            break;
+        }
+
+        if (attempt == MAX_ATTEMPTS) {
+            return false;
+        }
+    }
+
+    // Automatically select the user calibration if magic bytes are set
+    if (user_reply && user_reply->stickUserCalibration.rgucLeftMagic[0] == 0xB2 && user_reply->stickUserCalibration.rgucLeftMagic[1] == 0xA1) {
+        pLeftStickCal = user_reply->stickUserCalibration.rgucLeftCalibration;
+    } else {
+        pLeftStickCal = factory_reply->stickFactoryCalibration.rgucLeftCalibration;
+    }
+
+    if (user_reply && user_reply->stickUserCalibration.rgucRightMagic[0] == 0xB2 && user_reply->stickUserCalibration.rgucRightMagic[1] == 0xA1) {
+        pRightStickCal = user_reply->stickUserCalibration.rgucRightCalibration;
+    } else {
+        pRightStickCal = factory_reply->stickFactoryCalibration.rgucRightCalibration;
+    }
+
+    /* Stick calibration values are 12-bits each and are packed by bit
+     * For whatever reason the fields are in a different order for each stick
+     * Left:  X-Max, Y-Max, X-Center, Y-Center, X-Min, Y-Min
+     * Right: X-Center, Y-Center, X-Min, Y-Min, X-Max, Y-Max
+     */
+
+    // Left stick
+    ctx->m_StickCalData[0].axis[0].sMax = ((pLeftStickCal[1] << 8) & 0xF00) | pLeftStickCal[0];    // X Axis max above center
+    ctx->m_StickCalData[0].axis[1].sMax = (pLeftStickCal[2] << 4) | (pLeftStickCal[1] >> 4);       // Y Axis max above center
+    ctx->m_StickCalData[0].axis[0].sCenter = ((pLeftStickCal[4] << 8) & 0xF00) | pLeftStickCal[3]; // X Axis center
+    ctx->m_StickCalData[0].axis[1].sCenter = (pLeftStickCal[5] << 4) | (pLeftStickCal[4] >> 4);    // Y Axis center
+    ctx->m_StickCalData[0].axis[0].sMin = ((pLeftStickCal[7] << 8) & 0xF00) | pLeftStickCal[6];    // X Axis min below center
+    ctx->m_StickCalData[0].axis[1].sMin = (pLeftStickCal[8] << 4) | (pLeftStickCal[7] >> 4);       // Y Axis min below center
+
+    // Right stick
+    ctx->m_StickCalData[1].axis[0].sCenter = ((pRightStickCal[1] << 8) & 0xF00) | pRightStickCal[0]; // X Axis center
+    ctx->m_StickCalData[1].axis[1].sCenter = (pRightStickCal[2] << 4) | (pRightStickCal[1] >> 4);    // Y Axis center
+    ctx->m_StickCalData[1].axis[0].sMin = ((pRightStickCal[4] << 8) & 0xF00) | pRightStickCal[3];    // X Axis min below center
+    ctx->m_StickCalData[1].axis[1].sMin = (pRightStickCal[5] << 4) | (pRightStickCal[4] >> 4);       // Y Axis min below center
+    ctx->m_StickCalData[1].axis[0].sMax = ((pRightStickCal[7] << 8) & 0xF00) | pRightStickCal[6];    // X Axis max above center
+    ctx->m_StickCalData[1].axis[1].sMax = (pRightStickCal[8] << 4) | (pRightStickCal[7] >> 4);       // Y Axis max above center
+
+    // Filter out any values that were uninitialized (0xFFF) in the SPI read
+    for (stick = 0; stick < 2; ++stick) {
+        for (axis = 0; axis < 2; ++axis) {
+            if (ctx->m_StickCalData[stick].axis[axis].sCenter == 0xFFF) {
+                ctx->m_StickCalData[stick].axis[axis].sCenter = 2048;
+            }
+            if (ctx->m_StickCalData[stick].axis[axis].sMax == 0xFFF) {
+                ctx->m_StickCalData[stick].axis[axis].sMax = (Sint16)(ctx->m_StickCalData[stick].axis[axis].sCenter * 0.7f);
+            }
+            if (ctx->m_StickCalData[stick].axis[axis].sMin == 0xFFF) {
+                ctx->m_StickCalData[stick].axis[axis].sMin = (Sint16)(ctx->m_StickCalData[stick].axis[axis].sCenter * 0.7f);
+            }
+        }
+    }
+
+    for (stick = 0; stick < 2; ++stick) {
+        for (axis = 0; axis < 2; ++axis) {
+            ctx->m_StickExtents[stick].axis[axis].sMin = -(Sint16)(ctx->m_StickCalData[stick].axis[axis].sMin * 0.7f);
+            ctx->m_StickExtents[stick].axis[axis].sMax = (Sint16)(ctx->m_StickCalData[stick].axis[axis].sMax * 0.7f);
+        }
+    }
+
+    for (stick = 0; stick < 2; ++stick) {
+        for (axis = 0; axis < 2; ++axis) {
+            ctx->m_SimpleStickExtents[stick].axis[axis].sMin = (Sint16)(SDL_MIN_SINT16 * 0.5f);
+            ctx->m_SimpleStickExtents[stick].axis[axis].sMax = (Sint16)(SDL_MAX_SINT16 * 0.5f);
+        }
+    }
+
+    return true;
+}
+
+static bool LoadIMUCalibration(SDL_DriverSwitch_Context *ctx)
+{
+    SwitchSubcommandInputPacket_t *reply = NULL;
+
+    // Read Calibration Info
+    SwitchSPIOpData_t readParams;
+    readParams.unAddress = k_unSPIIMUScaleStartOffset;
+    readParams.ucLength = k_unSPIIMUScaleLength;
+
+    if (WriteSubcommand(ctx, k_eSwitchSubcommandIDs_SPIFlashRead, (uint8_t *)&readParams, sizeof(readParams), &reply)) {
+        Uint8 *pIMUScale;
+        Sint16 sAccelRawX, sAccelRawY, sAccelRawZ, sGyroRawX, sGyroRawY, sGyroRawZ;
+
+        // IMU scale gives us multipliers for converting raw values to real world values
+        pIMUScale = reply->spiReadData.rgucReadData;
+
+        sAccelRawX = (pIMUScale[1] << 8) | pIMUScale[0];
+        sAccelRawY = (pIMUScale[3] << 8) | pIMUScale[2];
+        sAccelRawZ = (pIMUScale[5] << 8) | pIMUScale[4];
+
+        sGyroRawX = (pIMUScale[13] << 8) | pIMUScale[12];
+        sGyroRawY = (pIMUScale[15] << 8) | pIMUScale[14];
+        sGyroRawZ = (pIMUScale[17] << 8) | pIMUScale[16];
+
+        // Check for user calibration data. If it's present and set, it'll override the factory settings
+        readParams.unAddress = k_unSPIIMUUserScaleStartOffset;
+        readParams.ucLength = k_unSPIIMUUserScaleLength;
+        if (WriteSubcommand(ctx, k_eSwitchSubcommandIDs_SPIFlashRead, (uint8_t *)&readParams, sizeof(readParams), &reply) && (pIMUScale[0] | pIMUScale[1] << 8) == 0xA1B2) {
+            pIMUScale = reply->spiReadData.rgucReadData;
+
+            sAccelRawX = (pIMUScale[3] << 8) | pIMUScale[2];
+            sAccelRawY = (pIMUScale[5] << 8) | pIMUScale[4];
+            sAccelRawZ = (pIMUScale[7] << 8) | pIMUScale[6];
+
+            sGyroRawX = (pIMUScale[15] << 8) | pIMUScale[14];
+            sGyroRawY = (pIMUScale[17] << 8) | pIMUScale[16];
+            sGyroRawZ = (pIMUScale[19] << 8) | pIMUScale[18];
+        }
+
+        // Accelerometer scale
+        ctx->m_IMUScaleData.fAccelScaleX = SWITCH_ACCEL_SCALE_MULT / (SWITCH_ACCEL_SCALE_OFFSET - (float)sAccelRawX) * SDL_STANDARD_GRAVITY;
+        ctx->m_IMUScaleData.fAccelScaleY = SWITCH_ACCEL_SCALE_MULT / (SWITCH_ACCEL_SCALE_OFFSET - (float)sAccelRawY) * SDL_STANDARD_GRAVITY;
+        ctx->m_IMUScaleData.fAccelScaleZ = SWITCH_ACCEL_SCALE_MULT / (SWITCH_ACCEL_SCALE_OFFSET - (float)sAccelRawZ) * SDL_STANDARD_GRAVITY;
+
+        // Gyro scale
+        ctx->m_IMUScaleData.fGyroScaleX = SWITCH_GYRO_SCALE_MULT / (SWITCH_GYRO_SCALE_OFFSET - (float)sGyroRawX) * SDL_PI_F / 180.0f;
+        ctx->m_IMUScaleData.fGyroScaleY = SWITCH_GYRO_SCALE_MULT / (SWITCH_GYRO_SCALE_OFFSET - (float)sGyroRawY) * SDL_PI_F / 180.0f;
+        ctx->m_IMUScaleData.fGyroScaleZ = SWITCH_GYRO_SCALE_MULT / (SWITCH_GYRO_SCALE_OFFSET - (float)sGyroRawZ) * SDL_PI_F / 180.0f;
+
+    } else {
+        // Use default values
+        const float accelScale = SDL_STANDARD_GRAVITY / SWITCH_ACCEL_SCALE;
+        const float gyroScale = SDL_PI_F / 180.0f / SWITCH_GYRO_SCALE;
+
+        ctx->m_IMUScaleData.fAccelScaleX = accelScale;
+        ctx->m_IMUScaleData.fAccelScaleY = accelScale;
+        ctx->m_IMUScaleData.fAccelScaleZ = accelScale;
+
+        ctx->m_IMUScaleData.fGyroScaleX = gyroScale;
+        ctx->m_IMUScaleData.fGyroScaleY = gyroScale;
+        ctx->m_IMUScaleData.fGyroScaleZ = gyroScale;
+    }
+    return true;
+}
+
+static Sint16 ApplyStickCalibration(SDL_DriverSwitch_Context *ctx, int nStick, int nAxis, Sint16 sRawValue)
+{
+    sRawValue -= ctx->m_StickCalData[nStick].axis[nAxis].sCenter;
+
+    if (sRawValue > ctx->m_StickExtents[nStick].axis[nAxis].sMax) {
+        ctx->m_StickExtents[nStick].axis[nAxis].sMax = sRawValue;
+    }
+    if (sRawValue < ctx->m_StickExtents[nStick].axis[nAxis].sMin) {
+        ctx->m_StickExtents[nStick].axis[nAxis].sMin = sRawValue;
+    }
+
+    return (Sint16)HIDAPI_RemapVal(sRawValue, ctx->m_StickExtents[nStick].axis[nAxis].sMin, ctx->m_StickExtents[nStick].axis[nAxis].sMax, SDL_MIN_SINT16, SDL_MAX_SINT16);
+}
+
+static Sint16 ApplySimpleStickCalibration(SDL_DriverSwitch_Context *ctx, int nStick, int nAxis, Sint16 sRawValue)
+{
+    // 0x8000 is the neutral value for all joystick axes
+    const Uint16 usJoystickCenter = 0x8000;
+
+    sRawValue -= usJoystickCenter;
+
+    if (sRawValue > ctx->m_SimpleStickExtents[nStick].axis[nAxis].sMax) {
+        ctx->m_SimpleStickExtents[nStick].axis[nAxis].sMax = sRawValue;
+    }
+    if (sRawValue < ctx->m_SimpleStickExtents[nStick].axis[nAxis].sMin) {
+        ctx->m_SimpleStickExtents[nStick].axis[nAxis].sMin = sRawValue;
+    }
+
+    return (Sint16)HIDAPI_RemapVal(sRawValue, ctx->m_SimpleStickExtents[nStick].axis[nAxis].sMin, ctx->m_SimpleStickExtents[nStick].axis[nAxis].sMax, SDL_MIN_SINT16, SDL_MAX_SINT16);
+}
+
+static Uint8 RemapButton(SDL_DriverSwitch_Context *ctx, Uint8 button)
+{
+    if (ctx->m_bUseButtonLabels) {
+        // Use button labels instead of positions, e.g. Nintendo Online Classic controllers
+        switch (button) {
+        case SDL_GAMEPAD_BUTTON_SOUTH:
+            return SDL_GAMEPAD_BUTTON_EAST;
+        case SDL_GAMEPAD_BUTTON_EAST:
+            return SDL_GAMEPAD_BUTTON_SOUTH;
+        case SDL_GAMEPAD_BUTTON_WEST:
+            return SDL_GAMEPAD_BUTTON_NORTH;
+        case SDL_GAMEPAD_BUTTON_NORTH:
+            return SDL_GAMEPAD_BUTTON_WEST;
+        default:
+            break;
+        }
+    }
+    return button;
+}
+
+static int GetMaxWriteAttempts(SDL_HIDAPI_Device *device)
+{
+    if (device->vendor_id == USB_VENDOR_NINTENDO &&
+        device->product_id == USB_PRODUCT_NINTENDO_SWITCH_JOYCON_GRIP) {
+        // This device is a little slow and we know we're always on USB
+        return 20;
+    } else {
+        return 5;
+    }
+}
+
+static ESwitchDeviceInfoControllerType ReadJoyConControllerType(SDL_HIDAPI_Device *device)
+{
+    ESwitchDeviceInfoControllerType eControllerType = k_eSwitchDeviceInfoControllerType_Unknown;
+    const int MAX_ATTEMPTS = 1; // Don't try too long, in case this is a zombie Bluetooth controller
+    int attempts = 0;
+
+    // Create enough of a context to read the controller type from the device
+    SDL_DriverSwitch_Context *ctx = (SDL_DriverSwitch_Context *)SDL_calloc(1, sizeof(*ctx));
+    if (ctx) {
+        ctx->device = device;
+        ctx->m_bSyncWrite = true;
+        ctx->m_nMaxWriteAttempts = GetMaxWriteAttempts(device);
+
+        for ( ; ; ) {
+            ++attempts;
+            if (device->is_bluetooth) {
+                SwitchSubcommandInputPacket_t *reply = NULL;
+
+                if (WriteSubcommand(ctx, k_eSwitchSubcommandIDs_RequestDeviceInfo, NULL, 0, &reply)) {
+                    eControllerType = CalculateControllerType(ctx, (ESwitchDeviceInfoControllerType)reply->deviceInfo.ucDeviceType);
+                }
+            } else {
+                if (WriteProprietary(ctx, k_eSwitchProprietaryCommandIDs_Status, NULL, 0, true)) {
+                    SwitchProprietaryStatusPacket_t *status = (SwitchProprietaryStatusPacket_t *)&ctx->m_rgucReadBuffer[0];
+
+                    eControllerType = CalculateControllerType(ctx, (ESwitchDeviceInfoControllerType)status->ucDeviceType);
+                }
+            }
+            if (eControllerType == k_eSwitchDeviceInfoControllerType_Unknown && attempts < MAX_ATTEMPTS) {
+                // Wait a bit and try again
+                SDL_Delay(100);
+                continue;
+            }
+            break;
+        }
+        SDL_free(ctx);
+    }
+    return eControllerType;
+}
+
+static bool HasHomeLED(SDL_DriverSwitch_Context *ctx)
+{
+    Uint16 vendor_id = ctx->device->vendor_id;
+    Uint16 product_id = ctx->device->product_id;
+
+    // The Power A Nintendo Switch Pro controllers don't have a Home LED
+    if (vendor_id == 0 && product_id == 0) {
+        return false;
+    }
+
+    // HORI Wireless Switch Pad
+    if (vendor_id == 0x0f0d && product_id == 0x00f6) {
+        return false;
+    }
+
+    // Third party controllers don't have a home LED and will shut off if we try to set it
+    if (ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_Unknown ||
+        ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_LicProController) {
+        return false;
+    }
+
+    // The Nintendo Online classic controllers don't have a Home LED
+    if (vendor_id == USB_VENDOR_NINTENDO &&
+        ctx->m_eControllerType > k_eSwitchDeviceInfoControllerType_ProController) {
+        return false;
+    }
+
+    return true;
+}
+
+static bool AlwaysUsesLabels(Uint16 vendor_id, Uint16 product_id, ESwitchDeviceInfoControllerType eControllerType)
+{
+    // Some controllers don't have a diamond button configuration, so should always use labels
+    if (SDL_IsJoystickGameCube(vendor_id, product_id)) {
+        return true;
+    }
+    switch (eControllerType) {
+    case k_eSwitchDeviceInfoControllerType_HVCLeft:
+    case k_eSwitchDeviceInfoControllerType_HVCRight:
+    case k_eSwitchDeviceInfoControllerType_NESLeft:
+    case k_eSwitchDeviceInfoControllerType_NESRight:
+    case k_eSwitchDeviceInfoControllerType_N64:
+    case k_eSwitchDeviceInfoControllerType_SEGA_Genesis:
+        return true;
+    default:
+        return false;
+    }
+}
+
+static void HIDAPI_DriverNintendoClassic_RegisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_NINTENDO_CLASSIC, callback, userdata);
+}
+
+static void HIDAPI_DriverNintendoClassic_UnregisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_NINTENDO_CLASSIC, callback, userdata);
+}
+
+static bool HIDAPI_DriverNintendoClassic_IsEnabled(void)
+{
+    return SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_NINTENDO_CLASSIC, SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI, SDL_HIDAPI_DEFAULT));
+}
+
+static bool HIDAPI_DriverNintendoClassic_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) {
+        if (product_id == USB_PRODUCT_NINTENDO_SWITCH_JOYCON_RIGHT) {
+            if (SDL_strncmp(name, "NES Controller", 14) == 0 ||
+                SDL_strncmp(name, "HVC Controller", 14) == 0) {
+                return true;
+            }
+        }
+
+        if (product_id == USB_PRODUCT_NINTENDO_N64_CONTROLLER) {
+            return true;
+        }
+
+        if (product_id == USB_PRODUCT_NINTENDO_SEGA_GENESIS_CONTROLLER) {
+            return true;
+        }
+
+        if (product_id == USB_PRODUCT_NINTENDO_SNES_CONTROLLER) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+static void HIDAPI_DriverJoyCons_RegisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_JOY_CONS, callback, userdata);
+}
+
+static void HIDAPI_DriverJoyCons_UnregisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_JOY_CONS, callback, userdata);
+}
+
+static bool HIDAPI_DriverJoyCons_IsEnabled(void)
+{
+    return SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_JOY_CONS, SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI, SDL_HIDAPI_DEFAULT));
+}
+
+static bool HIDAPI_DriverJoyCons_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) {
+        if (product_id == USB_PRODUCT_NINTENDO_SWITCH_PRO && device && device->dev) {
+            // This might be a Kinvoca Joy-Con that reports VID/PID as a Switch Pro controller
+            ESwitchDeviceInfoControllerType eControllerType = ReadJoyConControllerType(device);
+            if (eControllerType == k_eSwitchDeviceInfoControllerType_JoyConLeft ||
+                eControllerType == k_eSwitchDeviceInfoControllerType_JoyConRight) {
+                return true;
+            }
+        }
+
+        if (product_id == USB_PRODUCT_NINTENDO_SWITCH_JOYCON_LEFT ||
+            product_id == USB_PRODUCT_NINTENDO_SWITCH_JOYCON_RIGHT ||
+            product_id == USB_PRODUCT_NINTENDO_SWITCH_JOYCON_GRIP) {
+            return true;
+        }
+    }
+    return false;
+}
+
+static void HIDAPI_DriverSwitch_RegisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_SWITCH, callback, userdata);
+}
+
+static void HIDAPI_DriverSwitch_UnregisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_SWITCH, callback, userdata);
+}
+
+static bool HIDAPI_DriverSwitch_IsEnabled(void)
+{
+    return SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_SWITCH, SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI, SDL_HIDAPI_DEFAULT));
+}
+
+static bool HIDAPI_DriverSwitch_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)
+{
+    /* The HORI Wireless Switch Pad enumerates as a HID device when connected via USB
+       with the same VID/PID as when connected over Bluetooth but doesn't actually
+       support communication over USB. The most reliable way to block this without allowing the
+       controller to continually attempt to reconnect is to filter it out by manufacturer/product string.
+       Note that the controller does have a different product string when connected over Bluetooth.
+     */
+    if (SDL_strcmp(name, "HORI Wireless Switch Pad") == 0) {
+        return false;
+    }
+
+    // If it's handled by another driver, it's not handled here
+    if (HIDAPI_DriverNintendoClassic_IsSupportedDevice(device, name, type, vendor_id, product_id, version, interface_number, interface_class, interface_subclass, interface_protocol) ||
+        HIDAPI_DriverJoyCons_IsSupportedDevice(device, name, type, vendor_id, product_id, version, interface_number, interface_class, interface_subclass, interface_protocol)) {
+        return false;
+    }
+
+    return (type == SDL_GAMEPAD_TYPE_NINTENDO_SWITCH_PRO);
+}
+
+static void UpdateDeviceIdentity(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverSwitch_Context *ctx = (SDL_DriverSwitch_Context *)device->context;
+
+    if (ctx->m_bInputOnly) {
+        if (SDL_IsJoystickGameCube(device->vendor_id, device->product_id)) {
+            device->type = SDL_GAMEPAD_TYPE_STANDARD;
+        }
+    } else {
+        char serial[18];
+
+        switch (ctx->m_eControllerType) {
+        case k_eSwitchDeviceInfoControllerType_JoyConLeft:
+            HIDAPI_SetDeviceName(device, "Nintendo Switch Joy-Con (L)");
+            HIDAPI_SetDeviceProduct(device, USB_VENDOR_NINTENDO, USB_PRODUCT_NINTENDO_SWITCH_JOYCON_LEFT);
+            device->type = SDL_GAMEPAD_TYPE_NINTENDO_SWITCH_JOYCON_LEFT;
+            break;
+        case k_eSwitchDeviceInfoControllerType_JoyConRight:
+            HIDAPI_SetDeviceName(device, "Nintendo Switch Joy-Con (R)");
+            HIDAPI_SetDeviceProduct(device, USB_VENDOR_NINTENDO, USB_PRODUCT_NINTENDO_SWITCH_JOYCON_RIGHT);
+            device->type = SDL_GAMEPAD_TYPE_NINTENDO_SWITCH_JOYCON_RIGHT;
+            break;
+        case k_eSwitchDeviceInfoControllerType_ProController:
+        case k_eSwitchDeviceInfoControllerType_LicProController:
+            HIDAPI_SetDeviceName(device, "Nintendo Switch Pro Controller");
+            HIDAPI_SetDeviceProduct(device, USB_VENDOR_NINTENDO, USB_PRODUCT_NINTENDO_SWITCH_PRO);
+            device->type = SDL_GAMEPAD_TYPE_NINTENDO_SWITCH_PRO;
+            break;
+        case k_eSwitchDeviceInfoControllerType_HVCLeft:
+            HIDAPI_SetDeviceName(device, "Nintendo HVC Controller (1)");
+            device->type = SDL_GAMEPAD_TYPE_STANDARD;
+            break;
+        case k_eSwitchDeviceInfoControllerType_HVCRight:
+            HIDAPI_SetDeviceName(device, "Nintendo HVC Controller (2)");
+            device->type = SDL_GAMEPAD_TYPE_STANDARD;
+            break;
+        case k_eSwitchDeviceInfoControllerType_NESLeft:
+            HIDAPI_SetDeviceName(device, "Nintendo NES Controller (L)");
+            device->type = SDL_GAMEPAD_TYPE_STANDARD;
+            break;
+        case k_eSwitchDeviceInfoControllerType_NESRight:
+            HIDAPI_SetDeviceName(device, "Nintendo NES Controller (R)");
+            device->type = SDL_GAMEPAD_TYPE_STANDARD;
+            break;
+        case k_eSwitchDeviceInfoControllerType_SNES:
+            HIDAPI_SetDeviceName(device, "Nintendo SNES Controller");
+            HIDAPI_SetDeviceProduct(device, USB_VENDOR_NINTENDO, USB_PRODUCT_NINTENDO_SNES_CONTROLLER);
+            device->type = SDL_GAMEPAD_TYPE_STANDARD;
+            break;
+        case k_eSwitchDeviceInfoControllerType_N64:
+            HIDAPI_SetDeviceName(device, "Nintendo N64 Controller");
+            HIDAPI_SetDeviceProduct(device, USB_VENDOR_NINTENDO, USB_PRODUCT_NINTENDO_N64_CONTROLLER);
+            device->type = SDL_GAMEPAD_TYPE_STANDARD;
+            break;
+        case k_eSwitchDeviceInfoControllerType_SEGA_Genesis:
+            HIDAPI_SetDeviceName(device, "Nintendo SEGA Genesis Controller");
+            HIDAPI_SetDeviceProduct(device, USB_VENDOR_NINTENDO, USB_PRODUCT_NINTENDO_SEGA_GENESIS_CONTROLLER);
+            device->type = SDL_GAMEPAD_TYPE_STANDARD;
+            break;
+        case k_eSwitchDeviceInfoControllerType_Unknown:
+            // We couldn't read the device info for this controller, might not be fully compliant
+            if (device->vendor_id == USB_VENDOR_NINTENDO) {
+                switch (device->product_id) {
+                case USB_PRODUCT_NINTENDO_SWITCH_JOYCON_LEFT:
+                    ctx->m_eControllerType = k_eSwitchDeviceInfoControllerType_JoyConLeft;
+                    HIDAPI_SetDeviceName(device, "Nintendo Switch Joy-Con (L)");
+                    device->type = SDL_GAMEPAD_TYPE_NINTENDO_SWITCH_JOYCON_LEFT;
+                    break;
+                case USB_PRODUCT_NINTENDO_SWITCH_JOYCON_RIGHT:
+                    ctx->m_eControllerType = k_eSwitchDeviceInfoControllerType_JoyConRight;
+                    HIDAPI_SetDeviceName(device, "Nintendo Switch Joy-Con (R)");
+                    device->type = SDL_GAMEPAD_TYPE_NINTENDO_SWITCH_JOYCON_RIGHT;
+                    break;
+                case USB_PRODUCT_NINTENDO_SWITCH_PRO:
+                    ctx->m_eControllerType = k_eSwitchDeviceInfoControllerType_ProController;
+                    HIDAPI_SetDeviceName(device, "Nintendo Switch Pro Controller");
+                    device->type = SDL_GAMEPAD_TYPE_NINTENDO_SWITCH_PRO;
+                    break;
+                default:
+                    break;
+                }
+            }
+            return;
+        default:
+            device->type = SDL_GAMEPAD_TYPE_STANDARD;
+            break;
+        }
+        device->guid.data[15] = ctx->m_eControllerType;
+
+        (void)SDL_snprintf(serial, sizeof(serial), "%.2x-%.2x-%.2x-%.2x-%.2x-%.2x",
+                           ctx->m_rgucMACAddress[0],
+                           ctx->m_rgucMACAddress[1],
+                           ctx->m_rgucMACAddress[2],
+                           ctx->m_rgucMACAddress[3],
+                           ctx->m_rgucMACAddress[4],
+                           ctx->m_rgucMACAddress[5]);
+        HIDAPI_SetDeviceSerial(device, serial);
+    }
+}
+
+static bool HIDAPI_DriverSwitch_InitDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverSwitch_Context *ctx;
+
+    ctx = (SDL_DriverSwitch_Context *)SDL_calloc(1, sizeof(*ctx));
+    if (!ctx) {
+        return false;
+    }
+    ctx->device = device;
+    device->context = ctx;
+
+    ctx->m_nMaxWriteAttempts = GetMaxWriteAttempts(device);
+    ctx->m_bSyncWrite = true;
+
+    // Find out whether or not we can send output reports
+    ctx->m_bInputOnly = SDL_IsJoystickNintendoSwitchProInputOnly(device->vendor_id, device->product_id);
+    if (!ctx->m_bInputOnly) {
+        // Initialize rumble data, important for reading device info on the MOBAPAD M073
+        SetNeutralRumble(&ctx->m_RumblePacket.rumbleData[0]);
+        SetNeutralRumble(&ctx->m_RumblePacket.rumbleData[1]);
+
+        BReadDeviceInfo(ctx);
+    }
+    UpdateDeviceIdentity(device);
+
+    // Prefer the USB device over the Bluetooth device
+    if (device->is_bluetooth) {
+        if (HIDAPI_HasConnectedUSBDevice(device->serial)) {
+            return true;
+        }
+    } else {
+        HIDAPI_DisconnectBluetoothDevice(device->serial);
+    }
+    return HIDAPI_JoystickConnected(device, NULL);
+}
+
+static int HIDAPI_DriverSwitch_GetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id)
+{
+    return -1;
+}
+
+static void HIDAPI_DriverSwitch_SetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id, int player_index)
+{
+    SDL_DriverSwitch_Context *ctx = (SDL_DriverSwitch_Context *)device->context;
+
+    if (!ctx->joystick) {
+        return;
+    }
+
+    ctx->m_nPlayerIndex = player_index;
+
+    UpdateSlotLED(ctx);
+}
+
+static bool HIDAPI_DriverSwitch_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverSwitch_Context *ctx = (SDL_DriverSwitch_Context *)device->context;
+
+    SDL_AssertJoysticksLocked();
+
+    ctx->joystick = joystick;
+
+    ctx->m_bSyncWrite = true;
+
+    if (!ctx->m_bInputOnly) {
+#ifdef SDL_PLATFORM_MACOS
+        // Wait for the OS to finish its handshake with the controller
+        SDL_Delay(250);
+#endif
+        GetInitialInputMode(ctx);
+        ctx->m_nCurrentInputMode = ctx->m_nInitialInputMode;
+
+        // Initialize rumble data
+        SetNeutralRumble(&ctx->m_RumblePacket.rumbleData[0]);
+        SetNeutralRumble(&ctx->m_RumblePacket.rumbleData[1]);
+
+        if (!device->is_bluetooth) {
+            if (!BTrySetupUSB(ctx)) {
+                SDL_SetError("Couldn't setup USB mode");
+                return false;
+            }
+        }
+
+        if (!LoadStickCalibration(ctx)) {
+            SDL_SetError("Couldn't load stick calibration");
+            return false;
+        }
+
+        if (ctx->m_eControllerType != k_eSwitchDeviceInfoControllerType_HVCLeft &&
+            ctx->m_eControllerType != k_eSwitchDeviceInfoControllerType_HVCRight &&
+            ctx->m_eControllerType != k_eSwitchDeviceInfoControllerType_NESLeft &&
+            ctx->m_eControllerType != k_eSwitchDeviceInfoControllerType_NESRight &&
+            ctx->m_eControllerType != k_eSwitchDeviceInfoControllerType_SNES &&
+            ctx->m_eControllerType != k_eSwitchDeviceInfoControllerType_N64 &&
+            ctx->m_eControllerType != k_eSwitchDeviceInfoControllerType_SEGA_Genesis) {
+            if (LoadIMUCalibration(ctx)) {
+                ctx->m_bSensorsSupported = true;
+            }
+        }
+
+        // Enable vibration
+        SetVibrationEnabled(ctx, 1);
+
+        // Set desired input mode
+        SDL_AddHintCallback(SDL_HINT_JOYSTICK_ENHANCED_REPORTS,
+                            SDL_EnhancedReportsChanged, ctx);
+
+        // Start sending USB reports
+        if (!device->is_bluetooth) {
+            // ForceUSB doesn't generate an ACK, so don't wait for a reply
+            if (!WriteProprietary(ctx, k_eSwitchProprietaryCommandIDs_ForceUSB, NULL, 0, false)) {
+                SDL_SetError("Couldn't start USB reports");
+                return false;
+            }
+        }
+
+        // Set the LED state
+        if (HasHomeLED(ctx)) {
+            if (ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_JoyConLeft ||
+                ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_JoyConRight) {
+                SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_JOYCON_HOME_LED,
+                                    SDL_HomeLEDHintChanged, ctx);
+            } else {
+                SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_SWITCH_HOME_LED,
+                                    SDL_HomeLEDHintChanged, ctx);
+            }
+        }
+    }
+
+    if (AlwaysUsesLabels(device->vendor_id, device->product_id, ctx->m_eControllerType)) {
+        ctx->m_bUseButtonLabels = true;
+    }
+
+    // Initialize player index (needed for setting LEDs)
+    ctx->m_nPlayerIndex = SDL_GetJoystickPlayerIndex(joystick);
+    ctx->m_bPlayerLights = SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_SWITCH_PLAYER_LED, true);
+    UpdateSlotLED(ctx);
+
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_SWITCH_PLAYER_LED,
+                        SDL_PlayerLEDHintChanged, ctx);
+
+    // Initialize the joystick capabilities
+    joystick->nbuttons = SDL_GAMEPAD_NUM_SWITCH_BUTTONS;
+    joystick->naxes = SDL_GAMEPAD_AXIS_COUNT;
+    joystick->nhats = 1;
+
+    // Set up for input
+    ctx->m_bSyncWrite = false;
+    ctx->m_ulLastIMUReset = ctx->m_ulLastInput = SDL_GetTicks();
+    ctx->m_ulIMUUpdateIntervalNS = SDL_MS_TO_NS(5); // Start off at 5 ms update rate
+
+    // Set up for vertical mode
+    ctx->m_bVerticalMode = SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_VERTICAL_JOY_CONS, false);
+
+    return true;
+}
+
+static bool HIDAPI_DriverSwitch_ActuallyRumbleJoystick(SDL_DriverSwitch_Context *ctx, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+    /* Experimentally determined rumble values. These will only matter on some controllers as tested ones
+     * seem to disregard these and just use any non-zero rumble values as a binary flag for constant rumble
+     *
+     * More information about these values can be found here:
+     * https://github.com/dekuNukem/Nintendo_Switch_Reverse_Engineering/blob/master/rumble_data_table.md
+     */
+    const Uint16 k_usHighFreq = 0x0074;
+    const Uint8 k_ucHighFreqAmp = EncodeRumbleHighAmplitude(high_frequency_rumble);
+    const Uint8 k_ucLowFreq = 0x3D;
+    const Uint16 k_usLowFreqAmp = EncodeRumbleLowAmplitude(low_frequency_rumble);
+
+    if (low_frequency_rumble || high_frequency_rumble) {
+        EncodeRumble(&ctx->m_RumblePacket.rumbleData[0], k_usHighFreq, k_ucHighFreqAmp, k_ucLowFreq, k_usLowFreqAmp);
+        EncodeRumble(&ctx->m_RumblePacket.rumbleData[1], k_usHighFreq, k_ucHighFreqAmp, k_ucLowFreq, k_usLowFreqAmp);
+    } else {
+        SetNeutralRumble(&ctx->m_RumblePacket.rumbleData[0]);
+        SetNeutralRumble(&ctx->m_RumblePacket.rumbleData[1]);
+    }
+
+    ctx->m_bRumbleActive = (low_frequency_rumble || high_frequency_rumble);
+
+    if (!WriteRumble(ctx)) {
+        return SDL_SetError("Couldn't send rumble packet");
+    }
+    return true;
+}
+
+static bool HIDAPI_DriverSwitch_SendPendingRumble(SDL_DriverSwitch_Context *ctx)
+{
+    if (SDL_GetTicks() < (ctx->m_ulRumbleSent + RUMBLE_WRITE_FREQUENCY_MS)) {
+        return true;
+    }
+
+    if (ctx->m_bRumblePending) {
+        Uint16 low_frequency_rumble = (Uint16)(ctx->m_unRumblePending >> 16);
+        Uint16 high_frequency_rumble = (Uint16)ctx->m_unRumblePending;
+
+#ifdef DEBUG_RUMBLE
+        SDL_Log("Sent pending rumble %d/%d, %d ms after previous rumble", low_frequency_rumble, high_frequency_rumble, SDL_GetTicks() - ctx->m_ulRumbleSent);
+#endif
+        ctx->m_bRumblePending = false;
+        ctx->m_unRumblePending = 0;
+
+        return HIDAPI_DriverSwitch_ActuallyRumbleJoystick(ctx, low_frequency_rumble, high_frequency_rumble);
+    }
+
+    if (ctx->m_bRumbleZeroPending) {
+        ctx->m_bRumbleZeroPending = false;
+
+#ifdef DEBUG_RUMBLE
+        SDL_Log("Sent pending zero rumble, %d ms after previous rumble", SDL_GetTicks() - ctx->m_ulRumbleSent);
+#endif
+        return HIDAPI_DriverSwitch_ActuallyRumbleJoystick(ctx, 0, 0);
+    }
+
+    return true;
+}
+
+static bool HIDAPI_DriverSwitch_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+    SDL_DriverSwitch_Context *ctx = (SDL_DriverSwitch_Context *)device->context;
+
+    if (ctx->m_bInputOnly) {
+        return SDL_Unsupported();
+    }
+
+    if (device->parent) {
+        if (ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_JoyConLeft) {
+            // Just handle low frequency rumble
+            high_frequency_rumble = 0;
+        } else if (ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_JoyConRight) {
+            // Just handle high frequency rumble
+            low_frequency_rumble = 0;
+        }
+    }
+
+    if (ctx->m_bRumblePending) {
+        if (!HIDAPI_DriverSwitch_SendPendingRumble(ctx)) {
+            return false;
+        }
+    }
+
+    if (SDL_GetTicks() < (ctx->m_ulRumbleSent + RUMBLE_WRITE_FREQUENCY_MS)) {
+        if (low_frequency_rumble || high_frequency_rumble) {
+            Uint32 unRumblePending = ((Uint32)low_frequency_rumble << 16) | high_frequency_rumble;
+
+            // Keep the highest rumble intensity in the given interval
+            if (unRumblePending > ctx->m_unRumblePending) {
+                ctx->m_unRumblePending = unRumblePending;
+            }
+            ctx->m_bRumblePending = true;
+            ctx->m_bRumbleZeroPending = false;
+        } else {
+            // When rumble is complete, turn it off
+            ctx->m_bRumbleZeroPending = true;
+        }
+        return true;
+    }
+
+#ifdef DEBUG_RUMBLE
+    SDL_Log("Sent rumble %d/%d", low_frequency_rumble, high_frequency_rumble);
+#endif
+
+    return HIDAPI_DriverSwitch_ActuallyRumbleJoystick(ctx, low_frequency_rumble, high_frequency_rumble);
+}
+
+static bool HIDAPI_DriverSwitch_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
+{
+    return SDL_Unsupported();
+}
+
+static Uint32 HIDAPI_DriverSwitch_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverSwitch_Context *ctx = (SDL_DriverSwitch_Context *)device->context;
+    Uint32 result = 0;
+
+    if (ctx->m_bPlayerLights && !ctx->m_bInputOnly) {
+        result |= SDL_JOYSTICK_CAP_PLAYER_LED;
+    }
+
+    if (ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_ProController && !ctx->m_bInputOnly) {
+        // Doesn't have an RGB LED, so don't return SDL_JOYSTICK_CAP_RGB_LED here
+        result |= SDL_JOYSTICK_CAP_RUMBLE;
+    } else if (ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_JoyConLeft ||
+               ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_JoyConRight) {
+        result |= SDL_JOYSTICK_CAP_RUMBLE;
+    }
+    return result;
+}
+
+static bool HIDAPI_DriverSwitch_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverSwitch_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *data, int size)
+{
+    SDL_DriverSwitch_Context *ctx = (SDL_DriverSwitch_Context *)device->context;
+
+    if (size == sizeof(SwitchCommonOutputPacket_t)) {
+        const SwitchCommonOutputPacket_t *packet = (SwitchCommonOutputPacket_t *)data;
+
+        if (packet->ucPacketType != k_eSwitchOutputReportIDs_Rumble) {
+            return SDL_SetError("Unknown Nintendo Switch Pro effect type");
+        }
+
+        SDL_copyp(&ctx->m_RumblePacket.rumbleData[0], &packet->rumbleData[0]);
+        SDL_copyp(&ctx->m_RumblePacket.rumbleData[1], &packet->rumbleData[1]);
+        if (!WriteRumble(ctx)) {
+            return false;
+        }
+
+        // This overwrites any internal rumble
+        ctx->m_bRumblePending = false;
+        ctx->m_bRumbleZeroPending = false;
+        return true;
+    } else if (size >= 2 && size <= 256) {
+        const Uint8 *payload = (const Uint8 *)data;
+        ESwitchSubcommandIDs cmd = (ESwitchSubcommandIDs)payload[0];
+
+        if (cmd == k_eSwitchSubcommandIDs_SetInputReportMode && !device->is_bluetooth) {
+            // Going into simple mode over USB disables input reports, so don't do that
+            return true;
+        }
+        if (cmd == k_eSwitchSubcommandIDs_SetHomeLight && !HasHomeLED(ctx)) {
+            // Setting the home LED when it's not supported can cause the controller to reset
+            return true;
+        }
+
+        if (!WriteSubcommand(ctx, cmd, &payload[1], (Uint8)(size - 1), NULL)) {
+            return false;
+        }
+        return true;
+    }
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverSwitch_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, bool enabled)
+{
+    SDL_DriverSwitch_Context *ctx = (SDL_DriverSwitch_Context *)device->context;
+
+    UpdateEnhancedModeOnApplicationUsage(ctx);
+
+    if (!ctx->m_bSensorsSupported || (enabled && !ctx->m_bEnhancedMode)) {
+        return SDL_Unsupported();
+    }
+
+    ctx->m_bReportSensors = enabled;
+    ctx->m_unIMUSamples = 0;
+    ctx->m_ulIMUSampleTimestampNS = SDL_GetTicksNS();
+
+    UpdateInputMode(ctx);
+    SetIMUEnabled(ctx, enabled);
+
+    return true;
+}
+
+static void HandleInputOnlyControllerState(SDL_Joystick *joystick, SDL_DriverSwitch_Context *ctx, SwitchInputOnlyControllerStatePacket_t *packet)
+{
+    Sint16 axis;
+    Uint64 timestamp = SDL_GetTicksNS();
+
+    if (packet->rgucButtons[0] != ctx->m_lastInputOnlyState.rgucButtons[0]) {
+        Uint8 data = packet->rgucButtons[0];
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_SOUTH), ((data & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_EAST), ((data & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_WEST), ((data & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_NORTH), ((data & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data & 0x20) != 0));
+    }
+
+    if (packet->rgucButtons[1] != ctx->m_lastInputOnlyState.rgucButtons[1]) {
+        Uint8 data = packet->rgucButtons[1];
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK, ((data & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_STICK, ((data & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SWITCH_SHARE, ((data & 0x20) != 0));
+    }
+
+    if (packet->ucStickHat != ctx->m_lastInputOnlyState.ucStickHat) {
+        Uint8 hat;
+
+        switch (packet->ucStickHat) {
+        case 0:
+            hat = SDL_HAT_UP;
+            break;
+        case 1:
+            hat = SDL_HAT_RIGHTUP;
+            break;
+        case 2:
+            hat = SDL_HAT_RIGHT;
+            break;
+        case 3:
+            hat = SDL_HAT_RIGHTDOWN;
+            break;
+        case 4:
+            hat = SDL_HAT_DOWN;
+            break;
+        case 5:
+            hat = SDL_HAT_LEFTDOWN;
+            break;
+        case 6:
+            hat = SDL_HAT_LEFT;
+            break;
+        case 7:
+            hat = SDL_HAT_LEFTUP;
+            break;
+        default:
+            hat = SDL_HAT_CENTERED;
+            break;
+        }
+        SDL_SendJoystickHat(timestamp, joystick, 0, hat);
+    }
+
+    axis = (packet->rgucButtons[0] & 0x40) ? 32767 : -32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, axis);
+
+    axis = (packet->rgucButtons[0] & 0x80) ? 32767 : -32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, axis);
+
+    if (packet->rgucJoystickLeft[0] != ctx->m_lastInputOnlyState.rgucJoystickLeft[0]) {
+        axis = (Sint16)HIDAPI_RemapVal(packet->rgucJoystickLeft[0], SDL_MIN_UINT8, SDL_MAX_UINT8, SDL_MIN_SINT16, SDL_MAX_SINT16);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, axis);
+    }
+
+    if (packet->rgucJoystickLeft[1] != ctx->m_lastInputOnlyState.rgucJoystickLeft[1]) {
+        axis = (Sint16)HIDAPI_RemapVal(packet->rgucJoystickLeft[1], SDL_MIN_UINT8, SDL_MAX_UINT8, SDL_MIN_SINT16, SDL_MAX_SINT16);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, axis);
+    }
+
+    if (packet->rgucJoystickRight[0] != ctx->m_lastInputOnlyState.rgucJoystickRight[0]) {
+        axis = (Sint16)HIDAPI_RemapVal(packet->rgucJoystickRight[0], SDL_MIN_UINT8, SDL_MAX_UINT8, SDL_MIN_SINT16, SDL_MAX_SINT16);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, axis);
+    }
+
+    if (packet->rgucJoystickRight[1] != ctx->m_lastInputOnlyState.rgucJoystickRight[1]) {
+        axis = (Sint16)HIDAPI_RemapVal(packet->rgucJoystickRight[1], SDL_MIN_UINT8, SDL_MAX_UINT8, SDL_MIN_SINT16, SDL_MAX_SINT16);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, axis);
+    }
+
+    ctx->m_lastInputOnlyState = *packet;
+}
+
+static void HandleCombinedSimpleControllerStateL(Uint64 timestamp, SDL_Joystick *joystick, SDL_DriverSwitch_Context *ctx, SwitchSimpleStatePacket_t *packet)
+{
+    if (packet->rgucButtons[0] != ctx->m_lastSimpleState.rgucButtons[0]) {
+        Uint8 data = packet->rgucButtons[0];
+        Uint8 hat = 0;
+
+        if (data & 0x01) {
+            hat |= SDL_HAT_LEFT;
+        }
+        if (data & 0x02) {
+            hat |= SDL_HAT_DOWN;
+        }
+        if (data & 0x04) {
+            hat |= SDL_HAT_UP;
+        }
+        if (data & 0x08) {
+            hat |= SDL_HAT_RIGHT;
+        }
+        SDL_SendJoystickHat(timestamp, joystick, 0, hat);
+
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SWITCH_LEFT_PADDLE1, ((data & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SWITCH_LEFT_PADDLE2, ((data & 0x20) != 0));
+    }
+
+    if (packet->rgucButtons[1] != ctx->m_lastSimpleState.rgucButtons[1]) {
+        Uint8 data = packet->rgucButtons[1];
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK, ((data & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SWITCH_SHARE, ((data & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data & 0x40) != 0));
+    }
+
+    Sint16 axis = (packet->rgucButtons[1] & 0x80) ? 32767 : -32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, axis);
+
+    if (packet->ucStickHat != ctx->m_lastSimpleState.ucStickHat) {
+        switch (packet->ucStickHat) {
+        case 0:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, SDL_JOYSTICK_AXIS_MAX);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, 0);
+            break;
+        case 1:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, SDL_JOYSTICK_AXIS_MAX);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, SDL_JOYSTICK_AXIS_MAX);
+            break;
+        case 2:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, 0);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, SDL_JOYSTICK_AXIS_MAX);
+            break;
+        case 3:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, SDL_JOYSTICK_AXIS_MIN);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, SDL_JOYSTICK_AXIS_MAX);
+            break;
+        case 4:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, SDL_JOYSTICK_AXIS_MIN);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, 0);
+            break;
+        case 5:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, SDL_JOYSTICK_AXIS_MIN);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, SDL_JOYSTICK_AXIS_MIN);
+            break;
+        case 6:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, 0);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, SDL_JOYSTICK_AXIS_MIN);
+            break;
+        case 7:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, SDL_JOYSTICK_AXIS_MAX);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, SDL_JOYSTICK_AXIS_MIN);
+            break;
+        default:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, 0);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, 0);
+            break;
+        }
+    }
+}
+
+static void HandleCombinedSimpleControllerStateR(Uint64 timestamp, SDL_Joystick *joystick, SDL_DriverSwitch_Context *ctx, SwitchSimpleStatePacket_t *packet)
+{
+    if (packet->rgucButtons[0] != ctx->m_lastSimpleState.rgucButtons[0]) {
+        Uint8 data = packet->rgucButtons[0];
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_EAST), ((data & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_NORTH), ((data & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_SOUTH), ((data & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_WEST), ((data & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SWITCH_RIGHT_PADDLE2, ((data & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SWITCH_RIGHT_PADDLE1, ((data & 0x20) != 0));
+    }
+
+    if (packet->rgucButtons[1] != ctx->m_lastSimpleState.rgucButtons[1]) {
+        Uint8 data = packet->rgucButtons[1];
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_STICK, ((data & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data & 0x40) != 0));
+    }
+
+    Sint16 axis = (packet->rgucButtons[1] & 0x80) ? 32767 : -32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, axis);
+
+    if (packet->ucStickHat != ctx->m_lastSimpleState.ucStickHat) {
+        switch (packet->ucStickHat) {
+        case 0:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, SDL_JOYSTICK_AXIS_MIN);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, 0);
+            break;
+        case 1:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, SDL_JOYSTICK_AXIS_MIN);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, SDL_JOYSTICK_AXIS_MIN);
+            break;
+        case 2:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, 0);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, SDL_JOYSTICK_AXIS_MIN);
+            break;
+        case 3:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, SDL_JOYSTICK_AXIS_MAX);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, SDL_JOYSTICK_AXIS_MIN);
+            break;
+        case 4:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, SDL_JOYSTICK_AXIS_MAX);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, 0);
+            break;
+        case 5:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, SDL_JOYSTICK_AXIS_MAX);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, SDL_JOYSTICK_AXIS_MAX);
+            break;
+        case 6:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, 0);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, SDL_JOYSTICK_AXIS_MAX);
+            break;
+        case 7:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, SDL_JOYSTICK_AXIS_MIN);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, SDL_JOYSTICK_AXIS_MAX);
+            break;
+        default:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, 0);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, 0);
+            break;
+        }
+    }
+}
+
+static void HandleMiniSimpleControllerStateL(Uint64 timestamp, SDL_Joystick *joystick, SDL_DriverSwitch_Context *ctx, SwitchSimpleStatePacket_t *packet)
+{
+    if (packet->rgucButtons[0] != ctx->m_lastSimpleState.rgucButtons[0]) {
+        Uint8 data = packet->rgucButtons[0];
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_SOUTH), ((data & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_EAST), ((data & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_WEST), ((data & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_NORTH), ((data & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data & 0x20) != 0));
+    }
+
+    if (packet->rgucButtons[1] != ctx->m_lastSimpleState.rgucButtons[1]) {
+        Uint8 data = packet->rgucButtons[1];
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SWITCH_LEFT_PADDLE1, ((data & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SWITCH_LEFT_PADDLE2, ((data & 0x80) != 0));
+    }
+
+    if (packet->ucStickHat != ctx->m_lastSimpleState.ucStickHat) {
+        switch (packet->ucStickHat) {
+        case 0:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, 0);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, SDL_JOYSTICK_AXIS_MIN);
+            break;
+        case 1:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, SDL_JOYSTICK_AXIS_MAX);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, SDL_JOYSTICK_AXIS_MIN);
+            break;
+        case 2:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, SDL_JOYSTICK_AXIS_MAX);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, 0);
+            break;
+        case 3:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, SDL_JOYSTICK_AXIS_MAX);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, SDL_JOYSTICK_AXIS_MAX);
+            break;
+        case 4:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, 0);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, SDL_JOYSTICK_AXIS_MAX);
+            break;
+        case 5:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, SDL_JOYSTICK_AXIS_MIN);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, SDL_JOYSTICK_AXIS_MAX);
+            break;
+        case 6:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, SDL_JOYSTICK_AXIS_MIN);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, 0);
+            break;
+        case 7:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, SDL_JOYSTICK_AXIS_MIN);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, SDL_JOYSTICK_AXIS_MIN);
+            break;
+        default:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, 0);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, 0);
+            break;
+        }
+    }
+}
+
+static void HandleMiniSimpleControllerStateR(Uint64 timestamp, SDL_Joystick *joystick, SDL_DriverSwitch_Context *ctx, SwitchSimpleStatePacket_t *packet)
+{
+    if (packet->rgucButtons[0] != ctx->m_lastSimpleState.rgucButtons[0]) {
+        Uint8 data = packet->rgucButtons[0];
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_SOUTH), ((data & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_EAST), ((data & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_WEST), ((data & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_NORTH), ((data & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data & 0x20) != 0));
+    }
+
+    if (packet->rgucButtons[1] != ctx->m_lastSimpleState.rgucButtons[1]) {
+        Uint8 data = packet->rgucButtons[1];
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SWITCH_SHARE, ((data & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SWITCH_RIGHT_PADDLE1, ((data & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SWITCH_RIGHT_PADDLE2, ((data & 0x80) != 0));
+    }
+
+    if (packet->ucStickHat != ctx->m_lastSimpleState.ucStickHat) {
+        switch (packet->ucStickHat) {
+        case 0:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, 0);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, SDL_JOYSTICK_AXIS_MIN);
+            break;
+        case 1:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, SDL_JOYSTICK_AXIS_MAX);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, SDL_JOYSTICK_AXIS_MIN);
+            break;
+        case 2:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, SDL_JOYSTICK_AXIS_MAX);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, 0);
+            break;
+        case 3:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, SDL_JOYSTICK_AXIS_MAX);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, SDL_JOYSTICK_AXIS_MAX);
+            break;
+        case 4:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, 0);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, SDL_JOYSTICK_AXIS_MAX);
+            break;
+        case 5:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, SDL_JOYSTICK_AXIS_MIN);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, SDL_JOYSTICK_AXIS_MAX);
+            break;
+        case 6:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, SDL_JOYSTICK_AXIS_MIN);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, 0);
+            break;
+        case 7:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, SDL_JOYSTICK_AXIS_MIN);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, SDL_JOYSTICK_AXIS_MIN);
+            break;
+        default:
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, 0);
+            SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, 0);
+            break;
+        }
+    }
+}
+
+static void HandleSimpleControllerState(SDL_Joystick *joystick, SDL_DriverSwitch_Context *ctx, SwitchSimpleStatePacket_t *packet)
+{
+    Uint64 timestamp = SDL_GetTicksNS();
+
+    if (ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_JoyConLeft) {
+        if (ctx->device->parent || ctx->m_bVerticalMode) {
+            HandleCombinedSimpleControllerStateL(timestamp, joystick, ctx, packet);
+        } else {
+            HandleMiniSimpleControllerStateL(timestamp, joystick, ctx, packet);
+        }
+    } else if (ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_JoyConRight) {
+        if (ctx->device->parent || ctx->m_bVerticalMode) {
+            HandleCombinedSimpleControllerStateR(timestamp, joystick, ctx, packet);
+        } else {
+            HandleMiniSimpleControllerStateR(timestamp, joystick, ctx, packet);
+        }
+    } else {
+        Sint16 axis;
+
+        if (packet->rgucButtons[0] != ctx->m_lastSimpleState.rgucButtons[0]) {
+            Uint8 data = packet->rgucButtons[0];
+            SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_SOUTH), ((data & 0x01) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_EAST), ((data & 0x02) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_WEST), ((data & 0x04) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_NORTH), ((data & 0x08) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data & 0x10) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data & 0x20) != 0));
+        }
+
+        if (packet->rgucButtons[1] != ctx->m_lastSimpleState.rgucButtons[1]) {
+            Uint8 data = packet->rgucButtons[1];
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK, ((data & 0x01) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data & 0x02) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data & 0x04) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_STICK, ((data & 0x08) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data & 0x10) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SWITCH_SHARE, ((data & 0x20) != 0));
+        }
+
+        if (packet->ucStickHat != ctx->m_lastSimpleState.ucStickHat) {
+            Uint8 hat;
+
+            switch (packet->ucStickHat) {
+            case 0:
+                hat = SDL_HAT_UP;
+                break;
+            case 1:
+                hat = SDL_HAT_RIGHTUP;
+                break;
+            case 2:
+                hat = SDL_HAT_RIGHT;
+                break;
+            case 3:
+                hat = SDL_HAT_RIGHTDOWN;
+                break;
+            case 4:
+                hat = SDL_HAT_DOWN;
+                break;
+            case 5:
+                hat = SDL_HAT_LEFTDOWN;
+                break;
+            case 6:
+                hat = SDL_HAT_LEFT;
+                break;
+            case 7:
+                hat = SDL_HAT_LEFTUP;
+                break;
+            default:
+                hat = SDL_HAT_CENTERED;
+                break;
+            }
+            SDL_SendJoystickHat(timestamp, joystick, 0, hat);
+        }
+
+        axis = (packet->rgucButtons[0] & 0x40) ? 32767 : -32768;
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, axis);
+
+        axis = ((packet->rgucButtons[0] & 0x80) || (packet->rgucButtons[1] & 0x80)) ? 32767 : -32768;
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, axis);
+
+        axis = ApplySimpleStickCalibration(ctx, 0, 0, packet->sJoystickLeft[0]);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, axis);
+
+        axis = ApplySimpleStickCalibration(ctx, 0, 1, packet->sJoystickLeft[1]);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, axis);
+
+        axis = ApplySimpleStickCalibration(ctx, 1, 0, packet->sJoystickRight[0]);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, axis);
+
+        axis = ApplySimpleStickCalibration(ctx, 1, 1, packet->sJoystickRight[1]);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, axis);
+    }
+
+    ctx->m_lastSimpleState = *packet;
+}
+
+static void SendSensorUpdate(Uint64 timestamp, SDL_Joystick *joystick, SDL_DriverSwitch_Context *ctx, SDL_SensorType type, Uint64 sensor_timestamp, const Sint16 *values)
+{
+    float data[3];
+
+    /* Note the order of components has been shuffled to match PlayStation controllers,
+     * since that's our de facto standard from already supporting those controllers, and
+     * users will want consistent axis mappings across devices.
+     */
+    if (type == SDL_SENSOR_GYRO || type == SDL_SENSOR_GYRO_L || type == SDL_SENSOR_GYRO_R) {
+        data[0] = -(ctx->m_IMUScaleData.fGyroScaleY * (float)values[1]);
+        data[1] = ctx->m_IMUScaleData.fGyroScaleZ * (float)values[2];
+        data[2] = -(ctx->m_IMUScaleData.fGyroScaleX * (float)values[0]);
+    } else {
+        data[0] = -(ctx->m_IMUScaleData.fAccelScaleY * (float)values[1]);
+        data[1] = ctx->m_IMUScaleData.fAccelScaleZ * (float)values[2];
+        data[2] = -(ctx->m_IMUScaleData.fAccelScaleX * (float)values[0]);
+    }
+
+    // Right Joy-Con flips some axes, so let's flip them back for consistency
+    if (ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_JoyConRight) {
+        data[0] = -data[0];
+        data[1] = -data[1];
+    }
+
+    if (ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_JoyConLeft &&
+        !ctx->device->parent && !ctx->m_bVerticalMode) {
+        // Mini-gamepad mode, swap some axes around
+        float tmp = data[2];
+        data[2] = -data[0];
+        data[0] = tmp;
+    }
+
+    if (ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_JoyConRight &&
+        !ctx->device->parent && !ctx->m_bVerticalMode) {
+        // Mini-gamepad mode, swap some axes around
+        float tmp = data[2];
+        data[2] = data[0];
+        data[0] = -tmp;
+    }
+
+    SDL_SendJoystickSensor(timestamp, joystick, type, sensor_timestamp, data, 3);
+}
+
+static void HandleCombinedControllerStateL(Uint64 timestamp, SDL_Joystick *joystick, SDL_DriverSwitch_Context *ctx, SwitchStatePacket_t *packet)
+{
+    Sint16 axis;
+
+    if (packet->controllerState.rgucButtons[1] != ctx->m_lastFullState.controllerState.rgucButtons[1]) {
+        Uint8 data = packet->controllerState.rgucButtons[1];
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK, ((data & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SWITCH_SHARE, ((data & 0x20) != 0));
+    }
+
+    if (packet->controllerState.rgucButtons[2] != ctx->m_lastFullState.controllerState.rgucButtons[2]) {
+        Uint8 data = packet->controllerState.rgucButtons[2];
+        Uint8 hat = 0;
+
+        if (data & 0x01) {
+            hat |= SDL_HAT_DOWN;
+        }
+        if (data & 0x02) {
+            hat |= SDL_HAT_UP;
+        }
+        if (data & 0x04) {
+            hat |= SDL_HAT_RIGHT;
+        }
+        if (data & 0x08) {
+            hat |= SDL_HAT_LEFT;
+        }
+        SDL_SendJoystickHat(timestamp, joystick, 0, hat);
+
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SWITCH_LEFT_PADDLE2, ((data & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SWITCH_LEFT_PADDLE1, ((data & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data & 0x40) != 0));
+        axis = (data & 0x80) ? 32767 : -32768;
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, axis);
+    }
+
+    axis = packet->controllerState.rgucJoystickLeft[0] | ((packet->controllerState.rgucJoystickLeft[1] & 0xF) << 8);
+    axis = ApplyStickCalibration(ctx, 0, 0, axis);
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, axis);
+
+    axis = ((packet->controllerState.rgucJoystickLeft[1] & 0xF0) >> 4) | (packet->controllerState.rgucJoystickLeft[2] << 4);
+    axis = ApplyStickCalibration(ctx, 0, 1, axis);
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, ~axis);
+}
+
+static void HandleCombinedControllerStateR(Uint64 timestamp, SDL_Joystick *joystick, SDL_DriverSwitch_Context *ctx, SwitchStatePacket_t *packet)
+{
+    Sint16 axis;
+
+    if (packet->controllerState.rgucButtons[0] != ctx->m_lastFullState.controllerState.rgucButtons[0]) {
+        Uint8 data = packet->controllerState.rgucButtons[0];
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_SOUTH), ((data & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_EAST), ((data & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_WEST), ((data & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_NORTH), ((data & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SWITCH_RIGHT_PADDLE1, ((data & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SWITCH_RIGHT_PADDLE2, ((data & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data & 0x40) != 0));
+        axis = (data & 0x80) ? 32767 : -32768;
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, axis);
+    }
+
+    if (packet->controllerState.rgucButtons[1] != ctx->m_lastFullState.controllerState.rgucButtons[1]) {
+        Uint8 data = packet->controllerState.rgucButtons[1];
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_STICK, ((data & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data & 0x10) != 0));
+    }
+
+    axis = packet->controllerState.rgucJoystickRight[0] | ((packet->controllerState.rgucJoystickRight[1] & 0xF) << 8);
+    axis = ApplyStickCalibration(ctx, 1, 0, axis);
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, axis);
+
+    axis = ((packet->controllerState.rgucJoystickRight[1] & 0xF0) >> 4) | (packet->controllerState.rgucJoystickRight[2] << 4);
+    axis = ApplyStickCalibration(ctx, 1, 1, axis);
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, ~axis);
+}
+
+static void HandleMiniControllerStateL(Uint64 timestamp, SDL_Joystick *joystick, SDL_DriverSwitch_Context *ctx, SwitchStatePacket_t *packet)
+{
+    Sint16 axis;
+
+    if (packet->controllerState.rgucButtons[1] != ctx->m_lastFullState.controllerState.rgucButtons[1]) {
+        Uint8 data = packet->controllerState.rgucButtons[1];
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data & 0x20) != 0));
+    }
+
+    if (packet->controllerState.rgucButtons[2] != ctx->m_lastFullState.controllerState.rgucButtons[2]) {
+        Uint8 data = packet->controllerState.rgucButtons[2];
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_SOUTH), ((data & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_EAST), ((data & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_WEST), ((data & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_NORTH), ((data & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SWITCH_LEFT_PADDLE1, ((data & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SWITCH_LEFT_PADDLE2, ((data & 0x80) != 0));
+    }
+
+    axis = packet->controllerState.rgucJoystickLeft[0] | ((packet->controllerState.rgucJoystickLeft[1] & 0xF) << 8);
+    axis = ApplyStickCalibration(ctx, 0, 0, axis);
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, ~axis);
+
+    axis = ((packet->controllerState.rgucJoystickLeft[1] & 0xF0) >> 4) | (packet->controllerState.rgucJoystickLeft[2] << 4);
+    axis = ApplyStickCalibration(ctx, 0, 1, axis);
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, ~axis);
+}
+
+static void HandleMiniControllerStateR(Uint64 timestamp, SDL_Joystick *joystick, SDL_DriverSwitch_Context *ctx, SwitchStatePacket_t *packet)
+{
+    Sint16 axis;
+
+    if (packet->controllerState.rgucButtons[0] != ctx->m_lastFullState.controllerState.rgucButtons[0]) {
+        Uint8 data = packet->controllerState.rgucButtons[0];
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_SOUTH), ((data & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_EAST), ((data & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_WEST), ((data & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_NORTH), ((data & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SWITCH_RIGHT_PADDLE1, ((data & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SWITCH_RIGHT_PADDLE2, ((data & 0x80) != 0));
+    }
+
+    if (packet->controllerState.rgucButtons[1] != ctx->m_lastFullState.controllerState.rgucButtons[1]) {
+        Uint8 data = packet->controllerState.rgucButtons[1];
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data & 0x10) != 0));
+    }
+
+    axis = packet->controllerState.rgucJoystickRight[0] | ((packet->controllerState.rgucJoystickRight[1] & 0xF) << 8);
+    axis = ApplyStickCalibration(ctx, 1, 0, axis);
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, axis);
+
+    axis = ((packet->controllerState.rgucJoystickRight[1] & 0xF0) >> 4) | (packet->controllerState.rgucJoystickRight[2] << 4);
+    axis = ApplyStickCalibration(ctx, 1, 1, axis);
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, axis);
+}
+
+static void HandleFullControllerState(SDL_Joystick *joystick, SDL_DriverSwitch_Context *ctx, SwitchStatePacket_t *packet) SDL_NO_THREAD_SAFETY_ANALYSIS // We unlock and lock the device lock to be able to change IMU state
+{
+    Uint64 timestamp = SDL_GetTicksNS();
+
+    if (ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_JoyConLeft) {
+        if (ctx->device->parent || ctx->m_bVerticalMode) {
+            HandleCombinedControllerStateL(timestamp, joystick, ctx, packet);
+        } else {
+            HandleMiniControllerStateL(timestamp, joystick, ctx, packet);
+        }
+    } else if (ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_JoyConRight) {
+        if (ctx->device->parent || ctx->m_bVerticalMode) {
+            HandleCombinedControllerStateR(timestamp, joystick, ctx, packet);
+        } else {
+            HandleMiniControllerStateR(timestamp, joystick, ctx, packet);
+        }
+    } else {
+        Sint16 axis;
+
+        if (packet->controllerState.rgucButtons[0] != ctx->m_lastFullState.controllerState.rgucButtons[0]) {
+            Uint8 data = packet->controllerState.rgucButtons[0];
+            SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_SOUTH), ((data & 0x04) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_EAST), ((data & 0x08) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_WEST), ((data & 0x01) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, RemapButton(ctx, SDL_GAMEPAD_BUTTON_NORTH), ((data & 0x02) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data & 0x40) != 0));
+        }
+
+        if (packet->controllerState.rgucButtons[1] != ctx->m_lastFullState.controllerState.rgucButtons[1]) {
+            Uint8 data = packet->controllerState.rgucButtons[1];
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK, ((data & 0x01) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data & 0x02) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_STICK, ((data & 0x04) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data & 0x08) != 0));
+
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data & 0x10) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SWITCH_SHARE, ((data & 0x20) != 0));
+        }
+
+        if (packet->controllerState.rgucButtons[2] != ctx->m_lastFullState.controllerState.rgucButtons[2]) {
+            Uint8 data = packet->controllerState.rgucButtons[2];
+            Uint8 hat = 0;
+
+            if (data & 0x01) {
+                hat |= SDL_HAT_DOWN;
+            }
+            if (data & 0x02) {
+                hat |= SDL_HAT_UP;
+            }
+            if (data & 0x04) {
+                hat |= SDL_HAT_RIGHT;
+            }
+            if (data & 0x08) {
+                hat |= SDL_HAT_LEFT;
+            }
+            SDL_SendJoystickHat(timestamp, joystick, 0, hat);
+
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data & 0x40) != 0));
+        }
+
+        axis = (packet->controllerState.rgucButtons[0] & 0x80) ? 32767 : -32768;
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, axis);
+
+        axis = (packet->controllerState.rgucButtons[2] & 0x80) ? 32767 : -32768;
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, axis);
+
+        axis = packet->controllerState.rgucJoystickLeft[0] | ((packet->controllerState.rgucJoystickLeft[1] & 0xF) << 8);
+        axis = ApplyStickCalibration(ctx, 0, 0, axis);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, axis);
+
+        axis = ((packet->controllerState.rgucJoystickLeft[1] & 0xF0) >> 4) | (packet->controllerState.rgucJoystickLeft[2] << 4);
+        axis = ApplyStickCalibration(ctx, 0, 1, axis);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, ~axis);
+
+        axis = packet->controllerState.rgucJoystickRight[0] | ((packet->controllerState.rgucJoystickRight[1] & 0xF) << 8);
+        axis = ApplyStickCalibration(ctx, 1, 0, axis);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, axis);
+
+        axis = ((packet->controllerState.rgucJoystickRight[1] & 0xF0) >> 4) | (packet->controllerState.rgucJoystickRight[2] << 4);
+        axis = ApplyStickCalibration(ctx, 1, 1, axis);
+        SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, ~axis);
+    }
+
+    /* High nibble of battery/connection byte is battery level, low nibble is connection status (always 0 on 8BitDo Pro 2)
+     * LSB of connection nibble is USB/Switch connection status
+     * LSB of the battery nibble is used to report charging.
+     * The battery level is reported from 0(empty)-8(full)
+     */
+    SDL_PowerState state;
+    int charging = (packet->controllerState.ucBatteryAndConnection & 0x10);
+    int level = (packet->controllerState.ucBatteryAndConnection & 0xE0) >> 4;
+    int percent = (int)SDL_roundf((level / 8.0f) * 100.0f);
+
+    if (charging) {
+        if (level == 8) {
+            state = SDL_POWERSTATE_CHARGED;
+        } else {
+            state = SDL_POWERSTATE_CHARGING;
+        }
+    } else {
+        state = SDL_POWERSTATE_ON_BATTERY;
+    }
+    SDL_SendJoystickPowerInfo(joystick, state, percent);
+
+    if (ctx->m_bReportSensors) {
+        bool bHasSensorData = (packet->imuState[0].sAccelZ != 0 ||
+                                   packet->imuState[0].sAccelY != 0 ||
+                                   packet->imuState[0].sAccelX != 0);
+        if (bHasSensorData) {
+            const Uint32 IMU_UPDATE_RATE_SAMPLE_FREQUENCY = 1000;
+            Uint64 sensor_timestamp[3];
+
+            ctx->m_bHasSensorData = true;
+
+            // We got three IMU samples, calculate the IMU update rate and timestamps
+            ctx->m_unIMUSamples += 3;
+            if (ctx->m_unIMUSamples >= IMU_UPDATE_RATE_SAMPLE_FREQUENCY) {
+                Uint64 now = SDL_GetTicksNS();
+                Uint64 elapsed = (now - ctx->m_ulIMUSampleTimestampNS);
+
+                if (elapsed > 0) {
+                    ctx->m_ulIMUUpdateIntervalNS = elapsed / ctx->m_unIMUSamples;
+                }
+                ctx->m_unIMUSamples = 0;
+                ctx->m_ulIMUSampleTimestampNS = now;
+            }
+
+            ctx->m_ulTimestampNS += ctx->m_ulIMUUpdateIntervalNS;
+            sensor_timestamp[0] = ctx->m_ulTimestampNS;
+            ctx->m_ulTimestampNS += ctx->m_ulIMUUpdateIntervalNS;
+            sensor_timestamp[1] = ctx->m_ulTimestampNS;
+            ctx->m_ulTimestampNS += ctx->m_ulIMUUpdateIntervalNS;
+            sensor_timestamp[2] = ctx->m_ulTimestampNS;
+
+            if (!ctx->device->parent ||
+                ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_JoyConRight) {
+                SendSensorUpdate(timestamp, joystick, ctx, SDL_SENSOR_GYRO, sensor_timestamp[0], &packet->imuState[2].sGyroX);
+                SendSensorUpdate(timestamp, joystick, ctx, SDL_SENSOR_ACCEL, sensor_timestamp[0], &packet->imuState[2].sAccelX);
+
+                SendSensorUpdate(timestamp, joystick, ctx, SDL_SENSOR_GYRO, sensor_timestamp[1], &packet->imuState[1].sGyroX);
+                SendSensorUpdate(timestamp, joystick, ctx, SDL_SENSOR_ACCEL, sensor_timestamp[1], &packet->imuState[1].sAccelX);
+
+                SendSensorUpdate(timestamp, joystick, ctx, SDL_SENSOR_GYRO, sensor_timestamp[2], &packet->imuState[0].sGyroX);
+                SendSensorUpdate(timestamp, joystick, ctx, SDL_SENSOR_ACCEL, sensor_timestamp[2], &packet->imuState[0].sAccelX);
+            }
+
+            if (ctx->device->parent &&
+                ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_JoyConLeft) {
+                SendSensorUpdate(timestamp, joystick, ctx, SDL_SENSOR_GYRO_L, sensor_timestamp[0], &packet->imuState[2].sGyroX);
+                SendSensorUpdate(timestamp, joystick, ctx, SDL_SENSOR_ACCEL_L, sensor_timestamp[0], &packet->imuState[2].sAccelX);
+
+                SendSensorUpdate(timestamp, joystick, ctx, SDL_SENSOR_GYRO_L, sensor_timestamp[1], &packet->imuState[1].sGyroX);
+                SendSensorUpdate(timestamp, joystick, ctx, SDL_SENSOR_ACCEL_L, sensor_timestamp[1], &packet->imuState[1].sAccelX);
+
+                SendSensorUpdate(timestamp, joystick, ctx, SDL_SENSOR_GYRO_L, sensor_timestamp[2], &packet->imuState[0].sGyroX);
+                SendSensorUpdate(timestamp, joystick, ctx, SDL_SENSOR_ACCEL_L, sensor_timestamp[2], &packet->imuState[0].sAccelX);
+            }
+            if (ctx->device->parent &&
+                ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_JoyConRight) {
+                SendSensorUpdate(timestamp, joystick, ctx, SDL_SENSOR_GYRO_R, sensor_timestamp[0], &packet->imuState[2].sGyroX);
+                SendSensorUpdate(timestamp, joystick, ctx, SDL_SENSOR_ACCEL_R, sensor_timestamp[0], &packet->imuState[2].sAccelX);
+
+                SendSensorUpdate(timestamp, joystick, ctx, SDL_SENSOR_GYRO_R, sensor_timestamp[1], &packet->imuState[1].sGyroX);
+                SendSensorUpdate(timestamp, joystick, ctx, SDL_SENSOR_ACCEL_R, sensor_timestamp[1], &packet->imuState[1].sAccelX);
+
+                SendSensorUpdate(timestamp, joystick, ctx, SDL_SENSOR_GYRO_R, sensor_timestamp[2], &packet->imuState[0].sGyroX);
+                SendSensorUpdate(timestamp, joystick, ctx, SDL_SENSOR_ACCEL_R, sensor_timestamp[2], &packet->imuState[0].sAccelX);
+            }
+
+        } else if (ctx->m_bHasSensorData) {
+            // Uh oh, someone turned off the IMU?
+            const int IMU_RESET_DELAY_MS = 3000;
+            Uint64 now = SDL_GetTicks();
+
+            if (now >= (ctx->m_ulLastIMUReset + IMU_RESET_DELAY_MS)) {
+                SDL_HIDAPI_Device *device = ctx->device;
+
+                if (device->updating) {
+                    SDL_UnlockMutex(device->dev_lock);
+                }
+
+                SetIMUEnabled(ctx, true);
+
+                if (device->updating) {
+                    SDL_LockMutex(device->dev_lock);
+                }
+                ctx->m_ulLastIMUReset = now;
+            }
+
+        } else {
+            // We have never gotten IMU data, probably not supported on this device
+        }
+    }
+
+    ctx->m_lastFullState = *packet;
+}
+
+static bool HIDAPI_DriverSwitch_UpdateDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverSwitch_Context *ctx = (SDL_DriverSwitch_Context *)device->context;
+    SDL_Joystick *joystick = NULL;
+    int size;
+    int packet_count = 0;
+    Uint64 now = SDL_GetTicks();
+
+    if (device->num_joysticks > 0) {
+        joystick = SDL_GetJoystickFromID(device->joysticks[0]);
+    }
+
+    while ((size = ReadInput(ctx)) > 0) {
+#ifdef DEBUG_SWITCH_PROTOCOL
+        HIDAPI_DumpPacket("Nintendo Switch packet: size = %d", ctx->m_rgucReadBuffer, size);
+#endif
+        ++packet_count;
+        ctx->m_ulLastInput = now;
+
+        if (!joystick) {
+            continue;
+        }
+
+        if (ctx->m_bInputOnly) {
+            HandleInputOnlyControllerState(joystick, ctx, (SwitchInputOnlyControllerStatePacket_t *)&ctx->m_rgucReadBuffer[0]);
+        } else {
+            if (ctx->m_rgucReadBuffer[0] == k_eSwitchInputReportIDs_SubcommandReply) {
+                continue;
+            }
+
+            ctx->m_nCurrentInputMode = ctx->m_rgucReadBuffer[0];
+
+            switch (ctx->m_rgucReadBuffer[0]) {
+            case k_eSwitchInputReportIDs_SimpleControllerState:
+                HandleSimpleControllerState(joystick, ctx, (SwitchSimpleStatePacket_t *)&ctx->m_rgucReadBuffer[1]);
+                break;
+            case k_eSwitchInputReportIDs_FullControllerState:
+            case k_eSwitchInputReportIDs_FullControllerAndMcuState:
+                // This is the extended report, we can enable sensors now in auto mode
+                UpdateEnhancedModeOnEnhancedReport(ctx);
+
+                HandleFullControllerState(joystick, ctx, (SwitchStatePacket_t *)&ctx->m_rgucReadBuffer[1]);
+                break;
+            default:
+                break;
+            }
+        }
+    }
+
+    if (joystick) {
+        if (packet_count == 0) {
+            if (!ctx->m_bInputOnly && !device->is_bluetooth &&
+                ctx->device->product_id != USB_PRODUCT_NINTENDO_SWITCH_JOYCON_GRIP) {
+                const int INPUT_WAIT_TIMEOUT_MS = 100;
+                if (now >= (ctx->m_ulLastInput + INPUT_WAIT_TIMEOUT_MS)) {
+                    // Steam may have put the controller back into non-reporting mode
+                    bool wasSyncWrite = ctx->m_bSyncWrite;
+
+                    ctx->m_bSyncWrite = true;
+                    WriteProprietary(ctx, k_eSwitchProprietaryCommandIDs_ForceUSB, NULL, 0, false);
+                    ctx->m_bSyncWrite = wasSyncWrite;
+                }
+            } else if (device->is_bluetooth &&
+                       ctx->m_nCurrentInputMode != k_eSwitchInputReportIDs_SimpleControllerState) {
+                const int INPUT_WAIT_TIMEOUT_MS = 3000;
+                if (now >= (ctx->m_ulLastInput + INPUT_WAIT_TIMEOUT_MS)) {
+                    // Bluetooth may have disconnected, try reopening the controller
+                    size = -1;
+                }
+            }
+        }
+
+        if (ctx->m_bRumblePending || ctx->m_bRumbleZeroPending) {
+            HIDAPI_DriverSwitch_SendPendingRumble(ctx);
+        } else if (ctx->m_bRumbleActive &&
+                   now >= (ctx->m_ulRumbleSent + RUMBLE_REFRESH_FREQUENCY_MS)) {
+#ifdef DEBUG_RUMBLE
+            SDL_Log("Sent continuing rumble, %d ms after previous rumble", now - ctx->m_ulRumbleSent);
+#endif
+            WriteRumble(ctx);
+        }
+    }
+
+    // Reconnect the Bluetooth device once the USB device is gone
+    if (device->num_joysticks == 0 && device->is_bluetooth && packet_count > 0 &&
+        !device->parent &&
+        !HIDAPI_HasConnectedUSBDevice(device->serial)) {
+        HIDAPI_JoystickConnected(device, NULL);
+    }
+
+    if (size < 0 && device->num_joysticks > 0) {
+        // Read error, device is disconnected
+        HIDAPI_JoystickDisconnected(device, device->joysticks[0]);
+    }
+    return (size >= 0);
+}
+
+static void HIDAPI_DriverSwitch_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverSwitch_Context *ctx = (SDL_DriverSwitch_Context *)device->context;
+
+    if (!ctx->m_bInputOnly) {
+        // Restore simple input mode for other applications
+        if (!ctx->m_nInitialInputMode ||
+            ctx->m_nInitialInputMode == k_eSwitchInputReportIDs_SimpleControllerState) {
+            SetInputMode(ctx, k_eSwitchInputReportIDs_SimpleControllerState);
+        }
+    }
+
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_ENHANCED_REPORTS,
+                        SDL_EnhancedReportsChanged, ctx);
+
+    if (ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_JoyConLeft ||
+        ctx->m_eControllerType == k_eSwitchDeviceInfoControllerType_JoyConRight) {
+        SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_JOYCON_HOME_LED,
+                            SDL_HomeLEDHintChanged, ctx);
+    } else {
+        SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_SWITCH_HOME_LED,
+                            SDL_HomeLEDHintChanged, ctx);
+    }
+
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_SWITCH_PLAYER_LED,
+                        SDL_PlayerLEDHintChanged, ctx);
+
+    ctx->joystick = NULL;
+
+    ctx->m_bReportSensors = false;
+    ctx->m_bEnhancedMode = false;
+    ctx->m_bEnhancedModeAvailable = false;
+}
+
+static void HIDAPI_DriverSwitch_FreeDevice(SDL_HIDAPI_Device *device)
+{
+}
+
+SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverNintendoClassic = {
+    SDL_HINT_JOYSTICK_HIDAPI_NINTENDO_CLASSIC,
+    true,
+    HIDAPI_DriverNintendoClassic_RegisterHints,
+    HIDAPI_DriverNintendoClassic_UnregisterHints,
+    HIDAPI_DriverNintendoClassic_IsEnabled,
+    HIDAPI_DriverNintendoClassic_IsSupportedDevice,
+    HIDAPI_DriverSwitch_InitDevice,
+    HIDAPI_DriverSwitch_GetDevicePlayerIndex,
+    HIDAPI_DriverSwitch_SetDevicePlayerIndex,
+    HIDAPI_DriverSwitch_UpdateDevice,
+    HIDAPI_DriverSwitch_OpenJoystick,
+    HIDAPI_DriverSwitch_RumbleJoystick,
+    HIDAPI_DriverSwitch_RumbleJoystickTriggers,
+    HIDAPI_DriverSwitch_GetJoystickCapabilities,
+    HIDAPI_DriverSwitch_SetJoystickLED,
+    HIDAPI_DriverSwitch_SendJoystickEffect,
+    HIDAPI_DriverSwitch_SetJoystickSensorsEnabled,
+    HIDAPI_DriverSwitch_CloseJoystick,
+    HIDAPI_DriverSwitch_FreeDevice,
+};
+
+SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverJoyCons = {
+    SDL_HINT_JOYSTICK_HIDAPI_JOY_CONS,
+    true,
+    HIDAPI_DriverJoyCons_RegisterHints,
+    HIDAPI_DriverJoyCons_UnregisterHints,
+    HIDAPI_DriverJoyCons_IsEnabled,
+    HIDAPI_DriverJoyCons_IsSupportedDevice,
+    HIDAPI_DriverSwitch_InitDevice,
+    HIDAPI_DriverSwitch_GetDevicePlayerIndex,
+    HIDAPI_DriverSwitch_SetDevicePlayerIndex,
+    HIDAPI_DriverSwitch_UpdateDevice,
+    HIDAPI_DriverSwitch_OpenJoystick,
+    HIDAPI_DriverSwitch_RumbleJoystick,
+    HIDAPI_DriverSwitch_RumbleJoystickTriggers,
+    HIDAPI_DriverSwitch_GetJoystickCapabilities,
+    HIDAPI_DriverSwitch_SetJoystickLED,
+    HIDAPI_DriverSwitch_SendJoystickEffect,
+    HIDAPI_DriverSwitch_SetJoystickSensorsEnabled,
+    HIDAPI_DriverSwitch_CloseJoystick,
+    HIDAPI_DriverSwitch_FreeDevice,
+};
+
+SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverSwitch = {
+    SDL_HINT_JOYSTICK_HIDAPI_SWITCH,
+    true,
+    HIDAPI_DriverSwitch_RegisterHints,
+    HIDAPI_DriverSwitch_UnregisterHints,
+    HIDAPI_DriverSwitch_IsEnabled,
+    HIDAPI_DriverSwitch_IsSupportedDevice,
+    HIDAPI_DriverSwitch_InitDevice,
+    HIDAPI_DriverSwitch_GetDevicePlayerIndex,
+    HIDAPI_DriverSwitch_SetDevicePlayerIndex,
+    HIDAPI_DriverSwitch_UpdateDevice,
+    HIDAPI_DriverSwitch_OpenJoystick,
+    HIDAPI_DriverSwitch_RumbleJoystick,
+    HIDAPI_DriverSwitch_RumbleJoystickTriggers,
+    HIDAPI_DriverSwitch_GetJoystickCapabilities,
+    HIDAPI_DriverSwitch_SetJoystickLED,
+    HIDAPI_DriverSwitch_SendJoystickEffect,
+    HIDAPI_DriverSwitch_SetJoystickSensorsEnabled,
+    HIDAPI_DriverSwitch_CloseJoystick,
+    HIDAPI_DriverSwitch_FreeDevice,
+};
+
+#endif // SDL_JOYSTICK_HIDAPI_SWITCH
+
+#endif // SDL_JOYSTICK_HIDAPI
diff --git a/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_wii.c b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_wii.c
new file mode 100644
index 0000000..fb3e164
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_wii.c
@@ -0,0 +1,1617 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI
+
+#include "../../SDL_hints_c.h"
+#include "../SDL_sysjoystick.h"
+#include "SDL_hidapijoystick_c.h"
+#include "SDL_hidapi_rumble.h"
+#include "SDL_hidapi_nintendo.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI_WII
+
+// Define this if you want to log all packets from the controller
+// #define DEBUG_WII_PROTOCOL
+
+#define ENABLE_CONTINUOUS_REPORTING true
+
+#define INPUT_WAIT_TIMEOUT_MS      (3 * 1000)
+#define MOTION_PLUS_UPDATE_TIME_MS (8 * 1000)
+#define STATUS_UPDATE_TIME_MS      (15 * 60 * 1000)
+
+#define WII_EXTENSION_NONE            0x2E2E
+#define WII_EXTENSION_UNINITIALIZED   0xFFFF
+#define WII_EXTENSION_NUNCHUK         0x0000
+#define WII_EXTENSION_GAMEPAD         0x0101
+#define WII_EXTENSION_WIIUPRO         0x0120
+#define WII_EXTENSION_MOTIONPLUS_MASK 0xF0FF
+#define WII_EXTENSION_MOTIONPLUS_ID   0x0005
+
+#define WII_MOTIONPLUS_MODE_NONE     0x00
+#define WII_MOTIONPLUS_MODE_STANDARD 0x04
+#define WII_MOTIONPLUS_MODE_NUNCHUK  0x05
+#define WII_MOTIONPLUS_MODE_GAMEPAD  0x07
+
+typedef enum
+{
+    k_eWiiInputReportIDs_Status = 0x20,
+    k_eWiiInputReportIDs_ReadMemory = 0x21,
+    k_eWiiInputReportIDs_Acknowledge = 0x22,
+    k_eWiiInputReportIDs_ButtonData0 = 0x30,
+    k_eWiiInputReportIDs_ButtonData1 = 0x31,
+    k_eWiiInputReportIDs_ButtonData2 = 0x32,
+    k_eWiiInputReportIDs_ButtonData3 = 0x33,
+    k_eWiiInputReportIDs_ButtonData4 = 0x34,
+    k_eWiiInputReportIDs_ButtonData5 = 0x35,
+    k_eWiiInputReportIDs_ButtonData6 = 0x36,
+    k_eWiiInputReportIDs_ButtonData7 = 0x37,
+    k_eWiiInputReportIDs_ButtonDataD = 0x3D,
+    k_eWiiInputReportIDs_ButtonDataE = 0x3E,
+    k_eWiiInputReportIDs_ButtonDataF = 0x3F,
+} EWiiInputReportIDs;
+
+typedef enum
+{
+    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];
+    bool hasBaseButtons;
+    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;
+    bool m_bPlayerLights;
+    int m_nPlayerIndex;
+    bool m_bRumbleActive;
+    bool m_bMotionPlusPresent;
+    Uint8 m_ucMotionPlusMode;
+    bool m_bReportSensors;
+    Uint8 m_rgucReadBuffer[k_unWiiPacketDataLength];
+    Uint64 m_ulLastInput;
+    Uint64 m_ulLastStatus;
+    Uint64 m_ulNextMotionPlusCheck;
+    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_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_WII, callback, userdata);
+}
+
+static 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, false);
+#else
+    return SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_WII,
+                              SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI,
+                                                 SDL_HIDAPI_DEFAULT));
+#endif
+}
+
+static 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 true;
+    }
+    return 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_GetAtomicInt(&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 bool WriteOutput(SDL_DriverWii_Context *ctx, const Uint8 *data, int size, 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()) {
+            return false;
+        }
+        return SDL_HIDAPI_SendRumbleAndUnlock(ctx->device, data, size) >= 0;
+    }
+}
+
+static bool ReadInputSync(SDL_DriverWii_Context *ctx, EWiiInputReportIDs expectedID, 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 true;
+            }
+        } else {
+            if (SDL_GetTicks() >= endTicks) {
+                break;
+            }
+            SDL_Delay(1);
+        }
+    }
+    SDL_SetError("Read timed out");
+    return false;
+}
+
+static bool IsWriteMemoryResponse(const Uint8 *data)
+{
+    return data[3] == k_eWiiOutputReportIDs_WriteMemory;
+}
+
+static bool WriteRegister(SDL_DriverWii_Context *ctx, Uint32 address, const Uint8 *data, int size, bool sync)
+{
+    Uint8 writeRequest[k_unWiiPacketDataLength];
+
+    SDL_zeroa(writeRequest);
+    writeRequest[0] = k_eWiiOutputReportIDs_WriteMemory;
+    writeRequest[1] = (Uint8)(0x04 | (Uint8)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 false;
+    }
+    if (sync) {
+        // Wait for response
+        if (!ReadInputSync(ctx, k_eWiiInputReportIDs_Acknowledge, IsWriteMemoryResponse)) {
+            return false;
+        }
+        if (ctx->m_rgucReadBuffer[4]) {
+            SDL_SetError("Write memory failed: %u", ctx->m_rgucReadBuffer[4]);
+            return false;
+        }
+    }
+    return true;
+}
+
+static bool ReadRegister(SDL_DriverWii_Context *ctx, Uint32 address, int size, bool sync)
+{
+    Uint8 readRequest[7];
+
+    readRequest[0] = k_eWiiOutputReportIDs_ReadMemory;
+    readRequest[1] = (Uint8)(0x04 | (Uint8)ctx->m_bRumbleActive);
+    readRequest[2] = (address >> 16) & 0xff;
+    readRequest[3] = (address >> 8) & 0xff;
+    readRequest[4] = address & 0xff;
+    readRequest[5] = (size >> 8) & 0xff;
+    readRequest[6] = size & 0xff;
+
+    SDL_assert(size > 0 && size <= 0xffff);
+
+    if (!WriteOutput(ctx, readRequest, sizeof(readRequest), sync)) {
+        return false;
+    }
+    if (sync) {
+        SDL_assert(size <= 16); // Only waiting for one packet is supported right now
+        // Wait for response
+        if (!ReadInputSync(ctx, k_eWiiInputReportIDs_ReadMemory, NULL)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+static bool SendExtensionIdentify(SDL_DriverWii_Context *ctx, bool sync)
+{
+    return ReadRegister(ctx, 0xA400FE, 2, sync);
+}
+
+static bool ParseExtensionIdentifyResponse(SDL_DriverWii_Context *ctx, Uint16 *extension)
+{
+    int i;
+
+    if (ctx->m_rgucReadBuffer[0] != k_eWiiInputReportIDs_ReadMemory) {
+        SDL_SetError("Unexpected extension response type");
+        return false;
+    }
+
+    if (ctx->m_rgucReadBuffer[4] != 0x00 || ctx->m_rgucReadBuffer[5] != 0xFE) {
+        SDL_SetError("Unexpected extension response address");
+        return false;
+    }
+
+    if (ctx->m_rgucReadBuffer[3] != 0x10) {
+        Uint8 error = (ctx->m_rgucReadBuffer[3] & 0xF);
+
+        if (error == 7) {
+            // The extension memory isn't mapped
+            *extension = WII_EXTENSION_NONE;
+            return true;
+        }
+
+        if (error) {
+            SDL_SetError("Failed to read extension type: %u", error);
+        } else {
+            SDL_SetError("Unexpected read length when reading extension type: %d", (ctx->m_rgucReadBuffer[3] >> 4) + 1);
+        }
+        return false;
+    }
+
+    *extension = 0;
+    for (i = 6; i < 8; i++) {
+        *extension = *extension << 8 | ctx->m_rgucReadBuffer[i];
+    }
+    return true;
+}
+
+static EWiiExtensionControllerType GetExtensionType(Uint16 extension_id)
+{
+    switch (extension_id) {
+    case WII_EXTENSION_NONE:
+        return k_eWiiExtensionControllerType_None;
+    case WII_EXTENSION_NUNCHUK:
+        return k_eWiiExtensionControllerType_Nunchuk;
+    case WII_EXTENSION_GAMEPAD:
+        return k_eWiiExtensionControllerType_Gamepad;
+    case WII_EXTENSION_WIIUPRO:
+        return k_eWiiExtensionControllerType_WiiUPro;
+    default:
+        return k_eWiiExtensionControllerType_Unknown;
+    }
+}
+
+static bool SendExtensionReset(SDL_DriverWii_Context *ctx, bool sync)
+{
+    bool result = true;
+    {
+        Uint8 data = 0x55;
+        result = result && WriteRegister(ctx, 0xA400F0, &data, sizeof(data), sync);
+    }
+    // This write will fail if there is no extension connected, that's fine
+    {
+        Uint8 data = 0x00;
+        (void)WriteRegister(ctx, 0xA400FB, &data, sizeof(data), sync);
+    }
+    return result;
+}
+
+static bool GetMotionPlusState(SDL_DriverWii_Context *ctx, bool *connected, Uint8 *mode)
+{
+    Uint16 extension;
+
+    if (connected) {
+        *connected = false;
+    }
+    if (mode) {
+        *mode = 0;
+    }
+
+    if (ctx->m_eExtensionControllerType == k_eWiiExtensionControllerType_WiiUPro) {
+        // The Wii U Pro controller never has the Motion Plus extension
+        return true;
+    }
+
+    if (SendExtensionIdentify(ctx, true) &&
+        ParseExtensionIdentifyResponse(ctx, &extension)) {
+        if ((extension & WII_EXTENSION_MOTIONPLUS_MASK) == WII_EXTENSION_MOTIONPLUS_ID) {
+            // Motion Plus is currently active
+            if (connected) {
+                *connected = true;
+            }
+            if (mode) {
+                *mode = (extension >> 8);
+            }
+            return true;
+        }
+    }
+
+    if (ReadRegister(ctx, 0xA600FE, 2, true) &&
+        ParseExtensionIdentifyResponse(ctx, &extension)) {
+        if ((extension & WII_EXTENSION_MOTIONPLUS_MASK) == WII_EXTENSION_MOTIONPLUS_ID) {
+            // Motion Plus is currently connected
+            if (connected) {
+                *connected = true;
+            }
+        }
+        return true;
+    }
+
+    // Failed to read the register or parse the response
+    return false;
+}
+
+static bool NeedsPeriodicMotionPlusCheck(SDL_DriverWii_Context *ctx, bool status_update)
+{
+    if (ctx->m_eExtensionControllerType == k_eWiiExtensionControllerType_WiiUPro) {
+        // The Wii U Pro controller never has the Motion Plus extension
+        return false;
+    }
+
+    if (ctx->m_ucMotionPlusMode != WII_MOTIONPLUS_MODE_NONE && !status_update) {
+        // We'll get a status update when Motion Plus is disconnected
+        return false;
+    }
+
+    return true;
+}
+
+static void SchedulePeriodicMotionPlusCheck(SDL_DriverWii_Context *ctx)
+{
+    ctx->m_ulNextMotionPlusCheck = SDL_GetTicks() + MOTION_PLUS_UPDATE_TIME_MS;
+}
+
+static void CheckMotionPlusConnection(SDL_DriverWii_Context *ctx)
+{
+    SendExtensionIdentify(ctx, false);
+
+    ctx->m_eCommState = k_eWiiCommunicationState_CheckMotionPlusStage1;
+}
+
+static void ActivateMotionPlusWithMode(SDL_DriverWii_Context *ctx, Uint8 mode)
+{
+#ifdef SDL_PLATFORM_LINUX
+    /* Linux drivers maintain a lot of state around the Motion Plus
+     * extension, so don't mess with it here.
+     */
+#else
+    WriteRegister(ctx, 0xA600FE, &mode, sizeof(mode), true);
+
+    ctx->m_ucMotionPlusMode = mode;
+#endif // LINUX
+}
+
+static void ActivateMotionPlus(SDL_DriverWii_Context *ctx)
+{
+    Uint8 mode = WII_MOTIONPLUS_MODE_STANDARD;
+
+    // Pick the pass-through mode based on the connected controller
+    if (ctx->m_eExtensionControllerType == k_eWiiExtensionControllerType_Nunchuk) {
+        mode = WII_MOTIONPLUS_MODE_NUNCHUK;
+    } else if (ctx->m_eExtensionControllerType == k_eWiiExtensionControllerType_Gamepad) {
+        mode = WII_MOTIONPLUS_MODE_GAMEPAD;
+    }
+    ActivateMotionPlusWithMode(ctx, mode);
+}
+
+static void DeactivateMotionPlus(SDL_DriverWii_Context *ctx)
+{
+    Uint8 data = 0x55;
+    WriteRegister(ctx, 0xA400F0, &data, sizeof(data), true);
+
+    // Wait for the deactivation status message
+    ReadInputSync(ctx, k_eWiiInputReportIDs_Status, NULL);
+
+    ctx->m_ucMotionPlusMode = WII_MOTIONPLUS_MODE_NONE;
+}
+
+static void UpdatePowerLevelWii(SDL_Joystick *joystick, Uint8 batteryLevelByte)
+{
+    int percent;
+    if (batteryLevelByte > 178) {
+        percent = 100;
+    } else if (batteryLevelByte > 51) {
+        percent = 70;
+    } else if (batteryLevelByte > 13) {
+        percent = 20;
+    } else {
+        percent = 5;
+    }
+    SDL_SendJoystickPowerInfo(joystick, SDL_POWERSTATE_ON_BATTERY, percent);
+}
+
+static void UpdatePowerLevelWiiU(SDL_Joystick *joystick, Uint8 extensionBatteryByte)
+{
+    bool charging = !(extensionBatteryByte & 0x08);
+    bool pluggedIn = !(extensionBatteryByte & 0x04);
+    Uint8 batteryLevel = extensionBatteryByte >> 4;
+
+    if (pluggedIn) {
+        joystick->connection_state = SDL_JOYSTICK_CONNECTION_WIRED;
+    } else {
+        joystick->connection_state = SDL_JOYSTICK_CONNECTION_WIRELESS;
+    }
+
+    /* Not sure if all Wii U Pro controllers act like this, but on mine
+     * 4, 3, and 2 are held for about 20 hours each
+     * 1 is held for about 6 hours
+     * 0 is held for about 2 hours
+     * No value above 4 has been observed.
+     */
+    SDL_PowerState state;
+    int percent;
+    if (charging) {
+        state = SDL_POWERSTATE_CHARGING;
+    } else if (pluggedIn) {
+        state = SDL_POWERSTATE_CHARGED;
+    } else {
+        state = SDL_POWERSTATE_ON_BATTERY;
+    }
+    if (batteryLevel >= 4) {
+        percent = 100;
+    } else if (batteryLevel == 3) {
+        percent = 70;
+    } else if (batteryLevel == 2) {
+        percent = 40;
+    } else if (batteryLevel == 1) {
+        percent = 10;
+    } else {
+        percent = 3;
+    }
+    SDL_SendJoystickPowerInfo(joystick, state, percent);
+}
+
+static EWiiInputReportIDs GetButtonPacketType(SDL_DriverWii_Context *ctx)
+{
+    switch (ctx->m_eExtensionControllerType) {
+    case k_eWiiExtensionControllerType_WiiUPro:
+        return k_eWiiInputReportIDs_ButtonDataD;
+    case k_eWiiExtensionControllerType_Nunchuk:
+    case k_eWiiExtensionControllerType_Gamepad:
+        if (ctx->m_bReportSensors) {
+            return k_eWiiInputReportIDs_ButtonData5;
+        } else {
+            return k_eWiiInputReportIDs_ButtonData2;
+        }
+    default:
+        if (ctx->m_bReportSensors) {
+            return k_eWiiInputReportIDs_ButtonData5;
+        } else {
+            return k_eWiiInputReportIDs_ButtonData0;
+        }
+    }
+}
+
+static bool RequestButtonPacketType(SDL_DriverWii_Context *ctx, EWiiInputReportIDs type)
+{
+    Uint8 data[3];
+    Uint8 tt = (Uint8)ctx->m_bRumbleActive;
+
+    // Continuous reporting off, tt & 4 == 0
+    if (ENABLE_CONTINUOUS_REPORTING) {
+        tt |= 4;
+    }
+
+    data[0] = k_eWiiOutputReportIDs_DataReportingMode;
+    data[1] = tt;
+    data[2] = type;
+    return WriteOutput(ctx, data, sizeof(data), false);
+}
+
+static void ResetButtonPacketType(SDL_DriverWii_Context *ctx)
+{
+    RequestButtonPacketType(ctx, GetButtonPacketType(ctx));
+}
+
+static void InitStickCalibrationData(SDL_DriverWii_Context *ctx)
+{
+    int i;
+    switch (ctx->m_eExtensionControllerType) {
+    case k_eWiiExtensionControllerType_WiiUPro:
+        for (i = 0; i < 4; i++) {
+            ctx->m_StickCalibrationData[i].min = 1000;
+            ctx->m_StickCalibrationData[i].max = 3000;
+            ctx->m_StickCalibrationData[i].center = 0;
+            ctx->m_StickCalibrationData[i].deadzone = 100;
+        }
+        break;
+    case k_eWiiExtensionControllerType_Gamepad:
+        for (i = 0; i < 4; i++) {
+            ctx->m_StickCalibrationData[i].min = i < 2 ? 9 : 5;
+            ctx->m_StickCalibrationData[i].max = i < 2 ? 54 : 26;
+            ctx->m_StickCalibrationData[i].center = 0;
+            ctx->m_StickCalibrationData[i].deadzone = i < 2 ? 4 : 2;
+        }
+        break;
+    case k_eWiiExtensionControllerType_Nunchuk:
+        for (i = 0; i < 2; i++) {
+            ctx->m_StickCalibrationData[i].min = 40;
+            ctx->m_StickCalibrationData[i].max = 215;
+            ctx->m_StickCalibrationData[i].center = 0;
+            ctx->m_StickCalibrationData[i].deadzone = 10;
+        }
+        break;
+    default:
+        break;
+    }
+}
+
+static void InitializeExtension(SDL_DriverWii_Context *ctx)
+{
+    SendExtensionReset(ctx, true);
+    InitStickCalibrationData(ctx);
+    ResetButtonPacketType(ctx);
+}
+
+static void UpdateSlotLED(SDL_DriverWii_Context *ctx)
+{
+    Uint8 leds;
+    Uint8 data[2];
+
+    // The lowest bit needs to have the rumble status
+    leds = (Uint8)ctx->m_bRumbleActive;
+
+    if (ctx->m_bPlayerLights) {
+        // Use the same LED codes as Smash 8-player for 5-7
+        if (ctx->m_nPlayerIndex == 0 || ctx->m_nPlayerIndex > 3) {
+            leds |= k_eWiiPlayerLEDs_P1;
+        }
+        if (ctx->m_nPlayerIndex == 1 || ctx->m_nPlayerIndex == 4) {
+            leds |= k_eWiiPlayerLEDs_P2;
+        }
+        if (ctx->m_nPlayerIndex == 2 || ctx->m_nPlayerIndex == 5) {
+            leds |= k_eWiiPlayerLEDs_P3;
+        }
+        if (ctx->m_nPlayerIndex == 3 || ctx->m_nPlayerIndex == 6) {
+            leds |= k_eWiiPlayerLEDs_P4;
+        }
+        // Turn on all lights for other player indexes
+        if (ctx->m_nPlayerIndex < 0 || ctx->m_nPlayerIndex > 6) {
+            leds |= k_eWiiPlayerLEDs_P1 | k_eWiiPlayerLEDs_P2 | k_eWiiPlayerLEDs_P3 | k_eWiiPlayerLEDs_P4;
+        }
+    }
+
+    data[0] = k_eWiiOutputReportIDs_LEDs;
+    data[1] = leds;
+    WriteOutput(ctx, data, sizeof(data), false);
+}
+
+static void SDLCALL SDL_PlayerLEDHintChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
+{
+    SDL_DriverWii_Context *ctx = (SDL_DriverWii_Context *)userdata;
+    bool bPlayerLights = SDL_GetStringBoolean(hint, true);
+
+    if (bPlayerLights != ctx->m_bPlayerLights) {
+        ctx->m_bPlayerLights = bPlayerLights;
+
+        UpdateSlotLED(ctx);
+    }
+}
+
+static EWiiExtensionControllerType ReadExtensionControllerType(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverWii_Context *ctx = (SDL_DriverWii_Context *)device->context;
+    EWiiExtensionControllerType eExtensionControllerType = k_eWiiExtensionControllerType_Unknown;
+    const int MAX_ATTEMPTS = 20;
+    int attempts = 0;
+
+    // Create enough of a context to read the controller type from the device
+    for (attempts = 0; attempts < MAX_ATTEMPTS; ++attempts) {
+        Uint16 extension;
+        if (SendExtensionIdentify(ctx, true) &&
+            ParseExtensionIdentifyResponse(ctx, &extension)) {
+            Uint8 motion_plus_mode = 0;
+            if ((extension & WII_EXTENSION_MOTIONPLUS_MASK) == WII_EXTENSION_MOTIONPLUS_ID) {
+                motion_plus_mode = (Uint8)(extension >> 8);
+            }
+            if (motion_plus_mode || extension == WII_EXTENSION_UNINITIALIZED) {
+                SendExtensionReset(ctx, true);
+                if (SendExtensionIdentify(ctx, true)) {
+                    ParseExtensionIdentifyResponse(ctx, &extension);
+                }
+            }
+
+            eExtensionControllerType = GetExtensionType(extension);
+
+            // Reset the Motion Plus controller if needed
+            if (motion_plus_mode) {
+                ActivateMotionPlusWithMode(ctx, motion_plus_mode);
+            }
+            break;
+        }
+    }
+    return eExtensionControllerType;
+}
+
+static void UpdateDeviceIdentity(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverWii_Context *ctx = (SDL_DriverWii_Context *)device->context;
+
+    switch (ctx->m_eExtensionControllerType) {
+    case k_eWiiExtensionControllerType_None:
+        HIDAPI_SetDeviceName(device, "Nintendo Wii Remote");
+        break;
+    case k_eWiiExtensionControllerType_Nunchuk:
+        HIDAPI_SetDeviceName(device, "Nintendo Wii Remote with Nunchuk");
+        break;
+    case k_eWiiExtensionControllerType_Gamepad:
+        HIDAPI_SetDeviceName(device, "Nintendo Wii Remote with Classic Controller");
+        break;
+    case k_eWiiExtensionControllerType_WiiUPro:
+        HIDAPI_SetDeviceName(device, "Nintendo Wii U Pro Controller");
+        break;
+    default:
+        HIDAPI_SetDeviceName(device, "Nintendo Wii Remote with Unknown Extension");
+        break;
+    }
+    device->guid.data[15] = ctx->m_eExtensionControllerType;
+}
+
+static bool HIDAPI_DriverWii_InitDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverWii_Context *ctx;
+
+    ctx = (SDL_DriverWii_Context *)SDL_calloc(1, sizeof(*ctx));
+    if (!ctx) {
+        return false;
+    }
+    ctx->device = device;
+    device->context = ctx;
+
+    if (device->vendor_id == USB_VENDOR_NINTENDO) {
+        ctx->m_eExtensionControllerType = ReadExtensionControllerType(device);
+
+        UpdateDeviceIdentity(device);
+    }
+    return HIDAPI_JoystickConnected(device, NULL);
+}
+
+static int HIDAPI_DriverWii_GetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id)
+{
+    return -1;
+}
+
+static void HIDAPI_DriverWii_SetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id, int player_index)
+{
+    SDL_DriverWii_Context *ctx = (SDL_DriverWii_Context *)device->context;
+
+    if (!ctx->joystick) {
+        return;
+    }
+
+    ctx->m_nPlayerIndex = player_index;
+
+    UpdateSlotLED(ctx);
+}
+
+static bool HIDAPI_DriverWii_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverWii_Context *ctx = (SDL_DriverWii_Context *)device->context;
+
+    SDL_AssertJoysticksLocked();
+
+    ctx->joystick = joystick;
+
+    InitializeExtension(ctx);
+
+    GetMotionPlusState(ctx, &ctx->m_bMotionPlusPresent, &ctx->m_ucMotionPlusMode);
+
+    if (NeedsPeriodicMotionPlusCheck(ctx, false)) {
+        SchedulePeriodicMotionPlusCheck(ctx);
+    }
+
+    if (ctx->m_eExtensionControllerType == k_eWiiExtensionControllerType_None ||
+        ctx->m_eExtensionControllerType == k_eWiiExtensionControllerType_Nunchuk) {
+        SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_ACCEL, 100.0f);
+        if (ctx->m_eExtensionControllerType == k_eWiiExtensionControllerType_Nunchuk) {
+            SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_ACCEL_L, 100.0f);
+        }
+
+        if (ctx->m_bMotionPlusPresent) {
+            SDL_PrivateJoystickAddSensor(joystick, SDL_SENSOR_GYRO, 100.0f);
+        }
+    }
+
+    // Initialize player index (needed for setting LEDs)
+    ctx->m_nPlayerIndex = SDL_GetJoystickPlayerIndex(joystick);
+    ctx->m_bPlayerLights = SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_WII_PLAYER_LED, true);
+    UpdateSlotLED(ctx);
+
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_WII_PLAYER_LED,
+                        SDL_PlayerLEDHintChanged, ctx);
+
+    // Initialize the joystick capabilities
+    if (ctx->m_eExtensionControllerType == k_eWiiExtensionControllerType_WiiUPro) {
+        joystick->nbuttons = 15;
+    } else {
+        // Maximum is Classic Controller + Wiimote
+        joystick->nbuttons = k_eWiiButtons_Max;
+    }
+    joystick->naxes = SDL_GAMEPAD_AXIS_COUNT;
+
+    ctx->m_ulLastInput = SDL_GetTicks();
+
+    return true;
+}
+
+static bool HIDAPI_DriverWii_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+    SDL_DriverWii_Context *ctx = (SDL_DriverWii_Context *)device->context;
+    bool active = (low_frequency_rumble || high_frequency_rumble);
+
+    if (active != ctx->m_bRumbleActive) {
+        Uint8 data[2];
+
+        data[0] = k_eWiiOutputReportIDs_Rumble;
+        data[1] = (Uint8)active;
+        WriteOutput(ctx, data, sizeof(data), false);
+
+        ctx->m_bRumbleActive = active;
+    }
+    return true;
+}
+
+static bool HIDAPI_DriverWii_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
+{
+    return SDL_Unsupported();
+}
+
+static Uint32 HIDAPI_DriverWii_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    return SDL_JOYSTICK_CAP_RUMBLE;
+}
+
+static bool HIDAPI_DriverWii_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverWii_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *data, int size)
+{
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverWii_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, bool enabled)
+{
+    SDL_DriverWii_Context *ctx = (SDL_DriverWii_Context *)device->context;
+
+    if (enabled != ctx->m_bReportSensors) {
+        ctx->m_bReportSensors = enabled;
+
+        if (ctx->m_bMotionPlusPresent) {
+            if (enabled) {
+                ActivateMotionPlus(ctx);
+            } else {
+                DeactivateMotionPlus(ctx);
+            }
+        }
+
+        ResetButtonPacketType(ctx);
+    }
+    return true;
+}
+
+static void PostStickCalibrated(Uint64 timestamp, SDL_Joystick *joystick, StickCalibrationData *calibration, Uint8 axis, Uint16 data)
+{
+    Sint16 value = 0;
+    if (!calibration->center) {
+        // Center on first read
+        calibration->center = data;
+        return;
+    }
+    if (data < calibration->min) {
+        calibration->min = data;
+    }
+    if (data > calibration->max) {
+        calibration->max = data;
+    }
+    if (data < calibration->center - calibration->deadzone) {
+        Uint16 zero = calibration->center - calibration->deadzone;
+        Uint16 range = zero - calibration->min;
+        Uint16 distance = zero - data;
+        float fvalue = (float)distance / (float)range;
+        value = (Sint16)(fvalue * SDL_JOYSTICK_AXIS_MIN);
+    } else if (data > calibration->center + calibration->deadzone) {
+        Uint16 zero = calibration->center + calibration->deadzone;
+        Uint16 range = calibration->max - zero;
+        Uint16 distance = data - zero;
+        float fvalue = (float)distance / (float)range;
+        value = (Sint16)(fvalue * SDL_JOYSTICK_AXIS_MAX);
+    }
+    if (axis == SDL_GAMEPAD_AXIS_LEFTY || axis == SDL_GAMEPAD_AXIS_RIGHTY) {
+        if (value) {
+            value = ~value;
+        }
+    }
+    SDL_SendJoystickAxis(timestamp, joystick, axis, value);
+}
+
+/* Send button data to SDL
+ *`defs` is a mapping for each bit to which button it represents.  0xFF indicates an unused bit
+ *`data` is the button data from the controller
+ *`size` is the number of bytes in `data` and the number of arrays of 8 mappings in `defs`
+ *`on` is the joystick value to be sent if a bit is on
+ *`off` is the joystick value to be sent if a bit is off
+ */
+static void PostPackedButtonData(Uint64 timestamp, SDL_Joystick *joystick, const Uint8 defs[][8], const Uint8 *data, int size, bool on, bool off)
+{
+    int i, j;
+
+    for (i = 0; i < size; i++) {
+        for (j = 0; j < 8; j++) {
+            Uint8 button = defs[i][j];
+            if (button != 0xFF) {
+                bool down = (data[i] >> j) & 1 ? on : off;
+                SDL_SendJoystickButton(timestamp, joystick, button, down);
+            }
+        }
+    }
+}
+
+static const Uint8 GAMEPAD_BUTTON_DEFS[3][8] = {
+    {
+        0xFF /* Unused */,
+        SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER,
+        SDL_GAMEPAD_BUTTON_START,
+        SDL_GAMEPAD_BUTTON_GUIDE,
+        SDL_GAMEPAD_BUTTON_BACK,
+        SDL_GAMEPAD_BUTTON_LEFT_SHOULDER,
+        SDL_GAMEPAD_BUTTON_DPAD_DOWN,
+        SDL_GAMEPAD_BUTTON_DPAD_RIGHT,
+    },
+    {
+        SDL_GAMEPAD_BUTTON_DPAD_UP,
+        SDL_GAMEPAD_BUTTON_DPAD_LEFT,
+        0xFF /* ZR */,
+        SDL_GAMEPAD_BUTTON_NORTH,
+        SDL_GAMEPAD_BUTTON_EAST,
+        SDL_GAMEPAD_BUTTON_WEST,
+        SDL_GAMEPAD_BUTTON_SOUTH,
+        0xFF /*ZL*/,
+    },
+    {
+        SDL_GAMEPAD_BUTTON_RIGHT_STICK,
+        SDL_GAMEPAD_BUTTON_LEFT_STICK,
+        0xFF /* Charging */,
+        0xFF /* Plugged In */,
+        0xFF /* Unused */,
+        0xFF /* Unused */,
+        0xFF /* Unused */,
+        0xFF /* Unused */,
+    }
+};
+
+static const Uint8 MP_GAMEPAD_BUTTON_DEFS[3][8] = {
+    {
+        0xFF /* Unused */,
+        SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER,
+        SDL_GAMEPAD_BUTTON_START,
+        SDL_GAMEPAD_BUTTON_GUIDE,
+        SDL_GAMEPAD_BUTTON_BACK,
+        SDL_GAMEPAD_BUTTON_LEFT_SHOULDER,
+        SDL_GAMEPAD_BUTTON_DPAD_DOWN,
+        SDL_GAMEPAD_BUTTON_DPAD_RIGHT,
+    },
+    {
+        0xFF /* Motion Plus data */,
+        0xFF /* Motion Plus data */,
+        0xFF /* ZR */,
+        SDL_GAMEPAD_BUTTON_NORTH,
+        SDL_GAMEPAD_BUTTON_EAST,
+        SDL_GAMEPAD_BUTTON_WEST,
+        SDL_GAMEPAD_BUTTON_SOUTH,
+        0xFF /*ZL*/,
+    },
+    {
+        SDL_GAMEPAD_BUTTON_RIGHT_STICK,
+        SDL_GAMEPAD_BUTTON_LEFT_STICK,
+        0xFF /* Charging */,
+        0xFF /* Plugged In */,
+        0xFF /* Unused */,
+        0xFF /* Unused */,
+        0xFF /* Unused */,
+        0xFF /* Unused */,
+    }
+};
+
+static const Uint8 MP_FIXUP_DPAD_BUTTON_DEFS[2][8] = {
+    {
+        SDL_GAMEPAD_BUTTON_DPAD_UP,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+    },
+    {
+        SDL_GAMEPAD_BUTTON_DPAD_LEFT,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+    }
+};
+
+static void HandleWiiUProButtonData(SDL_DriverWii_Context *ctx, SDL_Joystick *joystick, const WiiButtonData *data)
+{
+    static const Uint8 axes[] = { SDL_GAMEPAD_AXIS_LEFTX, SDL_GAMEPAD_AXIS_RIGHTX, SDL_GAMEPAD_AXIS_LEFTY, SDL_GAMEPAD_AXIS_RIGHTY };
+    const Uint8(*buttons)[8] = GAMEPAD_BUTTON_DEFS;
+    Uint8 zl, zr;
+    int i;
+
+    if (data->ucNExtensionBytes < 11) {
+        return;
+    }
+
+    // Buttons
+    PostPackedButtonData(ctx->timestamp, joystick, buttons, data->rgucExtension + 8, 3, false, true);
+
+    // Triggers
+    zl = data->rgucExtension[9] & 0x80;
+    zr = data->rgucExtension[9] & 0x04;
+    SDL_SendJoystickAxis(ctx->timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, zl ? SDL_JOYSTICK_AXIS_MIN : SDL_JOYSTICK_AXIS_MAX);
+    SDL_SendJoystickAxis(ctx->timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, zr ? SDL_JOYSTICK_AXIS_MIN : SDL_JOYSTICK_AXIS_MAX);
+
+    // Sticks
+    for (i = 0; i < 4; i++) {
+        Uint16 value = data->rgucExtension[i * 2] | (data->rgucExtension[i * 2 + 1] << 8);
+        PostStickCalibrated(ctx->timestamp, joystick, &ctx->m_StickCalibrationData[i], axes[i], value);
+    }
+
+    // Power
+    UpdatePowerLevelWiiU(joystick, data->rgucExtension[10]);
+}
+
+static void HandleGamepadControllerButtonData(SDL_DriverWii_Context *ctx, SDL_Joystick *joystick, const WiiButtonData *data)
+{
+    const Uint8(*buttons)[8] = (ctx->m_ucMotionPlusMode == WII_MOTIONPLUS_MODE_GAMEPAD) ? MP_GAMEPAD_BUTTON_DEFS : GAMEPAD_BUTTON_DEFS;
+    Uint8 lx, ly, rx, ry, zl, zr;
+
+    if (data->ucNExtensionBytes < 6) {
+        return;
+    }
+
+    // Buttons
+    PostPackedButtonData(ctx->timestamp, joystick, buttons, data->rgucExtension + 4, 2, false, true);
+    if (ctx->m_ucMotionPlusMode == WII_MOTIONPLUS_MODE_GAMEPAD) {
+        PostPackedButtonData(ctx->timestamp, joystick, MP_FIXUP_DPAD_BUTTON_DEFS, data->rgucExtension, 2, false, true);
+    }
+
+    // Triggers
+    zl = data->rgucExtension[5] & 0x80;
+    zr = data->rgucExtension[5] & 0x04;
+    SDL_SendJoystickAxis(ctx->timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, zl ? SDL_JOYSTICK_AXIS_MIN : SDL_JOYSTICK_AXIS_MAX);
+    SDL_SendJoystickAxis(ctx->timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, zr ? SDL_JOYSTICK_AXIS_MIN : SDL_JOYSTICK_AXIS_MAX);
+
+    // Sticks
+    if (ctx->m_ucMotionPlusMode == WII_MOTIONPLUS_MODE_GAMEPAD) {
+        lx = data->rgucExtension[0] & 0x3E;
+        ly = data->rgucExtension[1] & 0x3E;
+    } else {
+        lx = data->rgucExtension[0] & 0x3F;
+        ly = data->rgucExtension[1] & 0x3F;
+    }
+    rx = (data->rgucExtension[2] >> 7) | ((data->rgucExtension[1] >> 5) & 0x06) | ((data->rgucExtension[0] >> 3) & 0x18);
+    ry = data->rgucExtension[2] & 0x1F;
+    PostStickCalibrated(ctx->timestamp, joystick, &ctx->m_StickCalibrationData[0], SDL_GAMEPAD_AXIS_LEFTX, lx);
+    PostStickCalibrated(ctx->timestamp, joystick, &ctx->m_StickCalibrationData[1], SDL_GAMEPAD_AXIS_LEFTY, ly);
+    PostStickCalibrated(ctx->timestamp, joystick, &ctx->m_StickCalibrationData[2], SDL_GAMEPAD_AXIS_RIGHTX, rx);
+    PostStickCalibrated(ctx->timestamp, joystick, &ctx->m_StickCalibrationData[3], SDL_GAMEPAD_AXIS_RIGHTY, ry);
+}
+
+static void HandleWiiRemoteButtonData(SDL_DriverWii_Context *ctx, SDL_Joystick *joystick, const WiiButtonData *data)
+{
+    static const Uint8 buttons[2][8] = {
+        {
+            k_eWiiButtons_DPad_Left,
+            k_eWiiButtons_DPad_Right,
+            k_eWiiButtons_DPad_Down,
+            k_eWiiButtons_DPad_Up,
+            k_eWiiButtons_Plus,
+            0xFF /* Unused */,
+            0xFF /* Unused */,
+            0xFF /* Unused */,
+        },
+        {
+            k_eWiiButtons_Two,
+            k_eWiiButtons_One,
+            k_eWiiButtons_B,
+            k_eWiiButtons_A,
+            k_eWiiButtons_Minus,
+            0xFF /* Unused */,
+            0xFF /* Unused */,
+            k_eWiiButtons_Home,
+        }
+    };
+    if (data->hasBaseButtons) {
+        PostPackedButtonData(ctx->timestamp, joystick, buttons, data->rgucBaseButtons, 2, true, false);
+    }
+}
+
+static void HandleWiiRemoteButtonDataAsMainController(SDL_DriverWii_Context *ctx, SDL_Joystick *joystick, const WiiButtonData *data)
+{
+    /* Wii remote maps really badly to a normal controller
+     * Mapped 1 and 2 as X and Y
+     * Not going to attempt positional mapping
+     */
+    static const Uint8 buttons[2][8] = {
+        {
+            SDL_GAMEPAD_BUTTON_DPAD_LEFT,
+            SDL_GAMEPAD_BUTTON_DPAD_RIGHT,
+            SDL_GAMEPAD_BUTTON_DPAD_DOWN,
+            SDL_GAMEPAD_BUTTON_DPAD_UP,
+            SDL_GAMEPAD_BUTTON_START,
+            0xFF /* Unused */,
+            0xFF /* Unused */,
+            0xFF /* Unused */,
+        },
+        {
+            SDL_GAMEPAD_BUTTON_NORTH,
+            SDL_GAMEPAD_BUTTON_WEST,
+            SDL_GAMEPAD_BUTTON_SOUTH,
+            SDL_GAMEPAD_BUTTON_EAST,
+            SDL_GAMEPAD_BUTTON_BACK,
+            0xFF /* Unused */,
+            0xFF /* Unused */,
+            SDL_GAMEPAD_BUTTON_GUIDE,
+        }
+    };
+    if (data->hasBaseButtons) {
+        PostPackedButtonData(ctx->timestamp, joystick, buttons, data->rgucBaseButtons, 2, true, false);
+    }
+}
+
+static void HandleNunchuckButtonData(SDL_DriverWii_Context *ctx, SDL_Joystick *joystick, const WiiButtonData *data)
+{
+    bool c_button, z_button;
+
+    if (data->ucNExtensionBytes < 6) {
+        return;
+    }
+
+    if (ctx->m_ucMotionPlusMode == WII_MOTIONPLUS_MODE_NUNCHUK) {
+        c_button = (data->rgucExtension[5] & 0x08) ? false : true;
+        z_button = (data->rgucExtension[5] & 0x04) ? false : true;
+    } else {
+        c_button = (data->rgucExtension[5] & 0x02) ? false : true;
+        z_button = (data->rgucExtension[5] & 0x01) ? false : true;
+    }
+    SDL_SendJoystickButton(ctx->timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, c_button);
+    SDL_SendJoystickAxis(ctx->timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, z_button ? SDL_JOYSTICK_AXIS_MAX : SDL_JOYSTICK_AXIS_MIN);
+    PostStickCalibrated(ctx->timestamp, joystick, &ctx->m_StickCalibrationData[0], SDL_GAMEPAD_AXIS_LEFTX, data->rgucExtension[0]);
+    PostStickCalibrated(ctx->timestamp, joystick, &ctx->m_StickCalibrationData[1], SDL_GAMEPAD_AXIS_LEFTY, data->rgucExtension[1]);
+
+    if (ctx->m_bReportSensors) {
+        const float ACCEL_RES_PER_G = 200.0f;
+        Sint16 x, y, z;
+        float values[3];
+
+        x = (data->rgucExtension[2] << 2);
+        y = (data->rgucExtension[3] << 2);
+        z = (data->rgucExtension[4] << 2);
+
+        if (ctx->m_ucMotionPlusMode == WII_MOTIONPLUS_MODE_NUNCHUK) {
+            x |= ((data->rgucExtension[5] >> 3) & 0x02);
+            y |= ((data->rgucExtension[5] >> 4) & 0x02);
+            z &= ~0x04;
+            z |= ((data->rgucExtension[5] >> 5) & 0x06);
+        } else {
+            x |= ((data->rgucExtension[5] >> 2) & 0x03);
+            y |= ((data->rgucExtension[5] >> 4) & 0x03);
+            z |= ((data->rgucExtension[5] >> 6) & 0x03);
+        }
+
+        x -= 0x200;
+        y -= 0x200;
+        z -= 0x200;
+
+        values[0] = -((float)x / ACCEL_RES_PER_G) * SDL_STANDARD_GRAVITY;
+        values[1] = ((float)z / ACCEL_RES_PER_G) * SDL_STANDARD_GRAVITY;
+        values[2] = ((float)y / ACCEL_RES_PER_G) * SDL_STANDARD_GRAVITY;
+        SDL_SendJoystickSensor(ctx->timestamp, joystick, SDL_SENSOR_ACCEL_L, ctx->timestamp, values, 3);
+    }
+}
+
+static void HandleMotionPlusData(SDL_DriverWii_Context *ctx, SDL_Joystick *joystick, const WiiButtonData *data)
+{
+    if (ctx->m_bReportSensors) {
+        const float GYRO_RES_PER_DEGREE = 8192.0f;
+        int x, y, z;
+        float values[3];
+
+        x = (data->rgucExtension[0] | ((data->rgucExtension[3] << 6) & 0xFF00)) - 8192;
+        y = (data->rgucExtension[1] | ((data->rgucExtension[4] << 6) & 0xFF00)) - 8192;
+        z = (data->rgucExtension[2] | ((data->rgucExtension[5] << 6) & 0xFF00)) - 8192;
+
+        if (data->rgucExtension[3] & 0x02) {
+            // Slow rotation rate: 8192/440 units per deg/s
+            x *= 440;
+        } else {
+            // Fast rotation rate: 8192/2000 units per deg/s
+            x *= 2000;
+        }
+        if (data->rgucExtension[4] & 0x02) {
+            // Slow rotation rate: 8192/440 units per deg/s
+            y *= 440;
+        } else {
+            // Fast rotation rate: 8192/2000 units per deg/s
+            y *= 2000;
+        }
+        if (data->rgucExtension[3] & 0x01) {
+            // Slow rotation rate: 8192/440 units per deg/s
+            z *= 440;
+        } else {
+            // Fast rotation rate: 8192/2000 units per deg/s
+            z *= 2000;
+        }
+
+        values[0] = -((float)z / GYRO_RES_PER_DEGREE) * SDL_PI_F / 180.0f;
+        values[1] = ((float)x / GYRO_RES_PER_DEGREE) * SDL_PI_F / 180.0f;
+        values[2] = ((float)y / GYRO_RES_PER_DEGREE) * SDL_PI_F / 180.0f;
+        SDL_SendJoystickSensor(ctx->timestamp, joystick, SDL_SENSOR_GYRO, ctx->timestamp, values, 3);
+    }
+}
+
+static void HandleWiiRemoteAccelData(SDL_DriverWii_Context *ctx, SDL_Joystick *joystick, const WiiButtonData *data)
+{
+    const float ACCEL_RES_PER_G = 100.0f;
+    Sint16 x, y, z;
+    float values[3];
+
+    if (!ctx->m_bReportSensors) {
+        return;
+    }
+
+    x = ((data->rgucAccelerometer[0] << 2) | ((data->rgucBaseButtons[0] >> 5) & 0x03)) - 0x200;
+    y = ((data->rgucAccelerometer[1] << 2) | ((data->rgucBaseButtons[1] >> 4) & 0x02)) - 0x200;
+    z = ((data->rgucAccelerometer[2] << 2) | ((data->rgucBaseButtons[1] >> 5) & 0x02)) - 0x200;
+
+    values[0] = -((float)x / ACCEL_RES_PER_G) * SDL_STANDARD_GRAVITY;
+    values[1] = ((float)z / ACCEL_RES_PER_G) * SDL_STANDARD_GRAVITY;
+    values[2] = ((float)y / ACCEL_RES_PER_G) * SDL_STANDARD_GRAVITY;
+    SDL_SendJoystickSensor(ctx->timestamp, joystick, SDL_SENSOR_ACCEL, ctx->timestamp, values, 3);
+}
+
+static void HandleButtonData(SDL_DriverWii_Context *ctx, SDL_Joystick *joystick, WiiButtonData *data)
+{
+    if (ctx->m_eExtensionControllerType == k_eWiiExtensionControllerType_WiiUPro) {
+        HandleWiiUProButtonData(ctx, joystick, data);
+        return;
+    }
+
+    if (ctx->m_ucMotionPlusMode != WII_MOTIONPLUS_MODE_NONE &&
+        data->ucNExtensionBytes > 5) {
+        if (data->rgucExtension[5] & 0x01) {
+            // The data is invalid, possibly during a hotplug
+            return;
+        }
+
+        if (data->rgucExtension[4] & 0x01) {
+            if (ctx->m_eExtensionControllerType == k_eWiiExtensionControllerType_None) {
+                // Something was plugged into the extension port, reinitialize to get new state
+                ctx->m_bDisconnected = true;
+            }
+        } else {
+            if (ctx->m_eExtensionControllerType != k_eWiiExtensionControllerType_None) {
+                // Something was removed from the extension port, reinitialize to get new state
+                ctx->m_bDisconnected = true;
+            }
+        }
+
+        if (data->rgucExtension[5] & 0x02) {
+            HandleMotionPlusData(ctx, joystick, data);
+
+            // The extension data is consumed
+            data->ucNExtensionBytes = 0;
+        }
+    }
+
+    HandleWiiRemoteButtonData(ctx, joystick, data);
+    switch (ctx->m_eExtensionControllerType) {
+    case k_eWiiExtensionControllerType_Nunchuk:
+        HandleNunchuckButtonData(ctx, joystick, data);
+        SDL_FALLTHROUGH;
+    case k_eWiiExtensionControllerType_None:
+        HandleWiiRemoteButtonDataAsMainController(ctx, joystick, data);
+        break;
+    case k_eWiiExtensionControllerType_Gamepad:
+        HandleGamepadControllerButtonData(ctx, joystick, data);
+        break;
+    default:
+        break;
+    }
+    HandleWiiRemoteAccelData(ctx, joystick, data);
+}
+
+static void GetBaseButtons(WiiButtonData *dst, const Uint8 *src)
+{
+    SDL_memcpy(dst->rgucBaseButtons, src, 2);
+    dst->hasBaseButtons = true;
+}
+
+static void GetAccelerometer(WiiButtonData *dst, const Uint8 *src)
+{
+    SDL_memcpy(dst->rgucAccelerometer, src, 3);
+    dst->hasAccelerometer = true;
+}
+
+static void GetExtensionData(WiiButtonData *dst, const Uint8 *src, int size)
+{
+    bool valid_data = false;
+    int i;
+
+    if (size > sizeof(dst->rgucExtension)) {
+        size = sizeof(dst->rgucExtension);
+    }
+
+    for (i = 0; i < size; ++i) {
+        if (src[i] != 0xFF) {
+            valid_data = true;
+            break;
+        }
+    }
+    if (valid_data) {
+        SDL_memcpy(dst->rgucExtension, src, size);
+        dst->ucNExtensionBytes = (Uint8)size;
+    }
+}
+
+static void HandleStatus(SDL_DriverWii_Context *ctx, SDL_Joystick *joystick)
+{
+    bool hadExtension = ctx->m_eExtensionControllerType != k_eWiiExtensionControllerType_None;
+    bool hasExtension = (ctx->m_rgucReadBuffer[3] & 2) ? true : false;
+    WiiButtonData data;
+    SDL_zero(data);
+    GetBaseButtons(&data, ctx->m_rgucReadBuffer + 1);
+    HandleButtonData(ctx, joystick, &data);
+
+    if (ctx->m_eExtensionControllerType != k_eWiiExtensionControllerType_WiiUPro) {
+        // Wii U has separate battery level tracking
+        UpdatePowerLevelWii(joystick, ctx->m_rgucReadBuffer[6]);
+    }
+
+    // The report data format has been reset, need to update it
+    ResetButtonPacketType(ctx);
+
+    SDL_LogDebug(SDL_LOG_CATEGORY_INPUT, "HIDAPI Wii: Status update, extension %s", hasExtension ? "CONNECTED" : "DISCONNECTED");
+
+    /* When Motion Plus is active, we get extension connect/disconnect status
+     * through the Motion Plus packets. Otherwise we can use the status here.
+     */
+    if (ctx->m_ucMotionPlusMode != WII_MOTIONPLUS_MODE_NONE) {
+        /* Check to make sure the Motion Plus extension state hasn't changed,
+         * otherwise we'll get extension connect/disconnect status through
+         * Motion Plus packets.
+         */
+        if (NeedsPeriodicMotionPlusCheck(ctx, true)) {
+            ctx->m_ulNextMotionPlusCheck = SDL_GetTicks();
+        }
+
+    } else if (hadExtension != hasExtension) {
+        // Reinitialize to get new state
+        ctx->m_bDisconnected = true;
+    }
+}
+
+static void HandleResponse(SDL_DriverWii_Context *ctx, SDL_Joystick *joystick)
+{
+    EWiiInputReportIDs type = (EWiiInputReportIDs)ctx->m_rgucReadBuffer[0];
+    WiiButtonData data;
+    SDL_assert(type == k_eWiiInputReportIDs_Acknowledge || type == k_eWiiInputReportIDs_ReadMemory);
+    SDL_zero(data);
+    GetBaseButtons(&data, ctx->m_rgucReadBuffer + 1);
+    HandleButtonData(ctx, joystick, &data);
+
+    switch (ctx->m_eCommState) {
+    case k_eWiiCommunicationState_None:
+        break;
+
+    case k_eWiiCommunicationState_CheckMotionPlusStage1:
+    case k_eWiiCommunicationState_CheckMotionPlusStage2:
+    {
+        Uint16 extension = 0;
+        if (ParseExtensionIdentifyResponse(ctx, &extension)) {
+            if ((extension & WII_EXTENSION_MOTIONPLUS_MASK) == WII_EXTENSION_MOTIONPLUS_ID) {
+                // Motion Plus is currently active
+                SDL_LogDebug(SDL_LOG_CATEGORY_INPUT, "HIDAPI Wii: Motion Plus CONNECTED (stage %d)", ctx->m_eCommState == k_eWiiCommunicationState_CheckMotionPlusStage1 ? 1 : 2);
+
+                if (!ctx->m_bMotionPlusPresent) {
+                    // Reinitialize to get new sensor availability
+                    ctx->m_bDisconnected = true;
+                }
+                ctx->m_eCommState = k_eWiiCommunicationState_None;
+
+            } else if (ctx->m_eCommState == k_eWiiCommunicationState_CheckMotionPlusStage1) {
+                // Check to see if Motion Plus is present
+                ReadRegister(ctx, 0xA600FE, 2, false);
+
+                ctx->m_eCommState = k_eWiiCommunicationState_CheckMotionPlusStage2;
+
+            } else {
+                // Motion Plus is not present
+                SDL_LogDebug(SDL_LOG_CATEGORY_INPUT, "HIDAPI Wii: Motion Plus DISCONNECTED (stage %d)", ctx->m_eCommState == k_eWiiCommunicationState_CheckMotionPlusStage1 ? 1 : 2);
+
+                if (ctx->m_bMotionPlusPresent) {
+                    // Reinitialize to get new sensor availability
+                    ctx->m_bDisconnected = true;
+                }
+                ctx->m_eCommState = k_eWiiCommunicationState_None;
+            }
+        }
+    } break;
+    default:
+        // Should never happen
+        break;
+    }
+}
+
+static void HandleButtonPacket(SDL_DriverWii_Context *ctx, SDL_Joystick *joystick)
+{
+    EWiiInputReportIDs eExpectedReport = GetButtonPacketType(ctx);
+    WiiButtonData data;
+
+    // FIXME: This should see if the data format is compatible rather than equal
+    if (eExpectedReport != ctx->m_rgucReadBuffer[0]) {
+        SDL_LogDebug(SDL_LOG_CATEGORY_INPUT, "HIDAPI Wii: Resetting report mode to %d", eExpectedReport);
+        RequestButtonPacketType(ctx, eExpectedReport);
+    }
+
+    // IR camera data is not supported
+    SDL_zero(data);
+    switch (ctx->m_rgucReadBuffer[0]) {
+    case k_eWiiInputReportIDs_ButtonData0: // 30 BB BB
+        GetBaseButtons(&data, ctx->m_rgucReadBuffer + 1);
+        break;
+    case k_eWiiInputReportIDs_ButtonData1: // 31 BB BB AA AA AA
+    case k_eWiiInputReportIDs_ButtonData3: // 33 BB BB AA AA AA II II II II II II II II II II II II
+        GetBaseButtons(&data, ctx->m_rgucReadBuffer + 1);
+        GetAccelerometer(&data, ctx->m_rgucReadBuffer + 3);
+        break;
+    case k_eWiiInputReportIDs_ButtonData2: // 32 BB BB EE EE EE EE EE EE EE EE
+        GetBaseButtons(&data, ctx->m_rgucReadBuffer + 1);
+        GetExtensionData(&data, ctx->m_rgucReadBuffer + 3, 8);
+        break;
+    case k_eWiiInputReportIDs_ButtonData4: // 34 BB BB EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE
+        GetBaseButtons(&data, ctx->m_rgucReadBuffer + 1);
+        GetExtensionData(&data, ctx->m_rgucReadBuffer + 3, 19);
+        break;
+    case k_eWiiInputReportIDs_ButtonData5: // 35 BB BB AA AA AA EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE
+        GetBaseButtons(&data, ctx->m_rgucReadBuffer + 1);
+        GetAccelerometer(&data, ctx->m_rgucReadBuffer + 3);
+        GetExtensionData(&data, ctx->m_rgucReadBuffer + 6, 16);
+        break;
+    case k_eWiiInputReportIDs_ButtonData6: // 36 BB BB II II II II II II II II II II EE EE EE EE EE EE EE EE EE
+        GetBaseButtons(&data, ctx->m_rgucReadBuffer + 1);
+        GetExtensionData(&data, ctx->m_rgucReadBuffer + 13, 9);
+        break;
+    case k_eWiiInputReportIDs_ButtonData7: // 37 BB BB AA AA AA II II II II II II II II II II EE EE EE EE EE EE
+        GetBaseButtons(&data, ctx->m_rgucReadBuffer + 1);
+        GetExtensionData(&data, ctx->m_rgucReadBuffer + 16, 6);
+        break;
+    case k_eWiiInputReportIDs_ButtonDataD: // 3d EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE EE
+        GetExtensionData(&data, ctx->m_rgucReadBuffer + 1, 21);
+        break;
+    case k_eWiiInputReportIDs_ButtonDataE:
+    case k_eWiiInputReportIDs_ButtonDataF:
+    default:
+        SDL_LogDebug(SDL_LOG_CATEGORY_INPUT, "HIDAPI Wii: Unsupported button data type %02x", ctx->m_rgucReadBuffer[0]);
+        return;
+    }
+    HandleButtonData(ctx, joystick, &data);
+}
+
+static void HandleInput(SDL_DriverWii_Context *ctx, SDL_Joystick *joystick)
+{
+    EWiiInputReportIDs type = (EWiiInputReportIDs)ctx->m_rgucReadBuffer[0];
+
+    // Set up for handling input
+    ctx->timestamp = SDL_GetTicksNS();
+
+    if (type == k_eWiiInputReportIDs_Status) {
+        HandleStatus(ctx, joystick);
+    } else if (type == k_eWiiInputReportIDs_Acknowledge || type == k_eWiiInputReportIDs_ReadMemory) {
+        HandleResponse(ctx, joystick);
+    } else if (type >= k_eWiiInputReportIDs_ButtonData0 && type <= k_eWiiInputReportIDs_ButtonDataF) {
+        HandleButtonPacket(ctx, joystick);
+    } else {
+        SDL_LogDebug(SDL_LOG_CATEGORY_INPUT, "HIDAPI Wii: Unexpected input packet of type %x", type);
+    }
+}
+
+static bool HIDAPI_DriverWii_UpdateDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverWii_Context *ctx = (SDL_DriverWii_Context *)device->context;
+    SDL_Joystick *joystick = NULL;
+    int size;
+    Uint64 now;
+
+    if (device->num_joysticks > 0) {
+        joystick = SDL_GetJoystickFromID(device->joysticks[0]);
+    } else {
+        return false;
+    }
+
+    now = SDL_GetTicks();
+
+    while ((size = ReadInput(ctx)) > 0) {
+        if (joystick) {
+            HandleInput(ctx, joystick);
+        }
+        ctx->m_ulLastInput = now;
+    }
+
+    /* Check to see if we've lost connection to the controller.
+     * We have continuous reporting enabled, so this should be reliable now.
+     */
+    {
+        SDL_COMPILE_TIME_ASSERT(ENABLE_CONTINUOUS_REPORTING, ENABLE_CONTINUOUS_REPORTING);
+    }
+    if (now >= (ctx->m_ulLastInput + INPUT_WAIT_TIMEOUT_MS)) {
+        // Bluetooth may have disconnected, try reopening the controller
+        size = -1;
+    }
+
+    if (joystick) {
+        // These checks aren't needed on the Wii U Pro Controller
+        if (ctx->m_eExtensionControllerType != k_eWiiExtensionControllerType_WiiUPro) {
+
+            // Check to see if the Motion Plus extension status has changed
+            if (ctx->m_ulNextMotionPlusCheck && now >= ctx->m_ulNextMotionPlusCheck) {
+                CheckMotionPlusConnection(ctx);
+                if (NeedsPeriodicMotionPlusCheck(ctx, false)) {
+                    SchedulePeriodicMotionPlusCheck(ctx);
+                } else {
+                    ctx->m_ulNextMotionPlusCheck = 0;
+                }
+            }
+
+            // Request a status update periodically to make sure our battery value is up to date
+            if (!ctx->m_ulLastStatus || now >= (ctx->m_ulLastStatus + STATUS_UPDATE_TIME_MS)) {
+                Uint8 data[2];
+
+                data[0] = k_eWiiOutputReportIDs_StatusRequest;
+                data[1] = (Uint8)ctx->m_bRumbleActive;
+                WriteOutput(ctx, data, sizeof(data), false);
+
+                ctx->m_ulLastStatus = now;
+            }
+        }
+    }
+
+    if (size < 0 || ctx->m_bDisconnected) {
+        // Read error, device is disconnected
+        HIDAPI_JoystickDisconnected(device, device->joysticks[0]);
+    }
+    return (size >= 0);
+}
+
+static void HIDAPI_DriverWii_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverWii_Context *ctx = (SDL_DriverWii_Context *)device->context;
+
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_WII_PLAYER_LED,
+                        SDL_PlayerLEDHintChanged, ctx);
+
+    ctx->joystick = NULL;
+}
+
+static void HIDAPI_DriverWii_FreeDevice(SDL_HIDAPI_Device *device)
+{
+}
+
+SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverWii = {
+    SDL_HINT_JOYSTICK_HIDAPI_WII,
+    true,
+    HIDAPI_DriverWii_RegisterHints,
+    HIDAPI_DriverWii_UnregisterHints,
+    HIDAPI_DriverWii_IsEnabled,
+    HIDAPI_DriverWii_IsSupportedDevice,
+    HIDAPI_DriverWii_InitDevice,
+    HIDAPI_DriverWii_GetDevicePlayerIndex,
+    HIDAPI_DriverWii_SetDevicePlayerIndex,
+    HIDAPI_DriverWii_UpdateDevice,
+    HIDAPI_DriverWii_OpenJoystick,
+    HIDAPI_DriverWii_RumbleJoystick,
+    HIDAPI_DriverWii_RumbleJoystickTriggers,
+    HIDAPI_DriverWii_GetJoystickCapabilities,
+    HIDAPI_DriverWii_SetJoystickLED,
+    HIDAPI_DriverWii_SendJoystickEffect,
+    HIDAPI_DriverWii_SetJoystickSensorsEnabled,
+    HIDAPI_DriverWii_CloseJoystick,
+    HIDAPI_DriverWii_FreeDevice,
+};
+
+#endif // SDL_JOYSTICK_HIDAPI_WII
+
+#endif // SDL_JOYSTICK_HIDAPI
diff --git a/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_xbox360.c b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_xbox360.c
new file mode 100644
index 0000000..49be08a
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_xbox360.c
@@ -0,0 +1,379 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI
+
+#include "../../SDL_hints_c.h"
+#include "../SDL_sysjoystick.h"
+#include "SDL_hidapijoystick_c.h"
+#include "SDL_hidapi_rumble.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI_XBOX360
+
+// Define this if you want to log all packets from the controller
+// #define DEBUG_XBOX_PROTOCOL
+
+typedef struct
+{
+    SDL_HIDAPI_Device *device;
+    SDL_Joystick *joystick;
+    int player_index;
+    bool player_lights;
+    Uint8 last_state[USB_PACKET_LENGTH];
+} SDL_DriverXbox360_Context;
+
+static void HIDAPI_DriverXbox360_RegisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_XBOX, callback, userdata);
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_XBOX_360, callback, userdata);
+}
+
+static void HIDAPI_DriverXbox360_UnregisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_XBOX, callback, userdata);
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_XBOX_360, callback, userdata);
+}
+
+static bool HIDAPI_DriverXbox360_IsEnabled(void)
+{
+    return SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_XBOX_360,
+                              SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_XBOX, SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI, SDL_HIDAPI_DEFAULT)));
+}
+
+static bool HIDAPI_DriverXbox360_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)
+{
+    const int XB360W_IFACE_PROTOCOL = 129; // Wireless
+
+    if (vendor_id == USB_VENDOR_ASTRO && product_id == USB_PRODUCT_ASTRO_C40_XBOX360) {
+        // This is the ASTRO C40 in Xbox 360 mode
+        return true;
+    }
+    if (vendor_id == USB_VENDOR_NVIDIA) {
+        // This is the NVIDIA Shield controller which doesn't talk Xbox controller protocol
+        return false;
+    }
+    if ((vendor_id == USB_VENDOR_MICROSOFT && (product_id == USB_PRODUCT_XBOX360_WIRELESS_RECEIVER_THIRDPARTY2 || product_id == USB_PRODUCT_XBOX360_WIRELESS_RECEIVER)) ||
+        (type == SDL_GAMEPAD_TYPE_XBOX360 && interface_protocol == XB360W_IFACE_PROTOCOL)) {
+        // This is the wireless dongle, which talks a different protocol
+        return false;
+    }
+    if (interface_number > 0) {
+        // This is the chatpad or other input interface, not the Xbox 360 interface
+        return false;
+    }
+#if defined(SDL_PLATFORM_MACOS) && defined(SDL_JOYSTICK_MFI)
+    if (SDL_IsJoystickSteamVirtualGamepad(vendor_id, product_id, version)) {
+        // GCController support doesn't work with the Steam Virtual Gamepad
+        return true;
+    } else {
+        // On macOS you can't write output reports to wired XBox controllers,
+        // so we'll just use the GCController support instead.
+        return false;
+    }
+#else
+    return (type == SDL_GAMEPAD_TYPE_XBOX360);
+#endif
+}
+
+static bool SetSlotLED(SDL_hid_device *dev, Uint8 slot, bool on)
+{
+    const bool blink = false;
+    Uint8 mode = on ? ((blink ? 0x02 : 0x06) + slot) : 0;
+    Uint8 led_packet[] = { 0x01, 0x03, 0x00 };
+
+    led_packet[2] = mode;
+    if (SDL_hid_write(dev, led_packet, sizeof(led_packet)) != sizeof(led_packet)) {
+        return false;
+    }
+    return true;
+}
+
+static void UpdateSlotLED(SDL_DriverXbox360_Context *ctx)
+{
+    if (ctx->player_lights && ctx->player_index >= 0) {
+        SetSlotLED(ctx->device->dev, (ctx->player_index % 4), true);
+    } else {
+        SetSlotLED(ctx->device->dev, 0, false);
+    }
+}
+
+static void SDLCALL SDL_PlayerLEDHintChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
+{
+    SDL_DriverXbox360_Context *ctx = (SDL_DriverXbox360_Context *)userdata;
+    bool player_lights = SDL_GetStringBoolean(hint, true);
+
+    if (player_lights != ctx->player_lights) {
+        ctx->player_lights = player_lights;
+
+        UpdateSlotLED(ctx);
+        HIDAPI_UpdateDeviceProperties(ctx->device);
+    }
+}
+
+static bool HIDAPI_DriverXbox360_InitDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverXbox360_Context *ctx;
+
+    ctx = (SDL_DriverXbox360_Context *)SDL_calloc(1, sizeof(*ctx));
+    if (!ctx) {
+        return false;
+    }
+    ctx->device = device;
+
+    device->context = ctx;
+
+    device->type = SDL_GAMEPAD_TYPE_XBOX360;
+
+    if (SDL_IsJoystickSteamVirtualGamepad(device->vendor_id, device->product_id, device->version) &&
+        device->product_string && SDL_strncmp(device->product_string, "GamePad-", 8) == 0) {
+        int slot = 0;
+        SDL_sscanf(device->product_string, "GamePad-%d", &slot);
+        device->steam_virtual_gamepad_slot = (slot - 1);
+    }
+
+    return HIDAPI_JoystickConnected(device, NULL);
+}
+
+static int HIDAPI_DriverXbox360_GetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id)
+{
+    return -1;
+}
+
+static void HIDAPI_DriverXbox360_SetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id, int player_index)
+{
+    SDL_DriverXbox360_Context *ctx = (SDL_DriverXbox360_Context *)device->context;
+
+    if (!ctx->joystick) {
+        return;
+    }
+
+    ctx->player_index = player_index;
+
+    UpdateSlotLED(ctx);
+}
+
+static bool HIDAPI_DriverXbox360_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverXbox360_Context *ctx = (SDL_DriverXbox360_Context *)device->context;
+
+    SDL_AssertJoysticksLocked();
+
+    ctx->joystick = joystick;
+    SDL_zeroa(ctx->last_state);
+
+    // Initialize player index (needed for setting LEDs)
+    ctx->player_index = SDL_GetJoystickPlayerIndex(joystick);
+    ctx->player_lights = SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_XBOX_360_PLAYER_LED, true);
+    UpdateSlotLED(ctx);
+
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_XBOX_360_PLAYER_LED,
+                        SDL_PlayerLEDHintChanged, ctx);
+
+    // Initialize the joystick capabilities
+    joystick->nbuttons = 11;
+    joystick->naxes = SDL_GAMEPAD_AXIS_COUNT;
+    joystick->nhats = 1;
+
+    return true;
+}
+
+static bool HIDAPI_DriverXbox360_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+    Uint8 rumble_packet[] = { 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+    rumble_packet[3] = (low_frequency_rumble >> 8);
+    rumble_packet[4] = (high_frequency_rumble >> 8);
+
+    if (SDL_HIDAPI_SendRumble(device, rumble_packet, sizeof(rumble_packet)) != sizeof(rumble_packet)) {
+        return SDL_SetError("Couldn't send rumble packet");
+    }
+    return true;
+}
+
+static bool HIDAPI_DriverXbox360_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
+{
+    return SDL_Unsupported();
+}
+
+static Uint32 HIDAPI_DriverXbox360_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverXbox360_Context *ctx = (SDL_DriverXbox360_Context *)device->context;
+    Uint32 result = SDL_JOYSTICK_CAP_RUMBLE;
+
+    if (ctx->player_lights) {
+        result |= SDL_JOYSTICK_CAP_PLAYER_LED;
+    }
+    return result;
+}
+
+static bool HIDAPI_DriverXbox360_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverXbox360_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *data, int size)
+{
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverXbox360_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, bool enabled)
+{
+    return SDL_Unsupported();
+}
+
+static void HIDAPI_DriverXbox360_HandleStatePacket(SDL_Joystick *joystick, SDL_DriverXbox360_Context *ctx, Uint8 *data, int size)
+{
+    Sint16 axis;
+#ifdef SDL_PLATFORM_MACOS
+    const bool invert_y_axes = false;
+#else
+    const bool invert_y_axes = true;
+#endif
+    Uint64 timestamp = SDL_GetTicksNS();
+
+    if (ctx->last_state[2] != data[2]) {
+        Uint8 hat = 0;
+
+        if (data[2] & 0x01) {
+            hat |= SDL_HAT_UP;
+        }
+        if (data[2] & 0x02) {
+            hat |= SDL_HAT_DOWN;
+        }
+        if (data[2] & 0x04) {
+            hat |= SDL_HAT_LEFT;
+        }
+        if (data[2] & 0x08) {
+            hat |= SDL_HAT_RIGHT;
+        }
+        SDL_SendJoystickHat(timestamp, joystick, 0, hat);
+
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data[2] & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK, ((data[2] & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data[2] & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_STICK, ((data[2] & 0x80) != 0));
+    }
+
+    if (ctx->last_state[3] != data[3]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data[3] & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data[3] & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data[3] & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SOUTH, ((data[3] & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_EAST, ((data[3] & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_WEST, ((data[3] & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_NORTH, ((data[3] & 0x80) != 0));
+    }
+
+    axis = ((int)data[4] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, axis);
+    axis = ((int)data[5] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, axis);
+    axis = SDL_Swap16LE(*(Sint16 *)(&data[6]));
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, axis);
+    axis = SDL_Swap16LE(*(Sint16 *)(&data[8]));
+    if (invert_y_axes) {
+        axis = ~axis;
+    }
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, axis);
+    axis = SDL_Swap16LE(*(Sint16 *)(&data[10]));
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, axis);
+    axis = SDL_Swap16LE(*(Sint16 *)(&data[12]));
+    if (invert_y_axes) {
+        axis = ~axis;
+    }
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, axis);
+
+    SDL_memcpy(ctx->last_state, data, SDL_min((size_t)size, sizeof(ctx->last_state)));
+}
+
+static bool HIDAPI_DriverXbox360_UpdateDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverXbox360_Context *ctx = (SDL_DriverXbox360_Context *)device->context;
+    SDL_Joystick *joystick = NULL;
+    Uint8 data[USB_PACKET_LENGTH];
+    int size = 0;
+
+    if (device->num_joysticks > 0) {
+        joystick = SDL_GetJoystickFromID(device->joysticks[0]);
+    } else {
+        return false;
+    }
+
+    while ((size = SDL_hid_read_timeout(device->dev, data, sizeof(data), 0)) > 0) {
+#ifdef DEBUG_XBOX_PROTOCOL
+        HIDAPI_DumpPacket("Xbox 360 packet: size = %d", data, size);
+#endif
+        if (!joystick) {
+            continue;
+        }
+
+        if (data[0] == 0x00) {
+            HIDAPI_DriverXbox360_HandleStatePacket(joystick, ctx, data, size);
+        }
+    }
+
+    if (size < 0) {
+        // Read error, device is disconnected
+        HIDAPI_JoystickDisconnected(device, device->joysticks[0]);
+    }
+    return (size >= 0);
+}
+
+static void HIDAPI_DriverXbox360_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverXbox360_Context *ctx = (SDL_DriverXbox360_Context *)device->context;
+
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_XBOX_360_PLAYER_LED,
+                        SDL_PlayerLEDHintChanged, ctx);
+
+    ctx->joystick = NULL;
+}
+
+static void HIDAPI_DriverXbox360_FreeDevice(SDL_HIDAPI_Device *device)
+{
+}
+
+SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverXbox360 = {
+    SDL_HINT_JOYSTICK_HIDAPI_XBOX_360,
+    true,
+    HIDAPI_DriverXbox360_RegisterHints,
+    HIDAPI_DriverXbox360_UnregisterHints,
+    HIDAPI_DriverXbox360_IsEnabled,
+    HIDAPI_DriverXbox360_IsSupportedDevice,
+    HIDAPI_DriverXbox360_InitDevice,
+    HIDAPI_DriverXbox360_GetDevicePlayerIndex,
+    HIDAPI_DriverXbox360_SetDevicePlayerIndex,
+    HIDAPI_DriverXbox360_UpdateDevice,
+    HIDAPI_DriverXbox360_OpenJoystick,
+    HIDAPI_DriverXbox360_RumbleJoystick,
+    HIDAPI_DriverXbox360_RumbleJoystickTriggers,
+    HIDAPI_DriverXbox360_GetJoystickCapabilities,
+    HIDAPI_DriverXbox360_SetJoystickLED,
+    HIDAPI_DriverXbox360_SendJoystickEffect,
+    HIDAPI_DriverXbox360_SetJoystickSensorsEnabled,
+    HIDAPI_DriverXbox360_CloseJoystick,
+    HIDAPI_DriverXbox360_FreeDevice,
+};
+
+#endif // SDL_JOYSTICK_HIDAPI_XBOX360
+
+#endif // SDL_JOYSTICK_HIDAPI
diff --git a/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_xbox360w.c b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_xbox360w.c
new file mode 100644
index 0000000..bf63707
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_xbox360w.c
@@ -0,0 +1,388 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI
+
+#include "../../SDL_hints_c.h"
+#include "../SDL_sysjoystick.h"
+#include "SDL_hidapijoystick_c.h"
+#include "SDL_hidapi_rumble.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI_XBOX360
+
+// Define this if you want to log all packets from the controller
+// #define DEBUG_XBOX_PROTOCOL
+
+typedef struct
+{
+    SDL_HIDAPI_Device *device;
+    bool connected;
+    int player_index;
+    bool player_lights;
+    Uint8 last_state[USB_PACKET_LENGTH];
+} SDL_DriverXbox360W_Context;
+
+static void HIDAPI_DriverXbox360W_RegisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_XBOX, callback, userdata);
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_XBOX_360, callback, userdata);
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_XBOX_360_WIRELESS, callback, userdata);
+}
+
+static void HIDAPI_DriverXbox360W_UnregisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_XBOX, callback, userdata);
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_XBOX_360, callback, userdata);
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_XBOX_360_WIRELESS, callback, userdata);
+}
+
+static bool HIDAPI_DriverXbox360W_IsEnabled(void)
+{
+    return SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_XBOX_360_WIRELESS,
+                              SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_XBOX_360, SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_XBOX, SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI, SDL_HIDAPI_DEFAULT))));
+}
+
+static bool HIDAPI_DriverXbox360W_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)
+{
+    const int XB360W_IFACE_PROTOCOL = 129; // Wireless
+
+    if ((vendor_id == USB_VENDOR_MICROSOFT && (product_id == USB_PRODUCT_XBOX360_WIRELESS_RECEIVER_THIRDPARTY2 || product_id == USB_PRODUCT_XBOX360_WIRELESS_RECEIVER_THIRDPARTY1 || product_id == USB_PRODUCT_XBOX360_WIRELESS_RECEIVER) && interface_protocol == 0) ||
+        (type == SDL_GAMEPAD_TYPE_XBOX360 && interface_protocol == XB360W_IFACE_PROTOCOL)) {
+        return true;
+    }
+    return false;
+}
+
+static bool SetSlotLED(SDL_hid_device *dev, Uint8 slot, bool on)
+{
+    const bool blink = false;
+    Uint8 mode = on ? ((blink ? 0x02 : 0x06) + slot) : 0;
+    Uint8 led_packet[] = { 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+    led_packet[3] = 0x40 + (mode % 0x0e);
+    if (SDL_hid_write(dev, led_packet, sizeof(led_packet)) != sizeof(led_packet)) {
+        return false;
+    }
+    return true;
+}
+
+static void UpdateSlotLED(SDL_DriverXbox360W_Context *ctx)
+{
+    if (ctx->player_lights && ctx->player_index >= 0) {
+        SetSlotLED(ctx->device->dev, (ctx->player_index % 4), true);
+    } else {
+        SetSlotLED(ctx->device->dev, 0, false);
+    }
+}
+
+static void SDLCALL SDL_PlayerLEDHintChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
+{
+    SDL_DriverXbox360W_Context *ctx = (SDL_DriverXbox360W_Context *)userdata;
+    bool player_lights = SDL_GetStringBoolean(hint, true);
+
+    if (player_lights != ctx->player_lights) {
+        ctx->player_lights = player_lights;
+
+        UpdateSlotLED(ctx);
+        HIDAPI_UpdateDeviceProperties(ctx->device);
+    }
+}
+
+static void UpdatePowerLevel(SDL_Joystick *joystick, Uint8 level)
+{
+    int percent = (int)SDL_roundf((level / 255.0f) * 100.0f);
+    SDL_SendJoystickPowerInfo(joystick, SDL_POWERSTATE_ON_BATTERY, percent);
+}
+
+static bool HIDAPI_DriverXbox360W_InitDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverXbox360W_Context *ctx;
+
+    // Requests controller presence information from the wireless dongle
+    const Uint8 init_packet[] = { 0x08, 0x00, 0x0F, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+    HIDAPI_SetDeviceName(device, "Xbox 360 Wireless Controller");
+
+    ctx = (SDL_DriverXbox360W_Context *)SDL_calloc(1, sizeof(*ctx));
+    if (!ctx) {
+        return false;
+    }
+    ctx->device = device;
+
+    device->context = ctx;
+
+    if (SDL_hid_write(device->dev, init_packet, sizeof(init_packet)) != sizeof(init_packet)) {
+        SDL_SetError("Couldn't write init packet");
+        return false;
+    }
+
+    device->type = SDL_GAMEPAD_TYPE_XBOX360;
+
+    return true;
+}
+
+static int HIDAPI_DriverXbox360W_GetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id)
+{
+    return -1;
+}
+
+static void HIDAPI_DriverXbox360W_SetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id, int player_index)
+{
+    SDL_DriverXbox360W_Context *ctx = (SDL_DriverXbox360W_Context *)device->context;
+
+    if (!ctx) {
+        return;
+    }
+
+    ctx->player_index = player_index;
+
+    UpdateSlotLED(ctx);
+}
+
+static bool HIDAPI_DriverXbox360W_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverXbox360W_Context *ctx = (SDL_DriverXbox360W_Context *)device->context;
+
+    SDL_AssertJoysticksLocked();
+
+    SDL_zeroa(ctx->last_state);
+
+    // Initialize player index (needed for setting LEDs)
+    ctx->player_index = SDL_GetJoystickPlayerIndex(joystick);
+    ctx->player_lights = SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_XBOX_360_PLAYER_LED, true);
+    UpdateSlotLED(ctx);
+
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_XBOX_360_PLAYER_LED,
+                        SDL_PlayerLEDHintChanged, ctx);
+
+    // Initialize the joystick capabilities
+    joystick->nbuttons = 11;
+    joystick->naxes = SDL_GAMEPAD_AXIS_COUNT;
+    joystick->nhats = 1;
+    joystick->connection_state = SDL_JOYSTICK_CONNECTION_WIRELESS;
+
+    return true;
+}
+
+static bool HIDAPI_DriverXbox360W_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+    Uint8 rumble_packet[] = { 0x00, 0x01, 0x0f, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+    rumble_packet[5] = (low_frequency_rumble >> 8);
+    rumble_packet[6] = (high_frequency_rumble >> 8);
+
+    if (SDL_HIDAPI_SendRumble(device, rumble_packet, sizeof(rumble_packet)) != sizeof(rumble_packet)) {
+        return SDL_SetError("Couldn't send rumble packet");
+    }
+    return true;
+}
+
+static bool HIDAPI_DriverXbox360W_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
+{
+    return SDL_Unsupported();
+}
+
+static Uint32 HIDAPI_DriverXbox360W_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverXbox360W_Context *ctx = (SDL_DriverXbox360W_Context *)device->context;
+    Uint32 result = SDL_JOYSTICK_CAP_RUMBLE;
+
+    if (ctx->player_lights) {
+        result |= SDL_JOYSTICK_CAP_PLAYER_LED;
+    }
+    return result;
+}
+
+static bool HIDAPI_DriverXbox360W_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverXbox360W_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *data, int size)
+{
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverXbox360W_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, bool enabled)
+{
+    return SDL_Unsupported();
+}
+
+static void HIDAPI_DriverXbox360W_HandleStatePacket(SDL_Joystick *joystick, SDL_hid_device *dev, SDL_DriverXbox360W_Context *ctx, Uint8 *data, int size)
+{
+    Sint16 axis;
+    const bool invert_y_axes = true;
+    Uint64 timestamp = SDL_GetTicksNS();
+
+    if (ctx->last_state[2] != data[2]) {
+        Uint8 hat = 0;
+
+        if (data[2] & 0x01) {
+            hat |= SDL_HAT_UP;
+        }
+        if (data[2] & 0x02) {
+            hat |= SDL_HAT_DOWN;
+        }
+        if (data[2] & 0x04) {
+            hat |= SDL_HAT_LEFT;
+        }
+        if (data[2] & 0x08) {
+            hat |= SDL_HAT_RIGHT;
+        }
+        SDL_SendJoystickHat(timestamp, joystick, 0, hat);
+
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data[2] & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK, ((data[2] & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data[2] & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_STICK, ((data[2] & 0x80) != 0));
+    }
+
+    if (ctx->last_state[3] != data[3]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data[3] & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data[3] & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data[3] & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SOUTH, ((data[3] & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_EAST, ((data[3] & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_WEST, ((data[3] & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_NORTH, ((data[3] & 0x80) != 0));
+    }
+
+    axis = ((int)data[4] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, axis);
+    axis = ((int)data[5] * 257) - 32768;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, axis);
+    axis = SDL_Swap16LE(*(Sint16 *)(&data[6]));
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, axis);
+    axis = SDL_Swap16LE(*(Sint16 *)(&data[8]));
+    if (invert_y_axes) {
+        axis = ~axis;
+    }
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, axis);
+    axis = SDL_Swap16LE(*(Sint16 *)(&data[10]));
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, axis);
+    axis = SDL_Swap16LE(*(Sint16 *)(&data[12]));
+    if (invert_y_axes) {
+        axis = ~axis;
+    }
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, axis);
+
+    SDL_memcpy(ctx->last_state, data, SDL_min(size, sizeof(ctx->last_state)));
+}
+
+static bool HIDAPI_DriverXbox360W_UpdateDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverXbox360W_Context *ctx = (SDL_DriverXbox360W_Context *)device->context;
+    SDL_Joystick *joystick = NULL;
+    Uint8 data[USB_PACKET_LENGTH];
+    int size;
+
+    if (device->num_joysticks > 0) {
+        joystick = SDL_GetJoystickFromID(device->joysticks[0]);
+    }
+
+    while ((size = SDL_hid_read_timeout(device->dev, data, sizeof(data), 0)) > 0) {
+#ifdef DEBUG_XBOX_PROTOCOL
+        HIDAPI_DumpPacket("Xbox 360 wireless packet: size = %d", data, size);
+#endif
+        if (size == 2 && data[0] == 0x08) {
+            bool connected = (data[1] & 0x80) ? true : false;
+#ifdef DEBUG_JOYSTICK
+            SDL_Log("Connected = %s", connected ? "TRUE" : "FALSE");
+#endif
+            if (connected != ctx->connected) {
+                ctx->connected = connected;
+
+                if (connected) {
+                    SDL_JoystickID joystickID;
+
+                    HIDAPI_JoystickConnected(device, &joystickID);
+
+                } else if (device->num_joysticks > 0) {
+                    HIDAPI_JoystickDisconnected(device, device->joysticks[0]);
+                }
+            }
+        } else if (size == 29 && data[0] == 0x00 && data[1] == 0x0f && data[2] == 0x00 && data[3] == 0xf0) {
+            // Serial number is data[7-13]
+#ifdef DEBUG_JOYSTICK
+            SDL_Log("Battery status (initial): %d", data[17]);
+#endif
+            if (joystick) {
+                UpdatePowerLevel(joystick, data[17]);
+            }
+        } else if (size == 29 && data[0] == 0x00 && data[1] == 0x00 && data[2] == 0x00 && data[3] == 0x13) {
+#ifdef DEBUG_JOYSTICK
+            SDL_Log("Battery status: %d", data[4]);
+#endif
+            if (joystick) {
+                UpdatePowerLevel(joystick, data[4]);
+            }
+        } else if (size == 29 && data[0] == 0x00 && (data[1] & 0x01) == 0x01) {
+            if (joystick) {
+                HIDAPI_DriverXbox360W_HandleStatePacket(joystick, device->dev, ctx, data + 4, size - 4);
+            }
+        }
+    }
+
+    if (size < 0 && device->num_joysticks > 0) {
+        // Read error, device is disconnected
+        HIDAPI_JoystickDisconnected(device, device->joysticks[0]);
+    }
+    return (size >= 0);
+}
+
+static void HIDAPI_DriverXbox360W_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverXbox360W_Context *ctx = (SDL_DriverXbox360W_Context *)device->context;
+
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_XBOX_360_PLAYER_LED,
+                        SDL_PlayerLEDHintChanged, ctx);
+}
+
+static void HIDAPI_DriverXbox360W_FreeDevice(SDL_HIDAPI_Device *device)
+{
+}
+
+SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverXbox360W = {
+    SDL_HINT_JOYSTICK_HIDAPI_XBOX_360_WIRELESS,
+    true,
+    HIDAPI_DriverXbox360W_RegisterHints,
+    HIDAPI_DriverXbox360W_UnregisterHints,
+    HIDAPI_DriverXbox360W_IsEnabled,
+    HIDAPI_DriverXbox360W_IsSupportedDevice,
+    HIDAPI_DriverXbox360W_InitDevice,
+    HIDAPI_DriverXbox360W_GetDevicePlayerIndex,
+    HIDAPI_DriverXbox360W_SetDevicePlayerIndex,
+    HIDAPI_DriverXbox360W_UpdateDevice,
+    HIDAPI_DriverXbox360W_OpenJoystick,
+    HIDAPI_DriverXbox360W_RumbleJoystick,
+    HIDAPI_DriverXbox360W_RumbleJoystickTriggers,
+    HIDAPI_DriverXbox360W_GetJoystickCapabilities,
+    HIDAPI_DriverXbox360W_SetJoystickLED,
+    HIDAPI_DriverXbox360W_SendJoystickEffect,
+    HIDAPI_DriverXbox360W_SetJoystickSensorsEnabled,
+    HIDAPI_DriverXbox360W_CloseJoystick,
+    HIDAPI_DriverXbox360W_FreeDevice,
+};
+
+#endif // SDL_JOYSTICK_HIDAPI_XBOX360
+
+#endif // SDL_JOYSTICK_HIDAPI
diff --git a/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_xboxone.c b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_xboxone.c
new file mode 100644
index 0000000..342eabd
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapi_xboxone.c
@@ -0,0 +1,1675 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI
+
+#include "../../SDL_hints_c.h"
+#include "../SDL_sysjoystick.h"
+#include "SDL_hidapijoystick_c.h"
+#include "SDL_hidapi_rumble.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI_XBOXONE
+
+// Define this if you want verbose logging of the init sequence
+// #define DEBUG_JOYSTICK
+
+// Define this if you want to log all packets from the controller
+// #define DEBUG_XBOX_PROTOCOL
+
+#if defined(SDL_PLATFORM_WIN32) || defined(SDL_PLATFORM_WINGDK)
+#define XBOX_ONE_DRIVER_ACTIVE  1
+#else
+#define XBOX_ONE_DRIVER_ACTIVE  0
+#endif
+
+#define CONTROLLER_IDENTIFY_TIMEOUT_MS      100
+#define CONTROLLER_PREPARE_INPUT_TIMEOUT_MS 50
+
+// Deadzone thresholds
+#define XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE  7849
+#define XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE 8689
+#define XINPUT_GAMEPAD_TRIGGER_THRESHOLD    -25058 // Uint8 30 scaled to Sint16 full range
+
+enum
+{
+    SDL_GAMEPAD_BUTTON_XBOX_SHARE_BUTTON = 11
+};
+
+// Power on
+static const Uint8 xbox_init_power_on[] = {
+    0x05, 0x20, 0x00, 0x01, 0x00
+};
+// Enable LED
+static const Uint8 xbox_init_enable_led[] = {
+    0x0A, 0x20, 0x00, 0x03, 0x00, 0x01, 0x14
+};
+// This controller passed security check
+static const Uint8 xbox_init_security_passed[] = {
+    0x06, 0x20, 0x00, 0x02, 0x01, 0x00
+};
+// Some PowerA controllers need to actually start the rumble motors
+static const Uint8 xbox_init_powera_rumble[] = {
+    0x09, 0x00, 0x00, 0x09, 0x00, 0x0F, 0x00, 0x00,
+    0x1D, 0x1D, 0xFF, 0x00, 0x00
+};
+// Setup rumble (not needed for Microsoft controllers, but it doesn't hurt)
+static const Uint8 xbox_init_rumble[] = {
+    0x09, 0x00, 0x00, 0x09, 0x00, 0x0F, 0x00, 0x00,
+    0x00, 0x00, 0xFF, 0x00, 0xEB
+};
+
+/*
+ * This specifies the selection of init packets that a gamepad
+ * will be sent on init *and* the order in which they will be
+ * sent. The correct sequence number will be added when the
+ * packet is going to be sent.
+ */
+typedef struct
+{
+    Uint16 vendor_id;
+    Uint16 product_id;
+    const Uint8 *data;
+    int size;
+} SDL_DriverXboxOne_InitPacket;
+
+static const SDL_DriverXboxOne_InitPacket xboxone_init_packets[] = {
+    { 0x0000, 0x0000, xbox_init_power_on, sizeof(xbox_init_power_on) },
+    { 0x0000, 0x0000, xbox_init_enable_led, sizeof(xbox_init_enable_led) },
+    { 0x0000, 0x0000, xbox_init_security_passed, sizeof(xbox_init_security_passed) },
+    { 0x24c6, 0x541a, xbox_init_powera_rumble, sizeof(xbox_init_powera_rumble) },
+    { 0x24c6, 0x542a, xbox_init_powera_rumble, sizeof(xbox_init_powera_rumble) },
+    { 0x24c6, 0x543a, xbox_init_powera_rumble, sizeof(xbox_init_powera_rumble) },
+    { 0x0000, 0x0000, xbox_init_rumble, sizeof(xbox_init_rumble) },
+};
+
+typedef enum
+{
+    XBOX_ONE_INIT_STATE_ANNOUNCED,
+    XBOX_ONE_INIT_STATE_IDENTIFYING,
+    XBOX_ONE_INIT_STATE_STARTUP,
+    XBOX_ONE_INIT_STATE_PREPARE_INPUT,
+    XBOX_ONE_INIT_STATE_COMPLETE,
+} SDL_XboxOneInitState;
+
+typedef enum
+{
+    XBOX_ONE_RUMBLE_STATE_IDLE,
+    XBOX_ONE_RUMBLE_STATE_QUEUED,
+    XBOX_ONE_RUMBLE_STATE_BUSY
+} SDL_XboxOneRumbleState;
+
+typedef struct
+{
+    SDL_HIDAPI_Device *device;
+    Uint16 vendor_id;
+    Uint16 product_id;
+    SDL_XboxOneInitState init_state;
+    Uint64 start_time;
+    Uint8 sequence;
+    Uint64 send_time;
+    bool has_guide_packet;
+    bool has_color_led;
+    bool has_paddles;
+    bool has_unmapped_state;
+    bool has_trigger_rumble;
+    bool has_share_button;
+    Uint8 last_paddle_state;
+    Uint8 low_frequency_rumble;
+    Uint8 high_frequency_rumble;
+    Uint8 left_trigger_rumble;
+    Uint8 right_trigger_rumble;
+    SDL_XboxOneRumbleState rumble_state;
+    Uint64 rumble_time;
+    bool rumble_pending;
+    Uint8 last_state[USB_PACKET_LENGTH];
+    Uint8 *chunk_buffer;
+    Uint32 chunk_length;
+} SDL_DriverXboxOne_Context;
+
+static bool ControllerHasColorLED(Uint16 vendor_id, Uint16 product_id)
+{
+    return vendor_id == USB_VENDOR_MICROSOFT && product_id == USB_PRODUCT_XBOX_ONE_ELITE_SERIES_2;
+}
+
+static bool ControllerHasPaddles(Uint16 vendor_id, Uint16 product_id)
+{
+    return SDL_IsJoystickXboxOneElite(vendor_id, product_id);
+}
+
+static bool ControllerHasTriggerRumble(Uint16 vendor_id, Uint16 product_id)
+{
+    // All the Microsoft Xbox One controllers have trigger rumble
+    if (vendor_id == USB_VENDOR_MICROSOFT) {
+        return true;
+    }
+
+    /* It turns out other controllers a mixed bag as to whether they support
+       trigger rumble or not, and when they do it's often a buzz rather than
+       the vibration of the Microsoft trigger rumble, so for now just pretend
+       that it is not available.
+     */
+    return false;
+}
+
+static bool ControllerHasShareButton(Uint16 vendor_id, Uint16 product_id)
+{
+    return SDL_IsJoystickXboxSeriesX(vendor_id, product_id);
+}
+
+static int GetHomeLEDBrightness(const char *hint)
+{
+    const int MAX_VALUE = 50;
+    int value = 20;
+
+    if (hint && *hint) {
+        if (SDL_strchr(hint, '.') != NULL) {
+            value = (int)(MAX_VALUE * SDL_atof(hint));
+        } else if (!SDL_GetStringBoolean(hint, true)) {
+            value = 0;
+        }
+    }
+    return value;
+}
+
+static void SetHomeLED(SDL_DriverXboxOne_Context *ctx, int value)
+{
+    Uint8 led_packet[] = { 0x0A, 0x20, 0x00, 0x03, 0x00, 0x00, 0x00 };
+
+    if (value > 0) {
+        led_packet[5] = 0x01;
+        led_packet[6] = (Uint8)value;
+    }
+    SDL_HIDAPI_SendRumble(ctx->device, led_packet, sizeof(led_packet));
+}
+
+static void SDLCALL SDL_HomeLEDHintChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
+{
+    SDL_DriverXboxOne_Context *ctx = (SDL_DriverXboxOne_Context *)userdata;
+
+    if (hint && *hint) {
+        SetHomeLED(ctx, GetHomeLEDBrightness(hint));
+    }
+}
+
+static void SetInitState(SDL_DriverXboxOne_Context *ctx, SDL_XboxOneInitState state)
+{
+#ifdef DEBUG_JOYSTICK
+    SDL_Log("Setting init state %d", state);
+#endif
+    ctx->init_state = state;
+}
+
+static Uint8 GetNextPacketSequence(SDL_DriverXboxOne_Context *ctx)
+{
+    ++ctx->sequence;
+    if (!ctx->sequence) {
+        ctx->sequence = 1;
+    }
+    return ctx->sequence;
+}
+
+static bool SendProtocolPacket(SDL_DriverXboxOne_Context *ctx, const Uint8 *data, int size)
+{
+#ifdef DEBUG_XBOX_PROTOCOL
+    HIDAPI_DumpPacket("Xbox One sending packet: size = %d", data, size);
+#endif
+
+    ctx->send_time = SDL_GetTicks();
+
+    if (!SDL_HIDAPI_LockRumble()) {
+        return false;
+    }
+    if (SDL_HIDAPI_SendRumbleAndUnlock(ctx->device, data, size) != size) {
+        return false;
+    }
+    return true;
+}
+
+#if 0
+static bool SendSerialRequest(SDL_DriverXboxOne_Context *ctx)
+{
+    Uint8 packet[] = { 0x1E, 0x20, 0x00, 0x01, 0x04 };
+
+    packet[2] = GetNextPacketSequence(ctx);
+
+    /* Request the serial number
+     * Sending this should be done only after startup is complete.
+     * It will cancel the announce packet if sent before that, and will be
+     * ignored if sent during the startup sequence.
+     */
+    if (!SendProtocolPacket(ctx, packet, sizeof(packet))) {
+        SDL_SetError("Couldn't send serial request packet");
+        return false;
+    }
+    return true;
+}
+#endif
+
+static bool ControllerSendsAnnouncement(Uint16 vendor_id, Uint16 product_id)
+{
+    if (vendor_id == USB_VENDOR_PDP && product_id == 0x0246) {
+        // The PDP Rock Candy (PID 0x0246) doesn't send the announce packet on Linux for some reason
+        return false;
+    }
+    return true;
+}
+
+static bool SendIdentificationRequest(SDL_DriverXboxOne_Context *ctx)
+{
+    // Request identification, sent in response to announce packet
+    Uint8 packet[] = {
+        0x04, 0x20, 0x00, 0x00
+    };
+
+    packet[2] = GetNextPacketSequence(ctx);
+
+    if (!SendProtocolPacket(ctx, packet, sizeof(packet))) {
+        SDL_SetError("Couldn't send identification request packet");
+        return false;
+    }
+    return true;
+}
+
+static bool SendControllerStartup(SDL_DriverXboxOne_Context *ctx)
+{
+    Uint16 vendor_id = ctx->vendor_id;
+    Uint16 product_id = ctx->product_id;
+    Uint8 init_packet[USB_PACKET_LENGTH];
+    size_t i;
+
+    for (i = 0; i < SDL_arraysize(xboxone_init_packets); ++i) {
+        const SDL_DriverXboxOne_InitPacket *packet = &xboxone_init_packets[i];
+
+        if (packet->vendor_id && (vendor_id != packet->vendor_id)) {
+            continue;
+        }
+
+        if (packet->product_id && (product_id != packet->product_id)) {
+            continue;
+        }
+
+        SDL_memcpy(init_packet, packet->data, packet->size);
+        init_packet[2] = GetNextPacketSequence(ctx);
+
+        if (init_packet[0] == 0x0A) {
+            // Get the initial brightness value
+            int brightness = GetHomeLEDBrightness(SDL_GetHint(SDL_HINT_JOYSTICK_HIDAPI_XBOX_ONE_HOME_LED));
+            init_packet[5] = (brightness > 0) ? 0x01 : 0x00;
+            init_packet[6] = (Uint8)brightness;
+        }
+
+        if (!SendProtocolPacket(ctx, init_packet, packet->size)) {
+            SDL_SetError("Couldn't send initialization packet");
+            return false;
+        }
+
+        // Wait to process the rumble packet
+        if (packet->data == xbox_init_powera_rumble) {
+            SDL_Delay(10);
+        }
+    }
+    return true;
+}
+
+static void HIDAPI_DriverXboxOne_RegisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_XBOX, callback, userdata);
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_XBOX_ONE, callback, userdata);
+}
+
+static void HIDAPI_DriverXboxOne_UnregisterHints(SDL_HintCallback callback, void *userdata)
+{
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_XBOX, callback, userdata);
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_XBOX_ONE, callback, userdata);
+}
+
+static bool HIDAPI_DriverXboxOne_IsEnabled(void)
+{
+    return SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_XBOX_ONE,
+                              SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI_XBOX, SDL_GetHintBoolean(SDL_HINT_JOYSTICK_HIDAPI, SDL_HIDAPI_DEFAULT)));
+}
+
+static bool HIDAPI_DriverXboxOne_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 defined(SDL_PLATFORM_MACOS) && defined(SDL_JOYSTICK_MFI)
+    if (!SDL_IsJoystickBluetoothXboxOne(vendor_id, product_id)) {
+        // On macOS we get a shortened version of the real report and
+        // you can't write output reports for wired controllers, so
+        // we'll just use the GCController support instead.
+        return false;
+    }
+#endif
+    return (type == SDL_GAMEPAD_TYPE_XBOXONE);
+}
+
+static bool HIDAPI_DriverXboxOne_InitDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverXboxOne_Context *ctx;
+
+    ctx = (SDL_DriverXboxOne_Context *)SDL_calloc(1, sizeof(*ctx));
+    if (!ctx) {
+        return false;
+    }
+    ctx->device = device;
+
+    device->context = ctx;
+
+    ctx->vendor_id = device->vendor_id;
+    ctx->product_id = device->product_id;
+    ctx->start_time = SDL_GetTicks();
+    ctx->sequence = 0;
+    ctx->has_color_led = ControllerHasColorLED(ctx->vendor_id, ctx->product_id);
+    ctx->has_paddles = ControllerHasPaddles(ctx->vendor_id, ctx->product_id);
+    ctx->has_trigger_rumble = ControllerHasTriggerRumble(ctx->vendor_id, ctx->product_id);
+    ctx->has_share_button = ControllerHasShareButton(ctx->vendor_id, ctx->product_id);
+
+    // Assume that the controller is correctly initialized when we start
+    if (!ControllerSendsAnnouncement(device->vendor_id, device->product_id)) {
+        // Jump into the startup sequence for this controller
+        ctx->init_state = XBOX_ONE_INIT_STATE_STARTUP;
+    } else {
+        ctx->init_state = XBOX_ONE_INIT_STATE_COMPLETE;
+    }
+
+#ifdef DEBUG_JOYSTICK
+    SDL_Log("Controller version: %d (0x%.4x)", device->version, device->version);
+#endif
+
+    device->type = SDL_GAMEPAD_TYPE_XBOXONE;
+
+    return HIDAPI_JoystickConnected(device, NULL);
+}
+
+static int HIDAPI_DriverXboxOne_GetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id)
+{
+    return -1;
+}
+
+static void HIDAPI_DriverXboxOne_SetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id, int player_index)
+{
+}
+
+static bool HIDAPI_DriverXboxOne_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverXboxOne_Context *ctx = (SDL_DriverXboxOne_Context *)device->context;
+
+    SDL_AssertJoysticksLocked();
+
+    ctx->low_frequency_rumble = 0;
+    ctx->high_frequency_rumble = 0;
+    ctx->left_trigger_rumble = 0;
+    ctx->right_trigger_rumble = 0;
+    ctx->rumble_state = XBOX_ONE_RUMBLE_STATE_IDLE;
+    ctx->rumble_time = 0;
+    ctx->rumble_pending = false;
+    SDL_zeroa(ctx->last_state);
+
+    // Initialize the joystick capabilities
+    joystick->nbuttons = 11;
+    if (ctx->has_share_button) {
+        joystick->nbuttons += 1;
+    }
+    if (ctx->has_paddles) {
+        joystick->nbuttons += 4;
+    }
+    joystick->naxes = SDL_GAMEPAD_AXIS_COUNT;
+    joystick->nhats = 1;
+
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_XBOX_ONE_HOME_LED,
+                        SDL_HomeLEDHintChanged, ctx);
+    return true;
+}
+
+static void HIDAPI_DriverXboxOne_RumbleSent(void *userdata)
+{
+    SDL_DriverXboxOne_Context *ctx = (SDL_DriverXboxOne_Context *)userdata;
+    ctx->rumble_time = SDL_GetTicks();
+}
+
+static bool HIDAPI_DriverXboxOne_UpdateRumble(SDL_DriverXboxOne_Context *ctx)
+{
+    if (ctx->rumble_state == XBOX_ONE_RUMBLE_STATE_QUEUED) {
+        if (ctx->rumble_time) {
+            ctx->rumble_state = XBOX_ONE_RUMBLE_STATE_BUSY;
+        }
+    }
+
+    if (ctx->rumble_state == XBOX_ONE_RUMBLE_STATE_BUSY) {
+        const int RUMBLE_BUSY_TIME_MS = ctx->device->is_bluetooth ? 50 : 10;
+        if (SDL_GetTicks() >= (ctx->rumble_time + RUMBLE_BUSY_TIME_MS)) {
+            ctx->rumble_time = 0;
+            ctx->rumble_state = XBOX_ONE_RUMBLE_STATE_IDLE;
+        }
+    }
+
+    if (!ctx->rumble_pending) {
+        return true;
+    }
+
+    if (ctx->rumble_state != XBOX_ONE_RUMBLE_STATE_IDLE) {
+        return true;
+    }
+
+    // We're no longer pending, even if we fail to send the rumble below
+    ctx->rumble_pending = false;
+
+    if (!SDL_HIDAPI_LockRumble()) {
+        return false;
+    }
+
+    if (ctx->device->is_bluetooth) {
+        Uint8 rumble_packet[] = { 0x03, 0x0F, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xEB };
+
+        rumble_packet[2] = ctx->left_trigger_rumble;
+        rumble_packet[3] = ctx->right_trigger_rumble;
+        rumble_packet[4] = ctx->low_frequency_rumble;
+        rumble_packet[5] = ctx->high_frequency_rumble;
+
+        if (SDL_HIDAPI_SendRumbleWithCallbackAndUnlock(ctx->device, rumble_packet, sizeof(rumble_packet), HIDAPI_DriverXboxOne_RumbleSent, ctx) != sizeof(rumble_packet)) {
+            return SDL_SetError("Couldn't send rumble packet");
+        }
+    } else {
+        Uint8 rumble_packet[] = { 0x09, 0x00, 0x00, 0x09, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xEB };
+
+        rumble_packet[6] = ctx->left_trigger_rumble;
+        rumble_packet[7] = ctx->right_trigger_rumble;
+        rumble_packet[8] = ctx->low_frequency_rumble;
+        rumble_packet[9] = ctx->high_frequency_rumble;
+
+        if (SDL_HIDAPI_SendRumbleWithCallbackAndUnlock(ctx->device, rumble_packet, sizeof(rumble_packet), HIDAPI_DriverXboxOne_RumbleSent, ctx) != sizeof(rumble_packet)) {
+            return SDL_SetError("Couldn't send rumble packet");
+        }
+    }
+
+    ctx->rumble_state = XBOX_ONE_RUMBLE_STATE_QUEUED;
+
+    return true;
+}
+
+static bool HIDAPI_DriverXboxOne_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+    SDL_DriverXboxOne_Context *ctx = (SDL_DriverXboxOne_Context *)device->context;
+
+    // Magnitude is 1..100 so scale the 16-bit input here
+    ctx->low_frequency_rumble = (Uint8)(low_frequency_rumble / 655);
+    ctx->high_frequency_rumble = (Uint8)(high_frequency_rumble / 655);
+    ctx->rumble_pending = true;
+
+    return HIDAPI_DriverXboxOne_UpdateRumble(ctx);
+}
+
+static bool HIDAPI_DriverXboxOne_RumbleJoystickTriggers(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
+{
+    SDL_DriverXboxOne_Context *ctx = (SDL_DriverXboxOne_Context *)device->context;
+
+    if (!ctx->has_trigger_rumble) {
+        return SDL_Unsupported();
+    }
+
+    // Magnitude is 1..100 so scale the 16-bit input here
+    ctx->left_trigger_rumble = (Uint8)(left_rumble / 655);
+    ctx->right_trigger_rumble = (Uint8)(right_rumble / 655);
+    ctx->rumble_pending = true;
+
+    return HIDAPI_DriverXboxOne_UpdateRumble(ctx);
+}
+
+static Uint32 HIDAPI_DriverXboxOne_GetJoystickCapabilities(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverXboxOne_Context *ctx = (SDL_DriverXboxOne_Context *)device->context;
+    Uint32 result = 0;
+
+    result |= SDL_JOYSTICK_CAP_RUMBLE;
+    if (ctx->has_trigger_rumble) {
+        result |= SDL_JOYSTICK_CAP_TRIGGER_RUMBLE;
+    }
+
+    if (ctx->has_color_led) {
+        result |= SDL_JOYSTICK_CAP_RGB_LED;
+    }
+
+    return result;
+}
+
+static bool HIDAPI_DriverXboxOne_SetJoystickLED(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    SDL_DriverXboxOne_Context *ctx = (SDL_DriverXboxOne_Context *)device->context;
+
+    if (ctx->has_color_led) {
+        Uint8 led_packet[] = { 0x0E, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+        led_packet[5] = 0x00; // Whiteness? Sets white intensity when RGB is 0, seems additive
+        led_packet[6] = red;
+        led_packet[7] = green;
+        led_packet[8] = blue;
+
+        if (SDL_HIDAPI_SendRumble(device, led_packet, sizeof(led_packet)) != sizeof(led_packet)) {
+            return SDL_SetError("Couldn't send LED packet");
+        }
+        return true;
+    } else {
+        return SDL_Unsupported();
+    }
+}
+
+static bool HIDAPI_DriverXboxOne_SendJoystickEffect(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *data, int size)
+{
+    return SDL_Unsupported();
+}
+
+static bool HIDAPI_DriverXboxOne_SetJoystickSensorsEnabled(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, bool enabled)
+{
+    return SDL_Unsupported();
+}
+
+/*
+ * The Xbox One Elite controller with 5.13+ firmware sends the unmapped state in a separate packet.
+ * We can use this to send the paddle state when they aren't mapped
+ */
+static void HIDAPI_DriverXboxOne_HandleUnmappedStatePacket(SDL_Joystick *joystick, SDL_DriverXboxOne_Context *ctx, Uint8 *data, int size)
+{
+    Uint8 profile;
+    int paddle_index;
+    int button1_bit;
+    int button2_bit;
+    int button3_bit;
+    int button4_bit;
+    bool paddles_mapped;
+    Uint64 timestamp = SDL_GetTicksNS();
+
+    if (size == 17) {
+        // XBox One Elite Series 2
+        paddle_index = 14;
+        button1_bit = 0x01;
+        button2_bit = 0x02;
+        button3_bit = 0x04;
+        button4_bit = 0x08;
+        profile = data[15];
+
+        if (profile == 0) {
+            paddles_mapped = false;
+        } else if (SDL_memcmp(&data[0], &ctx->last_state[0], 14) == 0) {
+            // We're using a profile, but paddles aren't mapped
+            paddles_mapped = false;
+        } else {
+            // Something is mapped, we can't use the paddles
+            paddles_mapped = true;
+        }
+
+    } else {
+        // Unknown format
+        return;
+    }
+#ifdef DEBUG_XBOX_PROTOCOL
+    SDL_Log(">>> Paddles: %d,%d,%d,%d mapped = %s",
+            (data[paddle_index] & button1_bit) ? 1 : 0,
+            (data[paddle_index] & button2_bit) ? 1 : 0,
+            (data[paddle_index] & button3_bit) ? 1 : 0,
+            (data[paddle_index] & button4_bit) ? 1 : 0,
+            paddles_mapped ? "TRUE" : "FALSE");
+#endif
+
+    if (paddles_mapped) {
+        // Respect that the paddles are being used for other controls and don't pass them on to the app
+        data[paddle_index] = 0;
+    }
+
+    if (ctx->last_paddle_state != data[paddle_index]) {
+        Uint8 nButton = (Uint8)(SDL_GAMEPAD_BUTTON_XBOX_SHARE_BUTTON + ctx->has_share_button); // Next available button
+        SDL_SendJoystickButton(timestamp, joystick, nButton++, ((data[paddle_index] & button1_bit) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, nButton++, ((data[paddle_index] & button2_bit) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, nButton++, ((data[paddle_index] & button3_bit) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, nButton++, ((data[paddle_index] & button4_bit) != 0));
+        ctx->last_paddle_state = data[paddle_index];
+    }
+    ctx->has_unmapped_state = true;
+}
+
+static void HIDAPI_DriverXboxOne_HandleStatePacket(SDL_Joystick *joystick, SDL_DriverXboxOne_Context *ctx, Uint8 *data, int size)
+{
+    Sint16 axis;
+    Uint64 timestamp = SDL_GetTicksNS();
+
+    // Enable paddles on the Xbox Elite controller when connected over USB
+    if (ctx->has_paddles && !ctx->has_unmapped_state && size == 46) {
+        Uint8 packet[] = { 0x4d, 0x00, 0x00, 0x02, 0x07, 0x00 };
+
+#ifdef DEBUG_JOYSTICK
+        SDL_Log("Enabling paddles on XBox Elite 2");
+#endif
+        SDL_HIDAPI_SendRumble(ctx->device, packet, sizeof(packet));
+    }
+
+    if (ctx->last_state[0] != data[0]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data[0] & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK, ((data[0] & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SOUTH, ((data[0] & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_EAST, ((data[0] & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_WEST, ((data[0] & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_NORTH, ((data[0] & 0x80) != 0));
+    }
+
+    if (ctx->last_state[1] != data[1]) {
+        Uint8 hat = 0;
+
+        if (data[1] & 0x01) {
+            hat |= SDL_HAT_UP;
+        }
+        if (data[1] & 0x02) {
+            hat |= SDL_HAT_DOWN;
+        }
+        if (data[1] & 0x04) {
+            hat |= SDL_HAT_LEFT;
+        }
+        if (data[1] & 0x08) {
+            hat |= SDL_HAT_RIGHT;
+        }
+        SDL_SendJoystickHat(timestamp, joystick, 0, hat);
+
+        if (ctx->vendor_id == USB_VENDOR_RAZER && ctx->product_id == USB_PRODUCT_RAZER_ATROX) {
+            // The Razer Atrox has the right and left shoulder bits reversed
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data[1] & 0x20) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data[1] & 0x10) != 0));
+        } else {
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data[1] & 0x10) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data[1] & 0x20) != 0));
+        }
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data[1] & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_STICK, ((data[1] & 0x80) != 0));
+    }
+
+    if (ctx->has_share_button) {
+        /* Xbox Series X firmware version 5.0, report is 32 bytes, share button is in byte 14
+         * Xbox Series X firmware version 5.1, report is 40 bytes, share button is in byte 14
+         * Xbox Series X firmware version 5.5, report is 44 bytes, share button is in byte 18
+         * Victrix Gambit Tournament Controller, report is 46 bytes, share button is in byte 28
+         * ThrustMaster eSwap PRO Controller Xbox, report is 60 bytes, share button is in byte 42
+         */
+        if (size < 44) {
+            if (ctx->last_state[14] != data[14]) {
+                SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_XBOX_SHARE_BUTTON, ((data[14] & 0x01) != 0));
+            }
+        } else if (size == 44) {
+            if (ctx->last_state[18] != data[18]) {
+                SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_XBOX_SHARE_BUTTON, ((data[18] & 0x01) != 0));
+            }
+        } else if (size == 46) {
+            if (ctx->last_state[28] != data[28]) {
+                SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_XBOX_SHARE_BUTTON, ((data[28] & 0x01) != 0));
+            }
+        } else if (size == 60) {
+            if (ctx->last_state[42] != data[42]) {
+                SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_XBOX_SHARE_BUTTON, ((data[42] & 0x01) != 0));
+            }
+        }
+    }
+
+    /* Xbox One S report is 14 bytes
+       Xbox One Elite Series 1 report is 29 bytes, paddles in data[28], mode in data[28] & 0x10, both modes have mapped paddles by default
+        Paddle bits:
+            P3: 0x01 (A)    P1: 0x02 (B)
+            P4: 0x04 (X)    P2: 0x08 (Y)
+       Xbox One Elite Series 2 4.x firmware report is 34 bytes, paddles in data[14], mode in data[15], mode 0 has no mapped paddles by default
+        Paddle bits:
+            P3: 0x04 (A)    P1: 0x01 (B)
+            P4: 0x08 (X)    P2: 0x02 (Y)
+       Xbox One Elite Series 2 5.x firmware report is 46 bytes, paddles in data[18], mode in data[19], mode 0 has no mapped paddles by default
+        Paddle bits:
+            P3: 0x04 (A)    P1: 0x01 (B)
+            P4: 0x08 (X)    P2: 0x02 (Y)
+       Xbox One Elite Series 2 5.17+ firmware report is 47 bytes, paddles in data[14], mode in data[20], mode 0 has no mapped paddles by default
+        Paddle bits:
+            P3: 0x04 (A)    P1: 0x01 (B)
+            P4: 0x08 (X)    P2: 0x02 (Y)
+    */
+    if (ctx->has_paddles && !ctx->has_unmapped_state && (size == 29 || size == 34 || size == 46 || size == 47)) {
+        int paddle_index;
+        int button1_bit;
+        int button2_bit;
+        int button3_bit;
+        int button4_bit;
+        bool paddles_mapped;
+
+        if (size == 29) {
+            // XBox One Elite Series 1
+            paddle_index = 28;
+            button1_bit = 0x02;
+            button2_bit = 0x08;
+            button3_bit = 0x01;
+            button4_bit = 0x04;
+
+            // The mapped controller state is at offset 0, the raw state is at offset 14, compare them to see if the paddles are mapped
+            paddles_mapped = (SDL_memcmp(&data[0], &data[14], 2) != 0);
+
+        } else if (size == 34) {
+            // XBox One Elite Series 2
+            paddle_index = 14;
+            button1_bit = 0x01;
+            button2_bit = 0x02;
+            button3_bit = 0x04;
+            button4_bit = 0x08;
+            paddles_mapped = (data[15] != 0);
+
+        } else if (size == 46) {
+            // XBox One Elite Series 2
+            paddle_index = 18;
+            button1_bit = 0x01;
+            button2_bit = 0x02;
+            button3_bit = 0x04;
+            button4_bit = 0x08;
+            paddles_mapped = (data[19] != 0);
+        } else /* if (size == 47) */ {
+            // XBox One Elite Series 2
+            paddle_index = 14;
+            button1_bit = 0x01;
+            button2_bit = 0x02;
+            button3_bit = 0x04;
+            button4_bit = 0x08;
+            paddles_mapped = (data[20] != 0);
+        }
+#ifdef DEBUG_XBOX_PROTOCOL
+        SDL_Log(">>> Paddles: %d,%d,%d,%d mapped = %s",
+                (data[paddle_index] & button1_bit) ? 1 : 0,
+                (data[paddle_index] & button2_bit) ? 1 : 0,
+                (data[paddle_index] & button3_bit) ? 1 : 0,
+                (data[paddle_index] & button4_bit) ? 1 : 0,
+                paddles_mapped ? "TRUE" : "FALSE");
+#endif
+
+        if (paddles_mapped) {
+            // Respect that the paddles are being used for other controls and don't pass them on to the app
+            data[paddle_index] = 0;
+        }
+
+        if (ctx->last_paddle_state != data[paddle_index]) {
+            Uint8 nButton = (Uint8)(SDL_GAMEPAD_BUTTON_XBOX_SHARE_BUTTON + ctx->has_share_button); // Next available button
+            SDL_SendJoystickButton(timestamp, joystick, nButton++, ((data[paddle_index] & button1_bit) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, nButton++, ((data[paddle_index] & button2_bit) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, nButton++, ((data[paddle_index] & button3_bit) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, nButton++, ((data[paddle_index] & button4_bit) != 0));
+            ctx->last_paddle_state = data[paddle_index];
+        }
+    }
+
+    axis = ((int)SDL_Swap16LE(*(Sint16 *)(&data[2])) * 64) - 32768;
+    if (axis == 32704) {
+        axis = 32767;
+    }
+    if (axis == -32768 && size == 26 && (data[18] & 0x80)) {
+        axis = 32767;
+    }
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, axis);
+
+    axis = ((int)SDL_Swap16LE(*(Sint16 *)(&data[4])) * 64) - 32768;
+    if (axis == -32768 && size == 26 && (data[18] & 0x40)) {
+        axis = 32767;
+    }
+    if (axis == 32704) {
+        axis = 32767;
+    }
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, axis);
+
+    axis = SDL_Swap16LE(*(Sint16 *)(&data[6]));
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, axis);
+    axis = SDL_Swap16LE(*(Sint16 *)(&data[8]));
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, ~axis);
+    axis = SDL_Swap16LE(*(Sint16 *)(&data[10]));
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, axis);
+    axis = SDL_Swap16LE(*(Sint16 *)(&data[12]));
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, ~axis);
+
+    SDL_memcpy(ctx->last_state, data, SDL_min(size, sizeof(ctx->last_state)));
+
+    // We don't have the unmapped state for this packet
+    ctx->has_unmapped_state = false;
+}
+
+static void HIDAPI_DriverXboxOne_HandleStatusPacket(SDL_DriverXboxOne_Context *ctx, const Uint8 *data, int size)
+{
+    if (ctx->init_state < XBOX_ONE_INIT_STATE_COMPLETE) {
+        SetInitState(ctx, XBOX_ONE_INIT_STATE_COMPLETE);
+    }
+}
+
+static void HIDAPI_DriverXboxOne_HandleModePacket(SDL_Joystick *joystick, SDL_DriverXboxOne_Context *ctx, const Uint8 *data, int size)
+{
+    Uint64 timestamp = SDL_GetTicksNS();
+
+    SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data[0] & 0x01) != 0));
+}
+
+/*
+ * Xbox One S with firmware 3.1.1221 uses a 16 byte packet and the GUIDE button in a separate packet
+ */
+static void HIDAPI_DriverXboxOneBluetooth_HandleButtons16(Uint64 timestamp, SDL_Joystick *joystick, SDL_DriverXboxOne_Context *ctx, const Uint8 *data, int size)
+{
+    if (ctx->last_state[14] != data[14]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SOUTH, ((data[14] & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_EAST, ((data[14] & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_WEST, ((data[14] & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_NORTH, ((data[14] & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data[14] & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data[14] & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK, ((data[14] & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data[14] & 0x80) != 0));
+    }
+
+    if (ctx->last_state[15] != data[15]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data[15] & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_STICK, ((data[15] & 0x02) != 0));
+    }
+}
+
+/*
+ * Xbox One S with firmware 4.8.1923 uses a 17 byte packet with BACK button in byte 16 and the GUIDE button in a separate packet (on Windows), or in byte 15 (on Linux)
+ * Xbox One S with firmware 5.x uses a 17 byte packet with BACK and GUIDE buttons in byte 15
+ * Xbox One Elite Series 2 with firmware 4.7.1872 uses a 55 byte packet with BACK button in byte 16, paddles starting at byte 33, and the GUIDE button in a separate packet
+ * Xbox One Elite Series 2 with firmware 4.8.1908 uses a 33 byte packet with BACK button in byte 16, paddles starting at byte 17, and the GUIDE button in a separate packet
+ * Xbox One Elite Series 2 with firmware 5.11.3112 uses a 19 byte packet with BACK and GUIDE buttons in byte 15
+ * Xbox Series X with firmware 5.5.2641 uses a 17 byte packet with BACK and GUIDE buttons in byte 15, and SHARE button in byte 17
+ */
+static void HIDAPI_DriverXboxOneBluetooth_HandleButtons(Uint64 timestamp, SDL_Joystick *joystick, SDL_DriverXboxOne_Context *ctx, Uint8 *data, int size)
+{
+    if (ctx->last_state[14] != data[14]) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_SOUTH, ((data[14] & 0x01) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_EAST, ((data[14] & 0x02) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_WEST, ((data[14] & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_NORTH, ((data[14] & 0x10) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, ((data[14] & 0x40) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, ((data[14] & 0x80) != 0));
+    }
+
+    if (ctx->last_state[15] != data[15]) {
+        if (!ctx->has_guide_packet) {
+            SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data[15] & 0x10) != 0));
+        }
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_START, ((data[15] & 0x08) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_LEFT_STICK, ((data[15] & 0x20) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_RIGHT_STICK, ((data[15] & 0x40) != 0));
+    }
+
+    if (ctx->has_share_button) {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK, ((data[15] & 0x04) != 0));
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_XBOX_SHARE_BUTTON, ((data[16] & 0x01) != 0));
+    } else {
+        SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK, ((data[15] & 0x04) || ((data[16] & 0x01)) != 0));
+    }
+
+    /*
+        Paddle bits:
+            P3: 0x04 (A)    P1: 0x01 (B)
+            P4: 0x08 (X)    P2: 0x02 (Y)
+    */
+    if (ctx->has_paddles && (size == 20 || size == 39 || size == 55)) {
+        int paddle_index;
+        int button1_bit;
+        int button2_bit;
+        int button3_bit;
+        int button4_bit;
+        bool paddles_mapped;
+
+        if (size == 55) {
+            // Initial firmware for the Xbox Elite Series 2 controller
+            paddle_index = 33;
+            button1_bit = 0x01;
+            button2_bit = 0x02;
+            button3_bit = 0x04;
+            button4_bit = 0x08;
+            paddles_mapped = (data[35] != 0);
+        } else if (size == 39) {
+            // Updated firmware for the Xbox Elite Series 2 controller
+            paddle_index = 17;
+            button1_bit = 0x01;
+            button2_bit = 0x02;
+            button3_bit = 0x04;
+            button4_bit = 0x08;
+            paddles_mapped = (data[19] != 0);
+        } else /* if (size == 20) */ {
+            // Updated firmware for the Xbox Elite Series 2 controller (5.13+)
+            paddle_index = 19;
+            button1_bit = 0x01;
+            button2_bit = 0x02;
+            button3_bit = 0x04;
+            button4_bit = 0x08;
+            paddles_mapped = (data[17] != 0);
+        }
+
+#ifdef DEBUG_XBOX_PROTOCOL
+        SDL_Log(">>> Paddles: %d,%d,%d,%d mapped = %s",
+                (data[paddle_index] & button1_bit) ? 1 : 0,
+                (data[paddle_index] & button2_bit) ? 1 : 0,
+                (data[paddle_index] & button3_bit) ? 1 : 0,
+                (data[paddle_index] & button4_bit) ? 1 : 0,
+                paddles_mapped ? "TRUE" : "FALSE");
+#endif
+
+        if (paddles_mapped) {
+            // Respect that the paddles are being used for other controls and don't pass them on to the app
+            data[paddle_index] = 0;
+        }
+
+        if (ctx->last_paddle_state != data[paddle_index]) {
+            Uint8 nButton = SDL_GAMEPAD_BUTTON_XBOX_SHARE_BUTTON; // Next available button
+            SDL_SendJoystickButton(timestamp, joystick, nButton++, ((data[paddle_index] & button1_bit) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, nButton++, ((data[paddle_index] & button2_bit) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, nButton++, ((data[paddle_index] & button3_bit) != 0));
+            SDL_SendJoystickButton(timestamp, joystick, nButton++, ((data[paddle_index] & button4_bit) != 0));
+            ctx->last_paddle_state = data[paddle_index];
+        }
+    }
+}
+
+static void HIDAPI_DriverXboxOneBluetooth_HandleStatePacket(SDL_Joystick *joystick, SDL_DriverXboxOne_Context *ctx, Uint8 *data, int size)
+{
+    Sint16 axis;
+    Uint64 timestamp = SDL_GetTicksNS();
+
+    if (size == 16) {
+        // Original Xbox One S, with separate report for guide button
+        HIDAPI_DriverXboxOneBluetooth_HandleButtons16(timestamp, joystick, ctx, data, size);
+    } else if (size > 16) {
+        HIDAPI_DriverXboxOneBluetooth_HandleButtons(timestamp, joystick, ctx, data, size);
+    } else {
+#ifdef DEBUG_XBOX_PROTOCOL
+        SDL_Log("Unknown Bluetooth state packet format");
+#endif
+        return;
+    }
+
+    if (ctx->last_state[13] != data[13]) {
+        Uint8 hat;
+
+        switch (data[13]) {
+        case 1:
+            hat = SDL_HAT_UP;
+            break;
+        case 2:
+            hat = SDL_HAT_RIGHTUP;
+            break;
+        case 3:
+            hat = SDL_HAT_RIGHT;
+            break;
+        case 4:
+            hat = SDL_HAT_RIGHTDOWN;
+            break;
+        case 5:
+            hat = SDL_HAT_DOWN;
+            break;
+        case 6:
+            hat = SDL_HAT_LEFTDOWN;
+            break;
+        case 7:
+            hat = SDL_HAT_LEFT;
+            break;
+        case 8:
+            hat = SDL_HAT_LEFTUP;
+            break;
+        default:
+            hat = SDL_HAT_CENTERED;
+            break;
+        }
+        SDL_SendJoystickHat(timestamp, joystick, 0, hat);
+    }
+
+    axis = ((int)SDL_Swap16LE(*(Sint16 *)(&data[9])) * 64) - 32768;
+    if (axis == 32704) {
+        axis = 32767;
+    }
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, axis);
+
+    axis = ((int)SDL_Swap16LE(*(Sint16 *)(&data[11])) * 64) - 32768;
+    if (axis == 32704) {
+        axis = 32767;
+    }
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, axis);
+
+    axis = (int)SDL_Swap16LE(*(Uint16 *)(&data[1])) - 0x8000;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, axis);
+    axis = (int)SDL_Swap16LE(*(Uint16 *)(&data[3])) - 0x8000;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, axis);
+    axis = (int)SDL_Swap16LE(*(Uint16 *)(&data[5])) - 0x8000;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, axis);
+    axis = (int)SDL_Swap16LE(*(Uint16 *)(&data[7])) - 0x8000;
+    SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, axis);
+
+    SDL_memcpy(ctx->last_state, data, SDL_min(size, sizeof(ctx->last_state)));
+}
+
+static void HIDAPI_DriverXboxOneBluetooth_HandleGuidePacket(SDL_Joystick *joystick, SDL_DriverXboxOne_Context *ctx, const Uint8 *data, int size)
+{
+    Uint64 timestamp = SDL_GetTicksNS();
+
+    ctx->has_guide_packet = true;
+    SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, ((data[1] & 0x01) != 0));
+}
+
+static void HIDAPI_DriverXboxOneBluetooth_HandleBatteryPacket(SDL_Joystick *joystick, SDL_DriverXboxOne_Context *ctx, const Uint8 *data, int size)
+{
+    Uint8 flags = data[1];
+    bool on_usb = (((flags & 0x0C) >> 2) == 0);
+    SDL_PowerState state;
+    int percent = 0;
+
+    // Mapped percentage value from:
+    // https://learn.microsoft.com/en-us/gaming/gdk/_content/gc/reference/input/gameinput/interfaces/igameinputdevice/methods/igameinputdevice_getbatterystate
+    switch (flags & 0x03) {
+    case 0:
+        percent = 10;
+        break;
+    case 1:
+        percent = 40;
+        break;
+    case 2:
+        percent = 70;
+        break;
+    case 3:
+        percent = 100;
+        break;
+    }
+    if (on_usb) {
+        state = SDL_POWERSTATE_CHARGING;
+    } else {
+        state = SDL_POWERSTATE_ON_BATTERY;
+    }
+    SDL_SendJoystickPowerInfo(joystick, state, percent);
+}
+
+static void HIDAPI_DriverXboxOne_HandleSerialIDPacket(SDL_DriverXboxOne_Context *ctx, const Uint8 *data, int size)
+{
+    char serial[29];
+    int i;
+
+    for (i = 0; i < 14; ++i) {
+        SDL_uitoa(data[2 + i], &serial[i * 2], 16);
+    }
+    serial[i * 2] = '\0';
+
+#ifdef DEBUG_JOYSTICK
+    SDL_Log("Setting serial number to %s", serial);
+#endif
+    HIDAPI_SetDeviceSerial(ctx->device, serial);
+}
+
+static bool HIDAPI_DriverXboxOne_UpdateInitState(SDL_DriverXboxOne_Context *ctx)
+{
+    SDL_XboxOneInitState prev_state;
+    do {
+        prev_state = ctx->init_state;
+
+        switch (ctx->init_state) {
+        case XBOX_ONE_INIT_STATE_ANNOUNCED:
+            if (XBOX_ONE_DRIVER_ACTIVE) {
+                // The driver is taking care of identification
+                SetInitState(ctx, XBOX_ONE_INIT_STATE_COMPLETE);
+            } else {
+                SendIdentificationRequest(ctx);
+                SetInitState(ctx, XBOX_ONE_INIT_STATE_IDENTIFYING);
+            }
+            break;
+        case XBOX_ONE_INIT_STATE_IDENTIFYING:
+            if (SDL_GetTicks() >= (ctx->send_time + CONTROLLER_IDENTIFY_TIMEOUT_MS)) {
+                // We haven't heard anything, let's move on
+#ifdef DEBUG_JOYSTICK
+                SDL_Log("Identification request timed out after %llu ms", (SDL_GetTicks() - ctx->send_time));
+#endif
+                SetInitState(ctx, XBOX_ONE_INIT_STATE_STARTUP);
+            }
+            break;
+        case XBOX_ONE_INIT_STATE_STARTUP:
+            if (XBOX_ONE_DRIVER_ACTIVE) {
+                // The driver is taking care of startup
+                SetInitState(ctx, XBOX_ONE_INIT_STATE_COMPLETE);
+            } else {
+                SendControllerStartup(ctx);
+                SetInitState(ctx, XBOX_ONE_INIT_STATE_PREPARE_INPUT);
+            }
+            break;
+        case XBOX_ONE_INIT_STATE_PREPARE_INPUT:
+            if (SDL_GetTicks() >= (ctx->send_time + CONTROLLER_PREPARE_INPUT_TIMEOUT_MS)) {
+#ifdef DEBUG_JOYSTICK
+                SDL_Log("Prepare input complete after %llu ms", (SDL_GetTicks() - ctx->send_time));
+#endif
+                SetInitState(ctx, XBOX_ONE_INIT_STATE_COMPLETE);
+            }
+            break;
+        case XBOX_ONE_INIT_STATE_COMPLETE:
+            break;
+        }
+
+    } while (ctx->init_state != prev_state);
+
+    return true;
+}
+
+/* GIP protocol handling adapted under the Zlib license with permission from @medusalix:
+ * https://github.com/medusalix/xone/blob/master/bus/protocol.h
+ * https://github.com/medusalix/xone/blob/master/bus/protocol.c
+ */
+#define GIP_HEADER_MIN_LENGTH 3
+
+// Internal commands
+#define GIP_CMD_ACKNOWLEDGE     0x01
+#define GIP_CMD_ANNOUNCE        0x02
+#define GIP_CMD_STATUS          0x03
+#define GIP_CMD_IDENTIFY        0x04
+#define GIP_CMD_POWER           0x05
+#define GIP_CMD_AUTHENTICATE    0x06
+#define GIP_CMD_VIRTUAL_KEY     0x07
+#define GIP_CMD_AUDIO_CONTROL   0x08
+#define GIP_CMD_LED             0x0A
+#define GIP_CMD_HID_REPORT      0x0B
+#define GIP_CMD_FIRMWARE        0x0C
+#define GIP_CMD_SERIAL_NUMBER   0x1E
+#define GIP_CMD_AUDIO_SAMPLES   0x60
+
+// External commands
+#define GIP_CMD_RUMBLE          0x09
+#define GIP_CMD_UNMAPPED_STATE  0x0C
+#define GIP_CMD_INPUT           0x20
+
+// Header option flags
+#define GIP_OPT_ACKNOWLEDGE     0x10
+#define GIP_OPT_INTERNAL        0x20
+#define GIP_OPT_CHUNK_START     0x40
+#define GIP_OPT_CHUNK           0x80
+
+#pragma pack(push, 1)
+
+struct gip_header {
+    Uint8 command;
+    Uint8 options;
+    Uint8 sequence;
+    Uint32 packet_length;
+    Uint32 chunk_offset;
+};
+
+struct gip_pkt_acknowledge {
+    Uint8 unknown;
+    Uint8 command;
+    Uint8 options;
+    Uint16 length;
+    Uint8 padding[2];
+    Uint16 remaining;
+};
+
+#pragma pack(pop)
+
+static int EncodeVariableInt(Uint8 *buf, Uint32 val)
+{
+    int i;
+
+    for (i = 0; i < sizeof(val); i++) {
+        buf[i] = (Uint8)val;
+        if (val > 0x7F) {
+            buf[i] |= 0x80;
+        }
+
+        val >>= 7;
+        if (!val) {
+            break;
+        }
+    }
+    return i + 1;
+}
+
+static int DecodeVariableInt(const Uint8 *data, int len, void *out)
+{
+    int i;
+    Uint32 val = 0;
+
+    for (i = 0; i < sizeof(val) && i < len; i++) {
+        val |= (data[i] & 0x7F) << (i * 7);
+
+        if (!(data[i] & 0x80)) {
+            break;
+        }
+    }
+    SDL_memcpy(out, &val, sizeof(val));
+    return i + 1;
+}
+
+static int HIDAPI_GIP_GetActualHeaderLength(struct gip_header *hdr)
+{
+    Uint32 pkt_len = hdr->packet_length;
+    Uint32 chunk_offset = hdr->chunk_offset;
+    int len = GIP_HEADER_MIN_LENGTH;
+
+    do {
+        len++;
+        pkt_len >>= 7;
+    } while (pkt_len);
+
+    if (hdr->options & GIP_OPT_CHUNK) {
+        while (chunk_offset) {
+            len++;
+            chunk_offset >>= 7;
+        }
+    }
+
+    return len;
+}
+
+static int HIDAPI_GIP_GetHeaderLength(struct gip_header *hdr)
+{
+    int len = HIDAPI_GIP_GetActualHeaderLength(hdr);
+
+    // Header length must be even
+    return len + (len % 2);
+}
+
+static void HIDAPI_GIP_EncodeHeader(struct gip_header *hdr, Uint8 *buf)
+{
+    int hdr_len = 0;
+
+    buf[hdr_len++] = hdr->command;
+    buf[hdr_len++] = hdr->options;
+    buf[hdr_len++] = hdr->sequence;
+
+    hdr_len += EncodeVariableInt(buf + hdr_len, hdr->packet_length);
+
+    // Header length must be even
+    if (HIDAPI_GIP_GetActualHeaderLength(hdr) % 2) {
+        buf[hdr_len - 1] |= 0x80;
+        buf[hdr_len++] = 0;
+    }
+
+    if (hdr->options & GIP_OPT_CHUNK) {
+        EncodeVariableInt(buf + hdr_len, hdr->chunk_offset);
+    }
+}
+
+static int HIDAPI_GIP_DecodeHeader(struct gip_header *hdr, const Uint8 *data, int len)
+{
+    int hdr_len = 0;
+
+    hdr->command = data[hdr_len++];
+    hdr->options = data[hdr_len++];
+    hdr->sequence = data[hdr_len++];
+    hdr->packet_length = 0;
+    hdr->chunk_offset = 0;
+
+    hdr_len += DecodeVariableInt(data + hdr_len, len - hdr_len, &hdr->packet_length);
+
+    if (hdr->options & GIP_OPT_CHUNK) {
+        hdr_len += DecodeVariableInt(data + hdr_len, len - hdr_len, &hdr->chunk_offset);
+    }
+    return hdr_len;
+}
+
+static bool HIDAPI_GIP_SendPacket(SDL_DriverXboxOne_Context *ctx, struct gip_header *hdr, const void *data)
+{
+    Uint8 packet[USB_PACKET_LENGTH];
+    int hdr_len, size;
+
+    hdr_len = HIDAPI_GIP_GetHeaderLength(hdr);
+    size = (hdr_len + hdr->packet_length);
+    if (size > sizeof(packet)) {
+        SDL_SetError("Couldn't send GIP packet, size (%d) too large", size);
+        return false;
+    }
+
+    if (!hdr->sequence) {
+        hdr->sequence = GetNextPacketSequence(ctx);
+    }
+
+    HIDAPI_GIP_EncodeHeader(hdr, packet);
+    if (data) {
+        SDL_memcpy(&packet[hdr_len], data, hdr->packet_length);
+    }
+
+    if (!SendProtocolPacket(ctx, packet, size)) {
+        SDL_SetError("Couldn't send protocol packet");
+        return false;
+    }
+    return true;
+}
+
+static bool HIDAPI_GIP_AcknowledgePacket(SDL_DriverXboxOne_Context *ctx, struct gip_header *ack)
+{
+    if (XBOX_ONE_DRIVER_ACTIVE) {
+        // The driver is taking care of acks
+        return true;
+    } else {
+        struct gip_header hdr;
+        struct gip_pkt_acknowledge pkt;
+
+        SDL_zero(hdr);
+        hdr.command = GIP_CMD_ACKNOWLEDGE;
+        hdr.options = GIP_OPT_INTERNAL;
+        hdr.sequence = ack->sequence;
+        hdr.packet_length = sizeof(pkt);
+
+        SDL_zero(pkt);
+        pkt.command = ack->command;
+        pkt.options = GIP_OPT_INTERNAL;
+        pkt.length = SDL_Swap16LE((Uint16)(ack->chunk_offset + ack->packet_length));
+
+        if ((ack->options & GIP_OPT_CHUNK) && ctx->chunk_buffer) {
+            pkt.remaining = SDL_Swap16LE((Uint16)(ctx->chunk_length - pkt.length));
+        }
+
+        return HIDAPI_GIP_SendPacket(ctx, &hdr, &pkt);
+    }
+}
+
+static bool HIDAPI_GIP_DispatchPacket(SDL_Joystick *joystick, SDL_DriverXboxOne_Context *ctx, struct gip_header *hdr, Uint8 *data, Uint32 size)
+{
+    if ((hdr->options & 0x0F) != 0) {
+        // This is a packet for a device plugged into the controller, skip it
+        return true;
+    }
+
+    if (hdr->options & GIP_OPT_INTERNAL) {
+        switch (hdr->command) {
+        case GIP_CMD_ACKNOWLEDGE:
+            // Ignore this packet
+            break;
+        case GIP_CMD_ANNOUNCE:
+            // Controller is connected and waiting for initialization
+            /* The data bytes are:
+               0x02 0x20 NN 0x1c, where NN is the packet sequence
+               then 6 bytes of wireless MAC address
+               then 2 bytes padding
+               then 16-bit VID
+               then 16-bit PID
+               then 16-bit firmware version quartet AA.BB.CC.DD
+                    e.g. 0x05 0x00 0x05 0x00 0x51 0x0a 0x00 0x00
+                         is firmware version 5.5.2641.0, and product version 0x0505 = 1285
+               then 8 bytes of unknown data
+            */
+#ifdef DEBUG_JOYSTICK
+            SDL_Log("Controller announce after %llu ms", (SDL_GetTicks() - ctx->start_time));
+#endif
+            SetInitState(ctx, XBOX_ONE_INIT_STATE_ANNOUNCED);
+            break;
+        case GIP_CMD_STATUS:
+            // Controller status update
+            HIDAPI_DriverXboxOne_HandleStatusPacket(ctx, data, size);
+            break;
+        case GIP_CMD_IDENTIFY:
+#ifdef DEBUG_JOYSTICK
+            SDL_Log("Identification request completed after %llu ms", (SDL_GetTicks() - ctx->send_time));
+#endif
+#ifdef DEBUG_XBOX_PROTOCOL
+            HIDAPI_DumpPacket("Xbox One identification data: size = %d", data, size);
+#endif
+            SetInitState(ctx, XBOX_ONE_INIT_STATE_STARTUP);
+            break;
+        case GIP_CMD_POWER:
+            // Ignore this packet
+            break;
+        case GIP_CMD_AUTHENTICATE:
+            // Ignore this packet
+            break;
+        case GIP_CMD_VIRTUAL_KEY:
+            if (!joystick) {
+                break;
+            }
+            HIDAPI_DriverXboxOne_HandleModePacket(joystick, ctx, data, size);
+            break;
+        case GIP_CMD_SERIAL_NUMBER:
+            /* If the packet starts with this:
+                0x1E 0x30 0x00 0x10 0x04 0x00
+                then the next 14 bytes are the controller serial number
+                    e.g. 0x30 0x39 0x37 0x31 0x32 0x33 0x33 0x32 0x33 0x35 0x34 0x30 0x33 0x36
+                    is serial number "3039373132333332333534303336"
+
+               The controller sends that in response to this request:
+                0x1E 0x20 0x00 0x01 0x04
+            */
+            HIDAPI_DriverXboxOne_HandleSerialIDPacket(ctx, data, size);
+            break;
+        default:
+#ifdef DEBUG_JOYSTICK
+            SDL_Log("Unknown Xbox One packet: 0x%.2x", hdr->command);
+#endif
+            break;
+        }
+    } else {
+        switch (hdr->command) {
+        case GIP_CMD_INPUT:
+            if (ctx->init_state < XBOX_ONE_INIT_STATE_COMPLETE) {
+                SetInitState(ctx, XBOX_ONE_INIT_STATE_COMPLETE);
+
+                // Ignore the first input, it may be spurious
+#ifdef DEBUG_JOYSTICK
+                SDL_Log("Controller ignoring spurious input");
+#endif
+                break;
+            }
+            if (!joystick) {
+                break;
+            }
+            HIDAPI_DriverXboxOne_HandleStatePacket(joystick, ctx, data, size);
+            break;
+        case GIP_CMD_UNMAPPED_STATE:
+            if (!joystick) {
+                break;
+            }
+            HIDAPI_DriverXboxOne_HandleUnmappedStatePacket(joystick, ctx, data, size);
+            break;
+        default:
+#ifdef DEBUG_JOYSTICK
+            SDL_Log("Unknown Xbox One packet: 0x%.2x", hdr->command);
+#endif
+            break;
+        }
+    }
+    return true;
+}
+
+static void HIDAPI_GIP_DestroyChunkBuffer(SDL_DriverXboxOne_Context *ctx)
+{
+    if (ctx->chunk_buffer) {
+        SDL_free(ctx->chunk_buffer);
+        ctx->chunk_buffer = NULL;
+        ctx->chunk_length = 0;
+    }
+}
+
+static bool HIDAPI_GIP_CreateChunkBuffer(SDL_DriverXboxOne_Context *ctx, Uint32 size)
+{
+    HIDAPI_GIP_DestroyChunkBuffer(ctx);
+
+    ctx->chunk_buffer = (Uint8 *)SDL_malloc(size);
+    if (ctx->chunk_buffer) {
+        ctx->chunk_length = size;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+static bool HIDAPI_GIP_ProcessPacketChunked(SDL_Joystick *joystick, SDL_DriverXboxOne_Context *ctx, struct gip_header *hdr, Uint8 *data)
+{
+    bool result;
+
+    if (!ctx->chunk_buffer) {
+        return false;
+    }
+
+    if ((hdr->chunk_offset + hdr->packet_length) > ctx->chunk_length) {
+        return false;
+    }
+
+    if (hdr->packet_length) {
+        SDL_memcpy(ctx->chunk_buffer + hdr->chunk_offset, data, hdr->packet_length);
+        return true;
+    }
+
+    result = HIDAPI_GIP_DispatchPacket(joystick, ctx, hdr, ctx->chunk_buffer, ctx->chunk_length);
+
+    HIDAPI_GIP_DestroyChunkBuffer(ctx);
+
+    return result;
+}
+
+static bool HIDAPI_GIP_ProcessPacket(SDL_Joystick *joystick, SDL_DriverXboxOne_Context *ctx, struct gip_header *hdr, Uint8 *data)
+{
+    if (hdr->options & GIP_OPT_CHUNK_START) {
+        if (!HIDAPI_GIP_CreateChunkBuffer(ctx, hdr->chunk_offset)) {
+            return false;
+        }
+        ctx->chunk_length = hdr->chunk_offset;
+
+        hdr->chunk_offset = 0;
+    }
+
+    if (hdr->options & GIP_OPT_ACKNOWLEDGE) {
+        if (!HIDAPI_GIP_AcknowledgePacket(ctx, hdr)) {
+            return false;
+        }
+    }
+
+    if (hdr->options & GIP_OPT_CHUNK) {
+        return HIDAPI_GIP_ProcessPacketChunked(joystick, ctx, hdr, data);
+    } else {
+        return HIDAPI_GIP_DispatchPacket(joystick, ctx, hdr, data, hdr->packet_length);
+    }
+}
+
+static bool HIDAPI_GIP_ProcessData(SDL_Joystick *joystick, SDL_DriverXboxOne_Context *ctx, Uint8 *data, int size)
+{
+    struct gip_header hdr;
+    int hdr_len;
+
+    while (size > GIP_HEADER_MIN_LENGTH) {
+        hdr_len = HIDAPI_GIP_DecodeHeader(&hdr, data, size);
+        if ((hdr_len + hdr.packet_length) > (Uint32)size) {
+            // On macOS we get a shortened version of the real report
+            hdr.packet_length = (Uint32)(size - hdr_len);
+        }
+
+        if (!HIDAPI_GIP_ProcessPacket(joystick, ctx, &hdr, data + hdr_len)) {
+            return false;
+        }
+
+        data += hdr_len + hdr.packet_length;
+        size -= hdr_len + hdr.packet_length;
+    }
+    return true;
+}
+
+static bool HIDAPI_DriverXboxOne_UpdateDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverXboxOne_Context *ctx = (SDL_DriverXboxOne_Context *)device->context;
+    SDL_Joystick *joystick = NULL;
+    Uint8 data[USB_PACKET_LENGTH];
+    int size;
+
+    if (device->num_joysticks > 0) {
+        joystick = SDL_GetJoystickFromID(device->joysticks[0]);
+    } else {
+        return false;
+    }
+
+    while ((size = SDL_hid_read_timeout(device->dev, data, sizeof(data), 0)) > 0) {
+#ifdef DEBUG_XBOX_PROTOCOL
+        HIDAPI_DumpPacket("Xbox One packet: size = %d", data, size);
+#endif
+        if (device->is_bluetooth) {
+            switch (data[0]) {
+            case 0x01:
+                if (!joystick) {
+                    break;
+                }
+                if (size >= 16) {
+                    HIDAPI_DriverXboxOneBluetooth_HandleStatePacket(joystick, ctx, data, size);
+                } else {
+#ifdef DEBUG_JOYSTICK
+                    SDL_Log("Unknown Xbox One Bluetooth packet size: %d", size);
+#endif
+                }
+                break;
+            case 0x02:
+                if (!joystick) {
+                    break;
+                }
+                HIDAPI_DriverXboxOneBluetooth_HandleGuidePacket(joystick, ctx, data, size);
+                break;
+            case 0x04:
+                if (!joystick) {
+                    break;
+                }
+                HIDAPI_DriverXboxOneBluetooth_HandleBatteryPacket(joystick, ctx, data, size);
+                break;
+            default:
+#ifdef DEBUG_JOYSTICK
+                SDL_Log("Unknown Xbox One packet: 0x%.2x", data[0]);
+#endif
+                break;
+            }
+        } else {
+            HIDAPI_GIP_ProcessData(joystick, ctx, data, size);
+        }
+    }
+
+    HIDAPI_DriverXboxOne_UpdateInitState(ctx);
+    HIDAPI_DriverXboxOne_UpdateRumble(ctx);
+
+    if (size < 0) {
+        // Read error, device is disconnected
+        HIDAPI_JoystickDisconnected(device, device->joysticks[0]);
+    }
+    return (size >= 0);
+}
+
+static void HIDAPI_DriverXboxOne_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_DriverXboxOne_Context *ctx = (SDL_DriverXboxOne_Context *)device->context;
+
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_XBOX_ONE_HOME_LED,
+                        SDL_HomeLEDHintChanged, ctx);
+}
+
+static void HIDAPI_DriverXboxOne_FreeDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_DriverXboxOne_Context *ctx = (SDL_DriverXboxOne_Context *)device->context;
+
+    HIDAPI_GIP_DestroyChunkBuffer(ctx);
+}
+
+SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverXboxOne = {
+    SDL_HINT_JOYSTICK_HIDAPI_XBOX_ONE,
+    true,
+    HIDAPI_DriverXboxOne_RegisterHints,
+    HIDAPI_DriverXboxOne_UnregisterHints,
+    HIDAPI_DriverXboxOne_IsEnabled,
+    HIDAPI_DriverXboxOne_IsSupportedDevice,
+    HIDAPI_DriverXboxOne_InitDevice,
+    HIDAPI_DriverXboxOne_GetDevicePlayerIndex,
+    HIDAPI_DriverXboxOne_SetDevicePlayerIndex,
+    HIDAPI_DriverXboxOne_UpdateDevice,
+    HIDAPI_DriverXboxOne_OpenJoystick,
+    HIDAPI_DriverXboxOne_RumbleJoystick,
+    HIDAPI_DriverXboxOne_RumbleJoystickTriggers,
+    HIDAPI_DriverXboxOne_GetJoystickCapabilities,
+    HIDAPI_DriverXboxOne_SetJoystickLED,
+    HIDAPI_DriverXboxOne_SendJoystickEffect,
+    HIDAPI_DriverXboxOne_SetJoystickSensorsEnabled,
+    HIDAPI_DriverXboxOne_CloseJoystick,
+    HIDAPI_DriverXboxOne_FreeDevice,
+};
+
+#endif // SDL_JOYSTICK_HIDAPI_XBOXONE
+
+#endif // SDL_JOYSTICK_HIDAPI
diff --git a/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapijoystick.c b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapijoystick.c
new file mode 100644
index 0000000..aec6463
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapijoystick.c
@@ -0,0 +1,1730 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_JOYSTICK_HIDAPI
+
+#include "../SDL_sysjoystick.h"
+#include "SDL_hidapijoystick_c.h"
+#include "SDL_hidapi_rumble.h"
+#include "../../SDL_hints_c.h"
+
+#if defined(SDL_PLATFORM_WIN32) || defined(SDL_PLATFORM_WINGDK)
+#include "../windows/SDL_rawinputjoystick_c.h"
+#endif
+
+
+struct joystick_hwdata
+{
+    SDL_HIDAPI_Device *device;
+};
+
+static SDL_HIDAPI_DeviceDriver *SDL_HIDAPI_drivers[] = {
+#ifdef SDL_JOYSTICK_HIDAPI_GAMECUBE
+    &SDL_HIDAPI_DriverGameCube,
+#endif
+#ifdef SDL_JOYSTICK_HIDAPI_LUNA
+    &SDL_HIDAPI_DriverLuna,
+#endif
+#ifdef SDL_JOYSTICK_HIDAPI_SHIELD
+    &SDL_HIDAPI_DriverShield,
+#endif
+#ifdef SDL_JOYSTICK_HIDAPI_PS3
+    &SDL_HIDAPI_DriverPS3,
+    &SDL_HIDAPI_DriverPS3ThirdParty,
+    &SDL_HIDAPI_DriverPS3SonySixaxis,
+#endif
+#ifdef SDL_JOYSTICK_HIDAPI_PS4
+    &SDL_HIDAPI_DriverPS4,
+#endif
+#ifdef SDL_JOYSTICK_HIDAPI_PS5
+    &SDL_HIDAPI_DriverPS5,
+#endif
+#ifdef SDL_JOYSTICK_HIDAPI_STADIA
+    &SDL_HIDAPI_DriverStadia,
+#endif
+#ifdef SDL_JOYSTICK_HIDAPI_STEAM
+    &SDL_HIDAPI_DriverSteam,
+#endif
+#ifdef SDL_JOYSTICK_HIDAPI_STEAM_HORI
+    &SDL_HIDAPI_DriverSteamHori,
+#endif
+#ifdef SDL_JOYSTICK_HIDAPI_STEAMDECK
+    &SDL_HIDAPI_DriverSteamDeck,
+#endif
+#ifdef SDL_JOYSTICK_HIDAPI_SWITCH
+    &SDL_HIDAPI_DriverNintendoClassic,
+    &SDL_HIDAPI_DriverJoyCons,
+    &SDL_HIDAPI_DriverSwitch,
+#endif
+#ifdef SDL_JOYSTICK_HIDAPI_WII
+    &SDL_HIDAPI_DriverWii,
+#endif
+#ifdef SDL_JOYSTICK_HIDAPI_XBOX360
+    &SDL_HIDAPI_DriverXbox360,
+    &SDL_HIDAPI_DriverXbox360W,
+#endif
+#ifdef SDL_JOYSTICK_HIDAPI_XBOXONE
+    &SDL_HIDAPI_DriverXboxOne,
+#endif
+};
+static int SDL_HIDAPI_numdrivers = 0;
+static SDL_AtomicInt SDL_HIDAPI_updating_devices;
+static bool SDL_HIDAPI_hints_changed = false;
+static Uint32 SDL_HIDAPI_change_count = 0;
+static SDL_HIDAPI_Device *SDL_HIDAPI_devices SDL_GUARDED_BY(SDL_joystick_lock);
+static int SDL_HIDAPI_numjoysticks = 0;
+static bool SDL_HIDAPI_combine_joycons = true;
+static bool initialized = false;
+static bool shutting_down = false;
+
+static char *HIDAPI_ConvertString(const wchar_t *wide_string)
+{
+    char *string = NULL;
+
+    if (wide_string) {
+        string = SDL_iconv_string("UTF-8", "WCHAR_T", (char *)wide_string, (SDL_wcslen(wide_string) + 1) * sizeof(wchar_t));
+        if (!string) {
+            switch (sizeof(wchar_t)) {
+            case 2:
+                string = SDL_iconv_string("UTF-8", "UCS-2-INTERNAL", (char *)wide_string, (SDL_wcslen(wide_string) + 1) * sizeof(wchar_t));
+                break;
+            case 4:
+                string = SDL_iconv_string("UTF-8", "UCS-4-INTERNAL", (char *)wide_string, (SDL_wcslen(wide_string) + 1) * sizeof(wchar_t));
+                break;
+            }
+        }
+    }
+    return string;
+}
+
+void HIDAPI_DumpPacket(const char *prefix, const Uint8 *data, int size)
+{
+    int i;
+    char *buffer;
+    size_t length = SDL_strlen(prefix) + 11 * (size / 8) + (5 * size * 2) + 1 + 1;
+    int start = 0, amount = size;
+    size_t current_len;
+
+    buffer = (char *)SDL_malloc(length);
+    current_len = SDL_snprintf(buffer, length, prefix, size);
+    for (i = start; i < start + amount; ++i) {
+        if ((i % 8) == 0) {
+            current_len += SDL_snprintf(&buffer[current_len], length - current_len, "\n%.2d:      ", i);
+        }
+        current_len += SDL_snprintf(&buffer[current_len], length - current_len, " 0x%.2x", data[i]);
+    }
+    SDL_strlcat(buffer, "\n", length);
+    SDL_Log("%s", buffer);
+    SDL_free(buffer);
+}
+
+bool HIDAPI_SupportsPlaystationDetection(Uint16 vendor, Uint16 product)
+{
+    /* If we already know the controller is a different type, don't try to detect it.
+     * This fixes a hang with the HORIPAD for Nintendo Switch (0x0f0d/0x00c1)
+     */
+    if (SDL_GetGamepadTypeFromVIDPID(vendor, product, NULL, false) != SDL_GAMEPAD_TYPE_STANDARD) {
+        return false;
+    }
+
+    switch (vendor) {
+    case USB_VENDOR_DRAGONRISE:
+        return true;
+    case USB_VENDOR_HORI:
+        return true;
+    case USB_VENDOR_LOGITECH:
+        /* Most Logitech devices are not PlayStation controllers, and some of them
+         * lock up or reset when we send them the Sony third-party query feature
+         * report, so don't include that vendor here. Instead add devices as
+         * appropriate to controller_list.h
+         */
+        return false;
+    case USB_VENDOR_MADCATZ:
+        if (product == USB_PRODUCT_MADCATZ_SAITEK_SIDE_PANEL_CONTROL_DECK) {
+            // This is not a Playstation compatible device
+            return false;
+        }
+        return true;
+    case USB_VENDOR_MAYFLASH:
+        return true;
+    case USB_VENDOR_NACON:
+    case USB_VENDOR_NACON_ALT:
+        return true;
+    case USB_VENDOR_PDP:
+        return true;
+    case USB_VENDOR_POWERA:
+        return true;
+    case USB_VENDOR_POWERA_ALT:
+        return true;
+    case USB_VENDOR_QANBA:
+        return true;
+    case USB_VENDOR_RAZER:
+        /* Most Razer devices are not PlayStation controllers, and some of them
+         * lock up or reset when we send them the Sony third-party query feature
+         * report, so don't include that vendor here. Instead add devices as
+         * appropriate to controller_list.h
+         *
+         * Reference: https://github.com/libsdl-org/SDL/issues/6733
+         *            https://github.com/libsdl-org/SDL/issues/6799
+         */
+        return false;
+    case USB_VENDOR_SHANWAN:
+        return true;
+    case USB_VENDOR_SHANWAN_ALT:
+        return true;
+    case USB_VENDOR_THRUSTMASTER:
+        /* Most of these are wheels, don't have the full set of effects, and
+         * at least in the case of the T248 and T300 RS, the hid-tmff2 driver
+         * puts them in a non-standard report mode and they can't be read.
+         *
+         * If these should use the HIDAPI driver, add them to controller_list.h
+         */
+        return false;
+    case USB_VENDOR_ZEROPLUS:
+        return true;
+    case 0x7545 /* SZ-MYPOWER */:
+        return true;
+    default:
+        return false;
+    }
+}
+
+float HIDAPI_RemapVal(float val, float val_min, float val_max, float output_min, float output_max)
+{
+    return output_min + (output_max - output_min) * (val - val_min) / (val_max - val_min);
+}
+
+static void HIDAPI_UpdateDeviceList(void);
+static void HIDAPI_JoystickClose(SDL_Joystick *joystick);
+
+static SDL_GamepadType SDL_GetJoystickGameControllerProtocol(const char *name, Uint16 vendor, Uint16 product, int interface_number, int interface_class, int interface_subclass, int interface_protocol)
+{
+    static const int LIBUSB_CLASS_VENDOR_SPEC = 0xFF;
+    static const int XB360_IFACE_SUBCLASS = 93;
+    static const int XB360_IFACE_PROTOCOL = 1;    // Wired
+    static const int XB360W_IFACE_PROTOCOL = 129; // Wireless
+    static const int XBONE_IFACE_SUBCLASS = 71;
+    static const int XBONE_IFACE_PROTOCOL = 208;
+
+    SDL_GamepadType type = SDL_GAMEPAD_TYPE_STANDARD;
+
+    // This code should match the checks in libusb/hid.c and HIDDeviceManager.java
+    if (interface_class == LIBUSB_CLASS_VENDOR_SPEC &&
+        interface_subclass == XB360_IFACE_SUBCLASS &&
+        (interface_protocol == XB360_IFACE_PROTOCOL ||
+         interface_protocol == XB360W_IFACE_PROTOCOL)) {
+
+        static const int SUPPORTED_VENDORS[] = {
+            0x0079, // GPD Win 2
+            0x044f, // Thrustmaster
+            0x045e, // Microsoft
+            0x046d, // Logitech
+            0x056e, // Elecom
+            0x06a3, // Saitek
+            0x0738, // Mad Catz
+            0x07ff, // Mad Catz
+            0x0e6f, // PDP
+            0x0f0d, // Hori
+            0x1038, // SteelSeries
+            0x11c9, // Nacon
+            0x12ab, // Unknown
+            0x1430, // RedOctane
+            0x146b, // BigBen
+            0x1532, // Razer
+            0x15e4, // Numark
+            0x162e, // Joytech
+            0x1689, // Razer Onza
+            0x1949, // Lab126, Inc.
+            0x1bad, // Harmonix
+            0x20d6, // PowerA
+            0x24c6, // PowerA
+            0x2c22, // Qanba
+            0x2dc8, // 8BitDo
+            0x9886, // ASTRO Gaming
+        };
+
+        int i;
+        for (i = 0; i < SDL_arraysize(SUPPORTED_VENDORS); ++i) {
+            if (vendor == SUPPORTED_VENDORS[i]) {
+                type = SDL_GAMEPAD_TYPE_XBOX360;
+                break;
+            }
+        }
+    }
+
+    if (interface_number == 0 &&
+        interface_class == LIBUSB_CLASS_VENDOR_SPEC &&
+        interface_subclass == XBONE_IFACE_SUBCLASS &&
+        interface_protocol == XBONE_IFACE_PROTOCOL) {
+
+        static const int SUPPORTED_VENDORS[] = {
+            0x03f0, // HP
+            0x044f, // Thrustmaster
+            0x045e, // Microsoft
+            0x0738, // Mad Catz
+            0x0b05, // ASUS
+            0x0e6f, // PDP
+            0x0f0d, // Hori
+            0x10f5, // Turtle Beach
+            0x1532, // Razer
+            0x20d6, // PowerA
+            0x24c6, // PowerA
+            0x2dc8, // 8BitDo
+            0x2e24, // Hyperkin
+            0x3537, // GameSir
+        };
+
+        int i;
+        for (i = 0; i < SDL_arraysize(SUPPORTED_VENDORS); ++i) {
+            if (vendor == SUPPORTED_VENDORS[i]) {
+                type = SDL_GAMEPAD_TYPE_XBOXONE;
+                break;
+            }
+        }
+    }
+
+    if (type == SDL_GAMEPAD_TYPE_STANDARD) {
+        type = SDL_GetGamepadTypeFromVIDPID(vendor, product, name, false);
+    }
+    return type;
+}
+
+static bool HIDAPI_IsDeviceSupported(Uint16 vendor_id, Uint16 product_id, Uint16 version, const char *name)
+{
+    int i;
+    SDL_GamepadType type = SDL_GetJoystickGameControllerProtocol(name, vendor_id, product_id, -1, 0, 0, 0);
+
+    for (i = 0; i < SDL_arraysize(SDL_HIDAPI_drivers); ++i) {
+        SDL_HIDAPI_DeviceDriver *driver = SDL_HIDAPI_drivers[i];
+        if (driver->enabled && driver->IsSupportedDevice(NULL, name, type, vendor_id, product_id, version, -1, 0, 0, 0)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+static SDL_HIDAPI_DeviceDriver *HIDAPI_GetDeviceDriver(SDL_HIDAPI_Device *device)
+{
+    const Uint16 USAGE_PAGE_GENERIC_DESKTOP = 0x0001;
+    const Uint16 USAGE_JOYSTICK = 0x0004;
+    const Uint16 USAGE_GAMEPAD = 0x0005;
+    const Uint16 USAGE_MULTIAXISCONTROLLER = 0x0008;
+    int i;
+
+    if (device->num_children > 0) {
+        return &SDL_HIDAPI_DriverCombined;
+    }
+
+    if (SDL_ShouldIgnoreJoystick(device->vendor_id, device->product_id, device->version, device->name)) {
+        return NULL;
+    }
+
+    if (device->vendor_id != USB_VENDOR_VALVE) {
+        if (device->usage_page && device->usage_page != USAGE_PAGE_GENERIC_DESKTOP) {
+            return NULL;
+        }
+        if (device->usage && device->usage != USAGE_JOYSTICK && device->usage != USAGE_GAMEPAD && device->usage != USAGE_MULTIAXISCONTROLLER) {
+            return NULL;
+        }
+    }
+
+    for (i = 0; i < SDL_arraysize(SDL_HIDAPI_drivers); ++i) {
+        SDL_HIDAPI_DeviceDriver *driver = SDL_HIDAPI_drivers[i];
+        if (driver->enabled && driver->IsSupportedDevice(device, device->name, device->type, device->vendor_id, device->product_id, device->version, device->interface_number, device->interface_class, device->interface_subclass, device->interface_protocol)) {
+            return driver;
+        }
+    }
+    return NULL;
+}
+
+static SDL_HIDAPI_Device *HIDAPI_GetDeviceByIndex(int device_index, SDL_JoystickID *pJoystickID)
+{
+    SDL_HIDAPI_Device *device;
+
+    SDL_AssertJoysticksLocked();
+
+    for (device = SDL_HIDAPI_devices; device; device = device->next) {
+        if (device->parent || device->broken) {
+            continue;
+        }
+        if (device->driver) {
+            if (device_index < device->num_joysticks) {
+                if (pJoystickID) {
+                    *pJoystickID = device->joysticks[device_index];
+                }
+                return device;
+            }
+            device_index -= device->num_joysticks;
+        }
+    }
+    return NULL;
+}
+
+static SDL_HIDAPI_Device *HIDAPI_GetJoystickByInfo(const char *path, Uint16 vendor_id, Uint16 product_id)
+{
+    SDL_HIDAPI_Device *device;
+
+    SDL_AssertJoysticksLocked();
+
+    for (device = SDL_HIDAPI_devices; device; device = device->next) {
+        if (device->vendor_id == vendor_id && device->product_id == product_id &&
+            SDL_strcmp(device->path, path) == 0) {
+            break;
+        }
+    }
+    return device;
+}
+
+static void HIDAPI_CleanupDeviceDriver(SDL_HIDAPI_Device *device)
+{
+    if (!device->driver) {
+        return; // Already cleaned up
+    }
+
+    // Disconnect any joysticks
+    while (device->num_joysticks && device->joysticks) {
+        HIDAPI_JoystickDisconnected(device, device->joysticks[0]);
+    }
+
+    device->driver->FreeDevice(device);
+    device->driver = NULL;
+
+    SDL_LockMutex(device->dev_lock);
+    {
+        if (device->dev) {
+            SDL_hid_close(device->dev);
+            device->dev = NULL;
+        }
+
+        if (device->context) {
+            SDL_free(device->context);
+            device->context = NULL;
+        }
+    }
+    SDL_UnlockMutex(device->dev_lock);
+}
+
+static void HIDAPI_SetupDeviceDriver(SDL_HIDAPI_Device *device, bool *removed) SDL_NO_THREAD_SAFETY_ANALYSIS // We unlock the joystick lock to be able to open the HID device on Android
+{
+    *removed = false;
+
+    if (device->driver) {
+        bool enabled;
+
+        if (device->vendor_id == USB_VENDOR_NINTENDO && device->product_id == USB_PRODUCT_NINTENDO_SWITCH_JOYCON_PAIR) {
+            enabled = SDL_HIDAPI_combine_joycons;
+        } else {
+            enabled = device->driver->enabled;
+        }
+        if (device->children) {
+            int i;
+
+            for (i = 0; i < device->num_children; ++i) {
+                SDL_HIDAPI_Device *child = device->children[i];
+                if (!child->driver || !child->driver->enabled) {
+                    enabled = false;
+                    break;
+                }
+            }
+        }
+        if (!enabled) {
+            HIDAPI_CleanupDeviceDriver(device);
+        }
+        return; // Already setup
+    }
+
+    if (HIDAPI_GetDeviceDriver(device)) {
+        // We might have a device driver for this device, try opening it and see
+        if (device->num_children == 0) {
+            SDL_hid_device *dev;
+
+            // Wait a little bit for the device to initialize
+            SDL_Delay(10);
+
+            dev = SDL_hid_open_path(device->path);
+
+            if (dev == NULL) {
+                SDL_LogDebug(SDL_LOG_CATEGORY_INPUT,
+                             "HIDAPI_SetupDeviceDriver() couldn't open %s: %s",
+                             device->path, SDL_GetError());
+                return;
+            }
+            SDL_hid_set_nonblocking(dev, 1);
+
+            device->dev = dev;
+        }
+
+        device->driver = HIDAPI_GetDeviceDriver(device);
+
+        // Initialize the device, which may cause a connected event
+        if (device->driver && !device->driver->InitDevice(device)) {
+            HIDAPI_CleanupDeviceDriver(device);
+        }
+
+        if (!device->driver && device->dev) {
+            // No driver claimed this device, go ahead and close it
+            SDL_hid_close(device->dev);
+            device->dev = NULL;
+        }
+    }
+}
+
+static void SDL_HIDAPI_UpdateDrivers(void)
+{
+    int i;
+    SDL_HIDAPI_Device *device;
+    bool removed;
+
+    SDL_AssertJoysticksLocked();
+
+    SDL_HIDAPI_numdrivers = 0;
+    for (i = 0; i < SDL_arraysize(SDL_HIDAPI_drivers); ++i) {
+        SDL_HIDAPI_DeviceDriver *driver = SDL_HIDAPI_drivers[i];
+        driver->enabled = driver->IsEnabled();
+        if (driver->enabled && driver != &SDL_HIDAPI_DriverCombined) {
+            ++SDL_HIDAPI_numdrivers;
+        }
+    }
+
+    removed = false;
+    do {
+        for (device = SDL_HIDAPI_devices; device; device = device->next) {
+            HIDAPI_SetupDeviceDriver(device, &removed);
+            if (removed) {
+                break;
+            }
+        }
+    } while (removed);
+}
+
+static void SDLCALL SDL_HIDAPIDriverHintChanged(void *userdata, const char *name, const char *oldValue, const char *hint)
+{
+    if (SDL_strcmp(name, SDL_HINT_JOYSTICK_HIDAPI_COMBINE_JOY_CONS) == 0) {
+        SDL_HIDAPI_combine_joycons = SDL_GetStringBoolean(hint, true);
+    }
+    SDL_HIDAPI_hints_changed = true;
+    SDL_HIDAPI_change_count = 0;
+}
+
+static bool HIDAPI_JoystickInit(void)
+{
+    int i;
+
+    if (initialized) {
+        return true;
+    }
+
+    if (SDL_hid_init() < 0) {
+        return SDL_SetError("Couldn't initialize hidapi");
+    }
+
+    for (i = 0; i < SDL_arraysize(SDL_HIDAPI_drivers); ++i) {
+        SDL_HIDAPI_DeviceDriver *driver = SDL_HIDAPI_drivers[i];
+        driver->RegisterHints(SDL_HIDAPIDriverHintChanged, driver);
+    }
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI_COMBINE_JOY_CONS,
+                        SDL_HIDAPIDriverHintChanged, NULL);
+    SDL_AddHintCallback(SDL_HINT_JOYSTICK_HIDAPI,
+                        SDL_HIDAPIDriverHintChanged, NULL);
+
+    SDL_HIDAPI_change_count = SDL_hid_device_change_count();
+    HIDAPI_UpdateDeviceList();
+    HIDAPI_UpdateDevices();
+
+    initialized = true;
+
+    return true;
+}
+
+static bool HIDAPI_AddJoystickInstanceToDevice(SDL_HIDAPI_Device *device, SDL_JoystickID joystickID)
+{
+    SDL_JoystickID *joysticks = (SDL_JoystickID *)SDL_realloc(device->joysticks, (device->num_joysticks + 1) * sizeof(*device->joysticks));
+    if (!joysticks) {
+        return false;
+    }
+
+    device->joysticks = joysticks;
+    device->joysticks[device->num_joysticks++] = joystickID;
+    return true;
+}
+
+static bool HIDAPI_DelJoystickInstanceFromDevice(SDL_HIDAPI_Device *device, SDL_JoystickID joystickID)
+{
+    int i, size;
+
+    for (i = 0; i < device->num_joysticks; ++i) {
+        if (device->joysticks[i] == joystickID) {
+            size = (device->num_joysticks - i - 1) * sizeof(SDL_JoystickID);
+            SDL_memmove(&device->joysticks[i], &device->joysticks[i + 1], size);
+            --device->num_joysticks;
+            if (device->num_joysticks == 0) {
+                SDL_free(device->joysticks);
+                device->joysticks = NULL;
+            }
+            return true;
+        }
+    }
+    return false;
+}
+
+static bool HIDAPI_JoystickInstanceIsUnique(SDL_HIDAPI_Device *device, SDL_JoystickID joystickID)
+{
+    if (device->parent && device->num_joysticks == 1 && device->parent->num_joysticks == 1 &&
+        device->joysticks[0] == device->parent->joysticks[0]) {
+        return false;
+    }
+    return true;
+}
+
+void HIDAPI_SetDeviceName(SDL_HIDAPI_Device *device, const char *name)
+{
+    if (name && *name && SDL_strcmp(name, device->name) != 0) {
+        SDL_free(device->name);
+        device->name = SDL_strdup(name);
+        SDL_SetJoystickGUIDCRC(&device->guid, SDL_crc16(0, name, SDL_strlen(name)));
+    }
+}
+
+void HIDAPI_SetDeviceProduct(SDL_HIDAPI_Device *device, Uint16 vendor_id, Uint16 product_id)
+{
+    // Don't set the device product ID directly, or we'll constantly re-enumerate this device
+    device->guid = SDL_CreateJoystickGUID(device->guid.data[0], vendor_id, product_id, device->version, device->manufacturer_string, device->product_string, 'h', 0);
+}
+
+static void HIDAPI_UpdateJoystickSerial(SDL_HIDAPI_Device *device)
+{
+    int i;
+
+    SDL_AssertJoysticksLocked();
+
+    for (i = 0; i < device->num_joysticks; ++i) {
+        SDL_Joystick *joystick = SDL_GetJoystickFromID(device->joysticks[i]);
+        if (joystick && device->serial) {
+            SDL_free(joystick->serial);
+            joystick->serial = SDL_strdup(device->serial);
+        }
+    }
+}
+
+static bool HIDAPI_SerialIsEmpty(SDL_HIDAPI_Device *device)
+{
+    bool all_zeroes = true;
+
+    if (device->serial) {
+        const char *serial = device->serial;
+        for (serial = device->serial; *serial; ++serial) {
+            if (*serial != '0') {
+                all_zeroes = false;
+                break;
+            }
+        }
+    }
+    return all_zeroes;
+}
+
+void HIDAPI_SetDeviceSerial(SDL_HIDAPI_Device *device, const char *serial)
+{
+    if (serial && *serial && (!device->serial || SDL_strcmp(serial, device->serial) != 0)) {
+        SDL_free(device->serial);
+        device->serial = SDL_strdup(serial);
+        HIDAPI_UpdateJoystickSerial(device);
+    }
+}
+
+static int wcstrcmp(const wchar_t *str1, const char *str2)
+{
+    int result;
+
+    while (1) {
+        result = (*str1 - *str2);
+        if (result != 0 || *str1 == 0) {
+            break;
+        }
+        ++str1;
+        ++str2;
+    }
+    return result;
+}
+
+static void HIDAPI_SetDeviceSerialW(SDL_HIDAPI_Device *device, const wchar_t *serial)
+{
+    if (serial && *serial && (!device->serial || wcstrcmp(serial, device->serial) != 0)) {
+        SDL_free(device->serial);
+        device->serial = HIDAPI_ConvertString(serial);
+        HIDAPI_UpdateJoystickSerial(device);
+    }
+}
+
+bool HIDAPI_HasConnectedUSBDevice(const char *serial)
+{
+    SDL_HIDAPI_Device *device;
+
+    SDL_AssertJoysticksLocked();
+
+    if (!serial) {
+        return false;
+    }
+
+    for (device = SDL_HIDAPI_devices; device; device = device->next) {
+        if (!device->driver || device->broken) {
+            continue;
+        }
+
+        if (device->is_bluetooth) {
+            continue;
+        }
+
+        if (device->serial && SDL_strcmp(serial, device->serial) == 0) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void HIDAPI_DisconnectBluetoothDevice(const char *serial)
+{
+    SDL_HIDAPI_Device *device;
+
+    SDL_AssertJoysticksLocked();
+
+    if (!serial) {
+        return;
+    }
+
+    for (device = SDL_HIDAPI_devices; device; device = device->next) {
+        if (!device->driver || device->broken) {
+            continue;
+        }
+
+        if (!device->is_bluetooth) {
+            continue;
+        }
+
+        if (device->serial && SDL_strcmp(serial, device->serial) == 0) {
+            while (device->num_joysticks && device->joysticks) {
+                HIDAPI_JoystickDisconnected(device, device->joysticks[0]);
+            }
+        }
+    }
+}
+
+bool HIDAPI_JoystickConnected(SDL_HIDAPI_Device *device, SDL_JoystickID *pJoystickID)
+{
+    int i, j;
+    SDL_JoystickID joystickID;
+
+    SDL_AssertJoysticksLocked();
+
+    for (i = 0; i < device->num_children; ++i) {
+        SDL_HIDAPI_Device *child = device->children[i];
+        for (j = child->num_joysticks; j--;) {
+            HIDAPI_JoystickDisconnected(child, child->joysticks[j]);
+        }
+    }
+
+    joystickID = SDL_GetNextObjectID();
+    HIDAPI_AddJoystickInstanceToDevice(device, joystickID);
+
+    for (i = 0; i < device->num_children; ++i) {
+        SDL_HIDAPI_Device *child = device->children[i];
+        HIDAPI_AddJoystickInstanceToDevice(child, joystickID);
+    }
+
+    ++SDL_HIDAPI_numjoysticks;
+
+    SDL_PrivateJoystickAdded(joystickID);
+
+    if (pJoystickID) {
+        *pJoystickID = joystickID;
+    }
+    return true;
+}
+
+void HIDAPI_JoystickDisconnected(SDL_HIDAPI_Device *device, SDL_JoystickID joystickID)
+{
+    int i, j;
+
+    SDL_LockJoysticks();
+
+    if (!HIDAPI_JoystickInstanceIsUnique(device, joystickID)) {
+        // Disconnecting a child always disconnects the parent
+        device = device->parent;
+    }
+
+    for (i = 0; i < device->num_joysticks; ++i) {
+        if (device->joysticks[i] == joystickID) {
+            SDL_Joystick *joystick = SDL_GetJoystickFromID(joystickID);
+            if (joystick) {
+                HIDAPI_JoystickClose(joystick);
+            }
+
+            HIDAPI_DelJoystickInstanceFromDevice(device, joystickID);
+
+            for (j = 0; j < device->num_children; ++j) {
+                SDL_HIDAPI_Device *child = device->children[j];
+                HIDAPI_DelJoystickInstanceFromDevice(child, joystickID);
+            }
+
+            --SDL_HIDAPI_numjoysticks;
+
+            if (!shutting_down) {
+                SDL_PrivateJoystickRemoved(joystickID);
+            }
+        }
+    }
+
+    // Rescan the device list in case device state has changed
+    SDL_HIDAPI_change_count = 0;
+
+    SDL_UnlockJoysticks();
+}
+
+static void HIDAPI_UpdateJoystickProperties(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
+{
+    SDL_PropertiesID props = SDL_GetJoystickProperties(joystick);
+    Uint32 caps = device->driver->GetJoystickCapabilities(device, joystick);
+
+    if (caps & SDL_JOYSTICK_CAP_MONO_LED) {
+        SDL_SetBooleanProperty(props, SDL_PROP_JOYSTICK_CAP_MONO_LED_BOOLEAN, true);
+    } else {
+        SDL_SetBooleanProperty(props, SDL_PROP_JOYSTICK_CAP_MONO_LED_BOOLEAN, false);
+    }
+    if (caps & SDL_JOYSTICK_CAP_RGB_LED) {
+        SDL_SetBooleanProperty(props, SDL_PROP_JOYSTICK_CAP_RGB_LED_BOOLEAN, true);
+    } else {
+        SDL_SetBooleanProperty(props, SDL_PROP_JOYSTICK_CAP_RGB_LED_BOOLEAN, false);
+    }
+    if (caps & SDL_JOYSTICK_CAP_PLAYER_LED) {
+        SDL_SetBooleanProperty(props, SDL_PROP_JOYSTICK_CAP_PLAYER_LED_BOOLEAN, true);
+    } else {
+        SDL_SetBooleanProperty(props, SDL_PROP_JOYSTICK_CAP_PLAYER_LED_BOOLEAN, false);
+    }
+    if (caps & SDL_JOYSTICK_CAP_RUMBLE) {
+        SDL_SetBooleanProperty(props, SDL_PROP_JOYSTICK_CAP_RUMBLE_BOOLEAN, true);
+    } else {
+        SDL_SetBooleanProperty(props, SDL_PROP_JOYSTICK_CAP_RUMBLE_BOOLEAN, false);
+    }
+    if (caps & SDL_JOYSTICK_CAP_TRIGGER_RUMBLE) {
+        SDL_SetBooleanProperty(props, SDL_PROP_JOYSTICK_CAP_TRIGGER_RUMBLE_BOOLEAN, true);
+    } else {
+        SDL_SetBooleanProperty(props, SDL_PROP_JOYSTICK_CAP_TRIGGER_RUMBLE_BOOLEAN, false);
+    }
+}
+
+void HIDAPI_UpdateDeviceProperties(SDL_HIDAPI_Device *device)
+{
+    int i;
+
+    SDL_LockJoysticks();
+
+    for (i = 0; i < device->num_joysticks; ++i) {
+        SDL_Joystick *joystick = SDL_GetJoystickFromID(device->joysticks[i]);
+        if (joystick) {
+            HIDAPI_UpdateJoystickProperties(device, joystick);
+        }
+    }
+
+    SDL_UnlockJoysticks();
+}
+
+static int HIDAPI_JoystickGetCount(void)
+{
+    return SDL_HIDAPI_numjoysticks;
+}
+
+static SDL_HIDAPI_Device *HIDAPI_AddDevice(const struct SDL_hid_device_info *info, int num_children, SDL_HIDAPI_Device **children)
+{
+    SDL_HIDAPI_Device *device;
+    SDL_HIDAPI_Device *curr, *last = NULL;
+    bool removed;
+    Uint16 bus;
+
+    SDL_AssertJoysticksLocked();
+
+    for (curr = SDL_HIDAPI_devices, last = NULL; curr; last = curr, curr = curr->next) {
+    }
+
+    device = (SDL_HIDAPI_Device *)SDL_calloc(1, sizeof(*device));
+    if (!device) {
+        return NULL;
+    }
+    SDL_SetObjectValid(device, SDL_OBJECT_TYPE_HIDAPI_JOYSTICK, true);
+    device->path = SDL_strdup(info->path);
+    if (!device->path) {
+        SDL_free(device);
+        return NULL;
+    }
+    device->seen = true;
+    device->vendor_id = info->vendor_id;
+    device->product_id = info->product_id;
+    device->version = info->release_number;
+    device->interface_number = info->interface_number;
+    device->interface_class = info->interface_class;
+    device->interface_subclass = info->interface_subclass;
+    device->interface_protocol = info->interface_protocol;
+    device->usage_page = info->usage_page;
+    device->usage = info->usage;
+    device->is_bluetooth = (info->bus_type == SDL_HID_API_BUS_BLUETOOTH);
+    device->dev_lock = SDL_CreateMutex();
+
+    // Need the device name before getting the driver to know whether to ignore this device
+    {
+        char *serial_number = HIDAPI_ConvertString(info->serial_number);
+
+        device->manufacturer_string = HIDAPI_ConvertString(info->manufacturer_string);
+        device->product_string = HIDAPI_ConvertString(info->product_string);
+        device->name = SDL_CreateJoystickName(device->vendor_id, device->product_id, device->manufacturer_string, device->product_string);
+
+        if (serial_number && *serial_number) {
+            device->serial = serial_number;
+        } else {
+            SDL_free(serial_number);
+        }
+
+        if (!device->name) {
+            SDL_free(device->manufacturer_string);
+            SDL_free(device->product_string);
+            SDL_free(device->serial);
+            SDL_free(device->path);
+            SDL_free(device);
+            return NULL;
+        }
+    }
+
+    if (info->bus_type == SDL_HID_API_BUS_BLUETOOTH) {
+        bus = SDL_HARDWARE_BUS_BLUETOOTH;
+    } else {
+        bus = SDL_HARDWARE_BUS_USB;
+    }
+    device->guid = SDL_CreateJoystickGUID(bus, device->vendor_id, device->product_id, device->version, device->manufacturer_string, device->product_string, 'h', 0);
+    device->joystick_type = SDL_JOYSTICK_TYPE_GAMEPAD;
+    device->type = SDL_GetJoystickGameControllerProtocol(device->name, device->vendor_id, device->product_id, device->interface_number, device->interface_class, device->interface_subclass, device->interface_protocol);
+    device->steam_virtual_gamepad_slot = -1;
+
+    if (num_children > 0) {
+        int i;
+
+        device->num_children = num_children;
+        device->children = children;
+        for (i = 0; i < num_children; ++i) {
+            children[i]->parent = device;
+        }
+    }
+
+    // Add it to the list
+    if (last) {
+        last->next = device;
+    } else {
+        SDL_HIDAPI_devices = device;
+    }
+
+    removed = false;
+    HIDAPI_SetupDeviceDriver(device, &removed);
+    if (removed) {
+        return NULL;
+    }
+
+    SDL_LogDebug(SDL_LOG_CATEGORY_INPUT, "Added HIDAPI device '%s' VID 0x%.4x, PID 0x%.4x, bluetooth %d, version %d, serial %s, interface %d, interface_class %d, interface_subclass %d, interface_protocol %d, usage page 0x%.4x, usage 0x%.4x, path = %s, driver = %s (%s)", device->name, device->vendor_id, device->product_id, device->is_bluetooth, device->version,
+            device->serial ? device->serial : "NONE", device->interface_number, device->interface_class, device->interface_subclass, device->interface_protocol, device->usage_page, device->usage,
+            device->path, device->driver ? device->driver->name : "NONE", device->driver && device->driver->enabled ? "ENABLED" : "DISABLED");
+
+    return device;
+}
+
+static void HIDAPI_DelDevice(SDL_HIDAPI_Device *device)
+{
+    SDL_HIDAPI_Device *curr, *last;
+    int i;
+
+    SDL_AssertJoysticksLocked();
+
+    SDL_LogDebug(SDL_LOG_CATEGORY_INPUT, "Removing HIDAPI device '%s' VID 0x%.4x, PID 0x%.4x, bluetooth %d, version %d, serial %s, interface %d, interface_class %d, interface_subclass %d, interface_protocol %d, usage page 0x%.4x, usage 0x%.4x, path = %s, driver = %s (%s)", device->name, device->vendor_id, device->product_id, device->is_bluetooth, device->version,
+            device->serial ? device->serial : "NONE", device->interface_number, device->interface_class, device->interface_subclass, device->interface_protocol, device->usage_page, device->usage,
+            device->path, device->driver ? device->driver->name : "NONE", device->driver && device->driver->enabled ? "ENABLED" : "DISABLED");
+
+    for (curr = SDL_HIDAPI_devices, last = NULL; curr; last = curr, curr = curr->next) {
+        if (curr == device) {
+            if (last) {
+                last->next = curr->next;
+            } else {
+                SDL_HIDAPI_devices = curr->next;
+            }
+
+            HIDAPI_CleanupDeviceDriver(device);
+
+            // Make sure the rumble thread is done with this device
+            while (SDL_GetAtomicInt(&device->rumble_pending) > 0) {
+                SDL_Delay(10);
+            }
+
+            for (i = 0; i < device->num_children; ++i) {
+                device->children[i]->parent = NULL;
+            }
+
+            SDL_SetObjectValid(device, SDL_OBJECT_TYPE_HIDAPI_JOYSTICK, false);
+            SDL_DestroyMutex(device->dev_lock);
+            SDL_free(device->manufacturer_string);
+            SDL_free(device->product_string);
+            SDL_free(device->serial);
+            SDL_free(device->name);
+            SDL_free(device->path);
+            SDL_free(device->children);
+            SDL_free(device);
+            return;
+        }
+    }
+}
+
+static bool HIDAPI_CreateCombinedJoyCons(void)
+{
+    SDL_HIDAPI_Device *device, *combined;
+    SDL_HIDAPI_Device *joycons[2] = { NULL, NULL };
+
+    SDL_AssertJoysticksLocked();
+
+    if (!SDL_HIDAPI_combine_joycons) {
+        return false;
+    }
+
+    for (device = SDL_HIDAPI_devices; device; device = device->next) {
+        Uint16 vendor, product;
+
+        if (!device->driver) {
+            // Unsupported device
+            continue;
+        }
+        if (device->parent) {
+            // This device is already part of a combined device
+            continue;
+        }
+        if (device->broken) {
+            // This device can't be used
+            continue;
+        }
+
+        SDL_GetJoystickGUIDInfo(device->guid, &vendor, &product, NULL, NULL);
+
+        if (!joycons[0] &&
+            (SDL_IsJoystickNintendoSwitchJoyConLeft(vendor, product) ||
+             (SDL_IsJoystickNintendoSwitchJoyConGrip(vendor, product) &&
+              SDL_strstr(device->name, "(L)") != NULL))) {
+            joycons[0] = device;
+        }
+        if (!joycons[1] &&
+            (SDL_IsJoystickNintendoSwitchJoyConRight(vendor, product) ||
+             (SDL_IsJoystickNintendoSwitchJoyConGrip(vendor, product) &&
+              SDL_strstr(device->name, "(R)") != NULL))) {
+            joycons[1] = device;
+        }
+        if (joycons[0] && joycons[1]) {
+            SDL_hid_device_info info;
+            SDL_HIDAPI_Device **children = (SDL_HIDAPI_Device **)SDL_malloc(2 * sizeof(SDL_HIDAPI_Device *));
+            if (!children) {
+                return false;
+            }
+            children[0] = joycons[0];
+            children[1] = joycons[1];
+
+            SDL_zero(info);
+            info.path = "nintendo_joycons_combined";
+            info.vendor_id = USB_VENDOR_NINTENDO;
+            info.product_id = USB_PRODUCT_NINTENDO_SWITCH_JOYCON_PAIR;
+            info.interface_number = -1;
+            info.usage_page = USB_USAGEPAGE_GENERIC_DESKTOP;
+            info.usage = USB_USAGE_GENERIC_GAMEPAD;
+            info.manufacturer_string = L"Nintendo";
+            info.product_string = L"Switch Joy-Con (L/R)";
+
+            combined = HIDAPI_AddDevice(&info, 2, children);
+            if (combined && combined->driver) {
+                return true;
+            } else {
+                if (combined) {
+                    HIDAPI_DelDevice(combined);
+                } else {
+                    SDL_free(children);
+                }
+                return false;
+            }
+        }
+    }
+    return false;
+}
+
+static void HIDAPI_UpdateDeviceList(void)
+{
+    SDL_HIDAPI_Device *device;
+    struct SDL_hid_device_info *devs, *info;
+
+    SDL_LockJoysticks();
+
+    if (SDL_HIDAPI_hints_changed) {
+        SDL_HIDAPI_UpdateDrivers();
+        SDL_HIDAPI_hints_changed = false;
+    }
+
+    // Prepare the existing device list
+    for (device = SDL_HIDAPI_devices; device; device = device->next) {
+        if (device->children) {
+            continue;
+        }
+        device->seen = false;
+    }
+
+    // Enumerate the devices
+    if (SDL_HIDAPI_numdrivers > 0) {
+        devs = SDL_hid_enumerate(0, 0);
+        if (devs) {
+            for (info = devs; info; info = info->next) {
+                device = HIDAPI_GetJoystickByInfo(info->path, info->vendor_id, info->product_id);
+                if (device) {
+                    device->seen = true;
+
+                    // Check to see if the serial number is available now
+                    if(HIDAPI_SerialIsEmpty(device)) {
+                        HIDAPI_SetDeviceSerialW(device, info->serial_number);
+                    }
+                } else {
+                    HIDAPI_AddDevice(info, 0, NULL);
+                }
+            }
+            SDL_hid_free_enumeration(devs);
+        }
+    }
+
+    // Remove any devices that weren't seen or have been disconnected due to read errors
+check_removed:
+    device = SDL_HIDAPI_devices;
+    while (device) {
+        SDL_HIDAPI_Device *next = device->next;
+
+        if (!device->seen ||
+            ((device->driver || device->children) && device->num_joysticks == 0 && !device->dev)) {
+            if (device->parent) {
+                // When a child device goes away, so does the parent
+                int i;
+                device = device->parent;
+                for (i = 0; i < device->num_children; ++i) {
+                    HIDAPI_DelDevice(device->children[i]);
+                }
+                HIDAPI_DelDevice(device);
+
+                // Update the device list again to pick up any children left
+                SDL_HIDAPI_change_count = 0;
+
+                // We deleted more than one device here, restart the loop
+                goto check_removed;
+            } else {
+                HIDAPI_DelDevice(device);
+                device = NULL;
+
+                // Update the device list again in case this device comes back
+                SDL_HIDAPI_change_count = 0;
+            }
+        }
+        if (device && device->broken && device->parent) {
+            HIDAPI_DelDevice(device->parent);
+
+            // We deleted a different device here, restart the loop
+            goto check_removed;
+        }
+        device = next;
+    }
+
+    // See if we can create any combined Joy-Con controllers
+    while (HIDAPI_CreateCombinedJoyCons()) {
+    }
+
+    SDL_UnlockJoysticks();
+}
+
+static bool HIDAPI_IsEquivalentToDevice(Uint16 vendor_id, Uint16 product_id, SDL_HIDAPI_Device *device)
+{
+    if (vendor_id == device->vendor_id && product_id == device->product_id) {
+        return true;
+    }
+
+    if (vendor_id == USB_VENDOR_MICROSOFT) {
+        // If we're looking for the wireless XBox 360 controller, also look for the dongle
+        if (product_id == USB_PRODUCT_XBOX360_XUSB_CONTROLLER && device->product_id == USB_PRODUCT_XBOX360_WIRELESS_RECEIVER) {
+            return true;
+        }
+
+        // If we're looking for the raw input Xbox One controller, match it against any other Xbox One controller
+        if (product_id == USB_PRODUCT_XBOX_ONE_XBOXGIP_CONTROLLER &&
+            device->type == SDL_GAMEPAD_TYPE_XBOXONE) {
+            return true;
+        }
+
+        // If we're looking for an XInput controller, match it against any other Xbox controller
+        if (product_id == USB_PRODUCT_XBOX360_XUSB_CONTROLLER) {
+            if (device->type == SDL_GAMEPAD_TYPE_XBOX360 || device->type == SDL_GAMEPAD_TYPE_XBOXONE) {
+                return true;
+            }
+        }
+    }
+
+    if (vendor_id == USB_VENDOR_NVIDIA) {
+        // If we're looking for the NVIDIA SHIELD controller Xbox interface, match it against any NVIDIA SHIELD controller
+        if (product_id == 0xb400 &&
+            SDL_IsJoystickNVIDIASHIELDController(vendor_id, product_id)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+static bool HIDAPI_StartUpdatingDevices(void)
+{
+    return SDL_CompareAndSwapAtomicInt(&SDL_HIDAPI_updating_devices, false, true);
+}
+
+static void HIDAPI_FinishUpdatingDevices(void)
+{
+    SDL_SetAtomicInt(&SDL_HIDAPI_updating_devices, false);
+}
+
+bool HIDAPI_IsDeviceTypePresent(SDL_GamepadType type)
+{
+    SDL_HIDAPI_Device *device;
+    bool result = false;
+
+    // Make sure we're initialized, as this could be called from other drivers during startup
+    if (!HIDAPI_JoystickInit()) {
+        return false;
+    }
+
+    if (HIDAPI_StartUpdatingDevices()) {
+        HIDAPI_UpdateDeviceList();
+        HIDAPI_FinishUpdatingDevices();
+    }
+
+    SDL_LockJoysticks();
+    for (device = SDL_HIDAPI_devices; device; device = device->next) {
+        if (device->driver && device->type == type) {
+            result = true;
+            break;
+        }
+    }
+    SDL_UnlockJoysticks();
+
+#ifdef DEBUG_HIDAPI
+    SDL_Log("HIDAPI_IsDeviceTypePresent() returning %s for %d", result ? "true" : "false", type);
+#endif
+    return result;
+}
+
+bool HIDAPI_IsDevicePresent(Uint16 vendor_id, Uint16 product_id, Uint16 version, const char *name)
+{
+    SDL_HIDAPI_Device *device;
+    bool supported = false;
+    bool result = false;
+
+    // Make sure we're initialized, as this could be called from other drivers during startup
+    if (!HIDAPI_JoystickInit()) {
+        return false;
+    }
+
+    /* Only update the device list for devices we know might be supported.
+       If we did this for every device, it would hit the USB driver too hard and potentially
+       lock up the system. This won't catch devices that we support but can only detect using
+       USB interface details, like Xbox controllers, but hopefully the device list update is
+       responsive enough to catch those.
+     */
+    supported = HIDAPI_IsDeviceSupported(vendor_id, product_id, version, name);
+#if defined(SDL_JOYSTICK_HIDAPI_XBOX360) || defined(SDL_JOYSTICK_HIDAPI_XBOXONE)
+    if (!supported &&
+        (SDL_strstr(name, "Xbox") || SDL_strstr(name, "X-Box") || SDL_strstr(name, "XBOX"))) {
+        supported = true;
+    }
+#endif // SDL_JOYSTICK_HIDAPI_XBOX360 || SDL_JOYSTICK_HIDAPI_XBOXONE
+    if (supported) {
+        if (HIDAPI_StartUpdatingDevices()) {
+            HIDAPI_UpdateDeviceList();
+            HIDAPI_FinishUpdatingDevices();
+        }
+    }
+
+    /* Note that this isn't a perfect check - there may be multiple devices with 0 VID/PID,
+       or a different name than we have it listed here, etc, but if we support the device
+       and we have something similar in our device list, mark it as present.
+     */
+    SDL_LockJoysticks();
+    for (device = SDL_HIDAPI_devices; device; device = device->next) {
+        if (device->driver &&
+            HIDAPI_IsEquivalentToDevice(vendor_id, product_id, device)) {
+            result = true;
+            break;
+        }
+    }
+    SDL_UnlockJoysticks();
+
+#ifdef DEBUG_HIDAPI
+    SDL_Log("HIDAPI_IsDevicePresent() returning %s for 0x%.4x / 0x%.4x", result ? "true" : "false", vendor_id, product_id);
+#endif
+    return result;
+}
+
+char *HIDAPI_GetDeviceProductName(Uint16 vendor_id, Uint16 product_id)
+{
+    SDL_HIDAPI_Device *device;
+    char *name = NULL;
+
+    SDL_LockJoysticks();
+    for (device = SDL_HIDAPI_devices; device; device = device->next) {
+        if (vendor_id == device->vendor_id && product_id == device->product_id) {
+            if (device->product_string) {
+                name = SDL_strdup(device->product_string);
+            }
+            break;
+        }
+    }
+    SDL_UnlockJoysticks();
+
+    return name;
+}
+
+char *HIDAPI_GetDeviceManufacturerName(Uint16 vendor_id, Uint16 product_id)
+{
+    SDL_HIDAPI_Device *device;
+    char *name = NULL;
+
+    SDL_LockJoysticks();
+    for (device = SDL_HIDAPI_devices; device; device = device->next) {
+        if (vendor_id == device->vendor_id && product_id == device->product_id) {
+            if (device->manufacturer_string) {
+                name = SDL_strdup(device->manufacturer_string);
+            }
+            break;
+        }
+    }
+    SDL_UnlockJoysticks();
+
+    return name;
+}
+
+SDL_JoystickType HIDAPI_GetJoystickTypeFromGUID(SDL_GUID guid)
+{
+    SDL_HIDAPI_Device *device;
+    SDL_JoystickType type = SDL_JOYSTICK_TYPE_UNKNOWN;
+
+    SDL_LockJoysticks();
+    for (device = SDL_HIDAPI_devices; device; device = device->next) {
+        if (SDL_memcmp(&guid, &device->guid, sizeof(guid)) == 0) {
+            type = device->joystick_type;
+            break;
+        }
+    }
+    SDL_UnlockJoysticks();
+
+    return type;
+}
+
+SDL_GamepadType HIDAPI_GetGamepadTypeFromGUID(SDL_GUID guid)
+{
+    SDL_HIDAPI_Device *device;
+    SDL_GamepadType type = SDL_GAMEPAD_TYPE_STANDARD;
+
+    SDL_LockJoysticks();
+    for (device = SDL_HIDAPI_devices; device; device = device->next) {
+        if (SDL_memcmp(&guid, &device->guid, sizeof(guid)) == 0) {
+            type = device->type;
+            break;
+        }
+    }
+    SDL_UnlockJoysticks();
+
+    return type;
+}
+
+static void HIDAPI_JoystickDetect(void)
+{
+    if (HIDAPI_StartUpdatingDevices()) {
+        Uint32 count = SDL_hid_device_change_count();
+        if (SDL_HIDAPI_change_count != count) {
+            SDL_HIDAPI_change_count = count;
+            HIDAPI_UpdateDeviceList();
+        }
+        HIDAPI_FinishUpdatingDevices();
+    }
+}
+
+void HIDAPI_UpdateDevices(void)
+{
+    SDL_HIDAPI_Device *device;
+
+    SDL_AssertJoysticksLocked();
+
+    // Update the devices, which may change connected joysticks and send events
+
+    // Prepare the existing device list
+    if (HIDAPI_StartUpdatingDevices()) {
+        for (device = SDL_HIDAPI_devices; device; device = device->next) {
+            if (device->parent) {
+                continue;
+            }
+            if (device->driver) {
+                if (SDL_TryLockMutex(device->dev_lock)) {
+                    device->updating = true;
+                    device->driver->UpdateDevice(device);
+                    device->updating = false;
+                    SDL_UnlockMutex(device->dev_lock);
+                }
+            }
+        }
+        HIDAPI_FinishUpdatingDevices();
+    }
+}
+
+static const char *HIDAPI_JoystickGetDeviceName(int device_index)
+{
+    SDL_HIDAPI_Device *device;
+    const char *name = NULL;
+
+    device = HIDAPI_GetDeviceByIndex(device_index, NULL);
+    if (device) {
+        // FIXME: The device could be freed after this name is returned...
+        name = device->name;
+    }
+
+    return name;
+}
+
+static const char *HIDAPI_JoystickGetDevicePath(int device_index)
+{
+    SDL_HIDAPI_Device *device;
+    const char *path = NULL;
+
+    device = HIDAPI_GetDeviceByIndex(device_index, NULL);
+    if (device) {
+        // FIXME: The device could be freed after this path is returned...
+        path = device->path;
+    }
+
+    return path;
+}
+
+static int HIDAPI_JoystickGetDeviceSteamVirtualGamepadSlot(int device_index)
+{
+    SDL_HIDAPI_Device *device;
+
+    device = HIDAPI_GetDeviceByIndex(device_index, NULL);
+    if (device) {
+        return device->steam_virtual_gamepad_slot;
+    }
+    return -1;
+}
+
+static int HIDAPI_JoystickGetDevicePlayerIndex(int device_index)
+{
+    SDL_HIDAPI_Device *device;
+    SDL_JoystickID instance_id;
+    int player_index = -1;
+
+    device = HIDAPI_GetDeviceByIndex(device_index, &instance_id);
+    if (device) {
+        player_index = device->driver->GetDevicePlayerIndex(device, instance_id);
+    }
+
+    return player_index;
+}
+
+static void HIDAPI_JoystickSetDevicePlayerIndex(int device_index, int player_index)
+{
+    SDL_HIDAPI_Device *device;
+    SDL_JoystickID instance_id;
+
+    device = HIDAPI_GetDeviceByIndex(device_index, &instance_id);
+    if (device) {
+        device->driver->SetDevicePlayerIndex(device, instance_id, player_index);
+    }
+}
+
+static SDL_GUID HIDAPI_JoystickGetDeviceGUID(int device_index)
+{
+    SDL_HIDAPI_Device *device;
+    SDL_GUID guid;
+
+    device = HIDAPI_GetDeviceByIndex(device_index, NULL);
+    if (device) {
+        SDL_memcpy(&guid, &device->guid, sizeof(guid));
+    } else {
+        SDL_zero(guid);
+    }
+
+    return guid;
+}
+
+static SDL_JoystickID HIDAPI_JoystickGetDeviceInstanceID(int device_index)
+{
+    SDL_JoystickID joystickID = 0;
+    HIDAPI_GetDeviceByIndex(device_index, &joystickID);
+    return joystickID;
+}
+
+static bool HIDAPI_JoystickOpen(SDL_Joystick *joystick, int device_index)
+{
+    SDL_JoystickID joystickID = 0;
+    SDL_HIDAPI_Device *device = HIDAPI_GetDeviceByIndex(device_index, &joystickID);
+    struct joystick_hwdata *hwdata;
+
+    SDL_AssertJoysticksLocked();
+
+    if (!device || !device->driver || device->broken) {
+        // This should never happen - validated before being called
+        return SDL_SetError("Couldn't find HIDAPI device at index %d", device_index);
+    }
+
+    hwdata = (struct joystick_hwdata *)SDL_calloc(1, sizeof(*hwdata));
+    if (!hwdata) {
+        return false;
+    }
+    hwdata->device = device;
+
+    // Process any pending reports before opening the device
+    SDL_LockMutex(device->dev_lock);
+    device->updating = true;
+    device->driver->UpdateDevice(device);
+    device->updating = false;
+    SDL_UnlockMutex(device->dev_lock);
+
+    // UpdateDevice() may have called HIDAPI_JoystickDisconnected() if the device went away
+    if (device->num_joysticks == 0) {
+        SDL_free(hwdata);
+        return SDL_SetError("HIDAPI device disconnected while opening");
+    }
+
+    // Set the default connection state, can be overridden below
+    if (device->is_bluetooth) {
+        joystick->connection_state = SDL_JOYSTICK_CONNECTION_WIRELESS;
+    } else {
+        joystick->connection_state = SDL_JOYSTICK_CONNECTION_WIRED;
+    }
+
+    if (!device->driver->OpenJoystick(device, joystick)) {
+        // The open failed, mark this device as disconnected and update devices
+        HIDAPI_JoystickDisconnected(device, joystickID);
+        SDL_free(hwdata);
+        return false;
+    }
+
+    HIDAPI_UpdateJoystickProperties(device, joystick);
+
+    if (device->serial) {
+        joystick->serial = SDL_strdup(device->serial);
+    }
+
+    joystick->hwdata = hwdata;
+    return true;
+}
+
+static bool HIDAPI_GetJoystickDevice(SDL_Joystick *joystick, SDL_HIDAPI_Device **device)
+{
+    SDL_AssertJoysticksLocked();
+
+    if (joystick && joystick->hwdata) {
+        *device = joystick->hwdata->device;
+        if (SDL_ObjectValid(*device, SDL_OBJECT_TYPE_HIDAPI_JOYSTICK) && (*device)->driver != NULL) {
+            return true;
+        }
+    }
+    return false;
+}
+
+static bool HIDAPI_JoystickRumble(SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+    bool result;
+    SDL_HIDAPI_Device *device = NULL;
+
+    if (HIDAPI_GetJoystickDevice(joystick, &device)) {
+        result = device->driver->RumbleJoystick(device, joystick, low_frequency_rumble, high_frequency_rumble);
+    } else {
+        result = SDL_SetError("Rumble failed, device disconnected");
+    }
+
+    return result;
+}
+
+static bool HIDAPI_JoystickRumbleTriggers(SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble)
+{
+    bool result;
+    SDL_HIDAPI_Device *device = NULL;
+
+    if (HIDAPI_GetJoystickDevice(joystick, &device)) {
+        result = device->driver->RumbleJoystickTriggers(device, joystick, left_rumble, right_rumble);
+    } else {
+        result = SDL_SetError("Rumble failed, device disconnected");
+    }
+
+    return result;
+}
+
+static bool HIDAPI_JoystickSetLED(SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue)
+{
+    bool result;
+    SDL_HIDAPI_Device *device = NULL;
+
+    if (HIDAPI_GetJoystickDevice(joystick, &device)) {
+        result = device->driver->SetJoystickLED(device, joystick, red, green, blue);
+    } else {
+        result = SDL_SetError("SetLED failed, device disconnected");
+    }
+
+    return result;
+}
+
+static bool HIDAPI_JoystickSendEffect(SDL_Joystick *joystick, const void *data, int size)
+{
+    bool result;
+    SDL_HIDAPI_Device *device = NULL;
+
+    if (HIDAPI_GetJoystickDevice(joystick, &device)) {
+        result = device->driver->SendJoystickEffect(device, joystick, data, size);
+    } else {
+        result = SDL_SetError("SendEffect failed, device disconnected");
+    }
+
+    return result;
+}
+
+static bool HIDAPI_JoystickSetSensorsEnabled(SDL_Joystick *joystick, bool enabled)
+{
+    bool result;
+    SDL_HIDAPI_Device *device = NULL;
+
+    if (HIDAPI_GetJoystickDevice(joystick, &device)) {
+        result = device->driver->SetJoystickSensorsEnabled(device, joystick, enabled);
+    } else {
+        result = SDL_SetError("SetSensorsEnabled failed, device disconnected");
+    }
+
+    return result;
+}
+
+static void HIDAPI_JoystickUpdate(SDL_Joystick *joystick)
+{
+    // This is handled in SDL_HIDAPI_UpdateDevices()
+}
+
+static void HIDAPI_JoystickClose(SDL_Joystick *joystick) SDL_NO_THREAD_SAFETY_ANALYSIS // We unlock the device lock so rumble can complete
+{
+    SDL_AssertJoysticksLocked();
+
+    if (joystick->hwdata) {
+        SDL_HIDAPI_Device *device = joystick->hwdata->device;
+        int i;
+
+        // Wait up to 30 ms for pending rumble to complete
+        if (device->updating) {
+            // Unlock the device so rumble can complete
+            SDL_UnlockMutex(device->dev_lock);
+        }
+        for (i = 0; i < 3; ++i) {
+            if (SDL_GetAtomicInt(&device->rumble_pending) > 0) {
+                SDL_Delay(10);
+            }
+        }
+        if (device->updating) {
+            // Relock the device
+            SDL_LockMutex(device->dev_lock);
+        }
+
+        device->driver->CloseJoystick(device, joystick);
+
+        SDL_free(joystick->hwdata);
+        joystick->hwdata = NULL;
+    }
+}
+
+static void HIDAPI_JoystickQuit(void)
+{
+    int i;
+
+    SDL_AssertJoysticksLocked();
+
+    shutting_down = true;
+
+    SDL_HIDAPI_QuitRumble();
+
+    while (SDL_HIDAPI_devices) {
+        SDL_HIDAPI_Device *device = SDL_HIDAPI_devices;
+        if (device->parent) {
+            // When a child device goes away, so does the parent
+            device = device->parent;
+            for (i = 0; i < device->num_children; ++i) {
+                HIDAPI_DelDevice(device->children[i]);
+            }
+            HIDAPI_DelDevice(device);
+        } else {
+            HIDAPI_DelDevice(device);
+        }
+    }
+
+    // Make sure the drivers cleaned up properly
+    SDL_assert(SDL_HIDAPI_numjoysticks == 0);
+
+    for (i = 0; i < SDL_arraysize(SDL_HIDAPI_drivers); ++i) {
+        SDL_HIDAPI_DeviceDriver *driver = SDL_HIDAPI_drivers[i];
+        driver->UnregisterHints(SDL_HIDAPIDriverHintChanged, driver);
+    }
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI_COMBINE_JOY_CONS,
+                        SDL_HIDAPIDriverHintChanged, NULL);
+    SDL_RemoveHintCallback(SDL_HINT_JOYSTICK_HIDAPI,
+                        SDL_HIDAPIDriverHintChanged, NULL);
+
+    SDL_hid_exit();
+
+    SDL_HIDAPI_change_count = 0;
+    shutting_down = false;
+    initialized = false;
+}
+
+static bool HIDAPI_JoystickGetGamepadMapping(int device_index, SDL_GamepadMapping *out)
+{
+    return false;
+}
+
+SDL_JoystickDriver SDL_HIDAPI_JoystickDriver = {
+    HIDAPI_JoystickInit,
+    HIDAPI_JoystickGetCount,
+    HIDAPI_JoystickDetect,
+    HIDAPI_IsDevicePresent,
+    HIDAPI_JoystickGetDeviceName,
+    HIDAPI_JoystickGetDevicePath,
+    HIDAPI_JoystickGetDeviceSteamVirtualGamepadSlot,
+    HIDAPI_JoystickGetDevicePlayerIndex,
+    HIDAPI_JoystickSetDevicePlayerIndex,
+    HIDAPI_JoystickGetDeviceGUID,
+    HIDAPI_JoystickGetDeviceInstanceID,
+    HIDAPI_JoystickOpen,
+    HIDAPI_JoystickRumble,
+    HIDAPI_JoystickRumbleTriggers,
+    HIDAPI_JoystickSetLED,
+    HIDAPI_JoystickSendEffect,
+    HIDAPI_JoystickSetSensorsEnabled,
+    HIDAPI_JoystickUpdate,
+    HIDAPI_JoystickClose,
+    HIDAPI_JoystickQuit,
+    HIDAPI_JoystickGetGamepadMapping
+};
+
+#endif // SDL_JOYSTICK_HIDAPI
diff --git a/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapijoystick_c.h b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapijoystick_c.h
new file mode 100644
index 0000000..9cd9f40
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/joystick/hidapi/SDL_hidapijoystick_c.h
@@ -0,0 +1,195 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifndef SDL_JOYSTICK_HIDAPI_H
+#define SDL_JOYSTICK_HIDAPI_H
+
+#include "../usb_ids.h"
+
+// This is the full set of HIDAPI drivers available
+#define SDL_JOYSTICK_HIDAPI_GAMECUBE
+#define SDL_JOYSTICK_HIDAPI_LUNA
+#define SDL_JOYSTICK_HIDAPI_PS3
+#define SDL_JOYSTICK_HIDAPI_PS4
+#define SDL_JOYSTICK_HIDAPI_PS5
+#define SDL_JOYSTICK_HIDAPI_STADIA
+#define SDL_JOYSTICK_HIDAPI_STEAM
+#define SDL_JOYSTICK_HIDAPI_STEAMDECK
+#define SDL_JOYSTICK_HIDAPI_SWITCH
+#define SDL_JOYSTICK_HIDAPI_WII
+#define SDL_JOYSTICK_HIDAPI_XBOX360
+#define SDL_JOYSTICK_HIDAPI_XBOXONE
+#define SDL_JOYSTICK_HIDAPI_SHIELD
+#define SDL_JOYSTICK_HIDAPI_STEAM_HORI
+
+// Joystick capability definitions
+#define SDL_JOYSTICK_CAP_MONO_LED       0x00000001
+#define SDL_JOYSTICK_CAP_RGB_LED        0x00000002
+#define SDL_JOYSTICK_CAP_PLAYER_LED     0x00000004
+#define SDL_JOYSTICK_CAP_RUMBLE         0x00000010
+#define SDL_JOYSTICK_CAP_TRIGGER_RUMBLE 0x00000020
+
+// Whether HIDAPI is enabled by default
+#if defined(SDL_PLATFORM_ANDROID) || \
+    defined(SDL_PLATFORM_IOS) || \
+    defined(SDL_PLATFORM_TVOS) || \
+    defined(SDL_PLATFORM_VISIONOS)
+// On Android, HIDAPI prompts for permissions and acquires exclusive access to the device, and on Apple mobile platforms it doesn't do anything except for handling Bluetooth Steam Controllers, so we'll leave it off by default.
+#define SDL_HIDAPI_DEFAULT false
+#else
+#define SDL_HIDAPI_DEFAULT true
+#endif
+
+// The maximum size of a USB packet for HID devices
+#define USB_PACKET_LENGTH 64
+
+// Forward declaration
+struct SDL_HIDAPI_DeviceDriver;
+
+typedef struct SDL_HIDAPI_Device
+{
+    char *name;
+    char *manufacturer_string;
+    char *product_string;
+    char *path;
+    Uint16 vendor_id;
+    Uint16 product_id;
+    Uint16 version;
+    char *serial;
+    SDL_GUID guid;
+    int interface_number; // Available on Windows and Linux
+    int interface_class;
+    int interface_subclass;
+    int interface_protocol;
+    Uint16 usage_page; // Available on Windows and macOS
+    Uint16 usage;      // Available on Windows and macOS
+    bool is_bluetooth;
+    SDL_JoystickType joystick_type;
+    SDL_GamepadType type;
+    int steam_virtual_gamepad_slot;
+
+    struct SDL_HIDAPI_DeviceDriver *driver;
+    void *context;
+    SDL_Mutex *dev_lock;
+    SDL_hid_device *dev;
+    SDL_AtomicInt rumble_pending;
+    int num_joysticks;
+    SDL_JoystickID *joysticks;
+
+    // Used during scanning for device changes
+    bool seen;
+
+    // Used to flag that the device is being updated
+    bool updating;
+
+    // Used to flag devices that failed open
+    // This can happen on Windows with Bluetooth devices that have turned off
+    bool broken;
+
+    struct SDL_HIDAPI_Device *parent;
+    int num_children;
+    struct SDL_HIDAPI_Device **children;
+
+    struct SDL_HIDAPI_Device *next;
+} SDL_HIDAPI_Device;
+
+typedef struct SDL_HIDAPI_DeviceDriver
+{
+    const char *name;
+    bool enabled;
+    void (*RegisterHints)(SDL_HintCallback callback, void *userdata);
+    void (*UnregisterHints)(SDL_HintCallback callback, void *userdata);
+    bool (*IsEnabled)(void);
+    bool (*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);
+    bool (*InitDevice)(SDL_HIDAPI_Device *device);
+    int (*GetDevicePlayerIndex)(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id);
+    void (*SetDevicePlayerIndex)(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id, int player_index);
+    bool (*UpdateDevice)(SDL_HIDAPI_Device *device);
+    bool (*OpenJoystick)(SDL_HIDAPI_Device *device, SDL_Joystick *joystick);
+    bool (*RumbleJoystick)(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble);
+    bool (*RumbleJoystickTriggers)(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 left_rumble, Uint16 right_rumble);
+    Uint32 (*GetJoystickCapabilities)(SDL_HIDAPI_Device *device, SDL_Joystick *joystick);
+    bool (*SetJoystickLED)(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint8 red, Uint8 green, Uint8 blue);
+    bool (*SendJoystickEffect)(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, const void *data, int size);
+    bool (*SetJoystickSensorsEnabled)(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, bool enabled);
+    void (*CloseJoystick)(SDL_HIDAPI_Device *device, SDL_Joystick *joystick);
+    void (*FreeDevice)(SDL_HIDAPI_Device *device);
+
+} SDL_HIDAPI_DeviceDriver;
+
+// HIDAPI device support
+extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverCombined;
+extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverGameCube;
+extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverJoyCons;
+extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverLuna;
+extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverNintendoClassic;
+extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverPS3;
+extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverPS3ThirdParty;
+extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverPS3SonySixaxis;
+extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverPS4;
+extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverPS5;
+extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverShield;
+extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverStadia;
+extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverSteam;
+extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverSteamDeck;
+extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverSwitch;
+extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverWii;
+extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverXbox360;
+extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverXbox360W;
+extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverXboxOne;
+extern SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverSteamHori;
+
+// Return true if a HID device is present and supported as a joystick of the given type
+extern bool HIDAPI_IsDeviceTypePresent(SDL_GamepadType type);
+
+// Return true if a HID device is present and supported as a joystick
+extern bool HIDAPI_IsDevicePresent(Uint16 vendor_id, Uint16 product_id, Uint16 version, const char *name);
+
+// Return the name of a connected device, which should be freed with SDL_free(), or NULL if it's not available
+extern char *HIDAPI_GetDeviceProductName(Uint16 vendor_id, Uint16 product_id);
+
+// Return the manufacturer of a connected device, which should be freed with SDL_free(), or NULL if it's not available
+extern char *HIDAPI_GetDeviceManufacturerName(Uint16 vendor_id, Uint16 product_id);
+
+// Return the type of a joystick if it's present and supported
+extern SDL_JoystickType HIDAPI_GetJoystickTypeFromGUID(SDL_GUID guid);
+
+// Return the type of a game controller if it's present and supported
+extern SDL_GamepadType HIDAPI_GetGamepadTypeFromGUID(SDL_GUID guid);
+
+extern void HIDAPI_UpdateDevices(void);
+extern void HIDAPI_SetDeviceName(SDL_HIDAPI_Device *device, const char *name);
+extern void HIDAPI_SetDeviceProduct(SDL_HIDAPI_Device *device, Uint16 vendor_id, Uint16 product_id);
+extern void HIDAPI_SetDeviceSerial(SDL_HIDAPI_Device *device, const char *serial);
+extern bool HIDAPI_HasConnectedUSBDevice(const char *serial);
+extern void HIDAPI_DisconnectBluetoothDevice(const char *serial);
+extern bool HIDAPI_JoystickConnected(SDL_HIDAPI_Device *device, SDL_JoystickID *pJoystickID);
+extern void HIDAPI_JoystickDisconnected(SDL_HIDAPI_Device *device, SDL_JoystickID joystickID);
+extern void HIDAPI_UpdateDeviceProperties(SDL_HIDAPI_Device *device);
+
+extern void HIDAPI_DumpPacket(const char *prefix, const Uint8 *data, int size);
+
+extern bool HIDAPI_SupportsPlaystationDetection(Uint16 vendor, Uint16 product);
+
+extern float HIDAPI_RemapVal(float val, float val_min, float val_max, float output_min, float output_max);
+
+#endif // SDL_JOYSTICK_HIDAPI_H
diff --git a/contrib/SDL-3.2.8/src/joystick/hidapi/steam/controller_constants.h b/contrib/SDL-3.2.8/src/joystick/hidapi/steam/controller_constants.h
new file mode 100644
index 0000000..78af016
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/joystick/hidapi/steam/controller_constants.h
@@ -0,0 +1,582 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 2021 Valve Corporation
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+
+#ifndef _CONTROLLER_CONSTANTS_
+#define _CONTROLLER_CONSTANTS_
+
+#include "controller_structs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define FEATURE_REPORT_SIZE     64
+
+#define VALVE_USB_VID           0x28DE
+
+// Frame update rate (in ms).
+#define FAST_SCAN_INTERVAL  6
+#define SLOW_SCAN_INTERVAL  9
+
+// Contains each of the USB PIDs for Valve controllers (only add to this enum and never change the order)
+enum ValveControllerPID
+{
+        BASTILLE_PID              = 0x2202,
+        CHELL_PID                 = 0x1101,
+        D0G_PID                   = 0x1102,
+        ELI_PID                   = 0x1103,
+        FREEMAN_PID               = 0x1104,
+        D0G_BLE_PID                               = 0x1105,
+        D0G_BLE2_PID                      = 0x1106,
+        D0GGLE_PID                = 0x1142,
+
+        JUPITER_PID               = 0x1205,
+};
+
+// This enum contains all of the messages exchanged between the host and the target (only add to this enum and never change the order)
+enum FeatureReportMessageIDs
+{
+        ID_SET_DIGITAL_MAPPINGS              = 0x80,
+        ID_CLEAR_DIGITAL_MAPPINGS            = 0x81,
+        ID_GET_DIGITAL_MAPPINGS              = 0x82,
+        ID_GET_ATTRIBUTES_VALUES             = 0x83,
+        ID_GET_ATTRIBUTE_LABEL               = 0x84,
+        ID_SET_DEFAULT_DIGITAL_MAPPINGS      = 0x85,
+        ID_FACTORY_RESET                     = 0x86,
+        ID_SET_SETTINGS_VALUES               = 0x87,
+        ID_CLEAR_SETTINGS_VALUES             = 0x88,
+        ID_GET_SETTINGS_VALUES               = 0x89,
+        ID_GET_SETTING_LABEL                 = 0x8A,
+        ID_GET_SETTINGS_MAXS                 = 0x8B,
+        ID_GET_SETTINGS_DEFAULTS             = 0x8C,
+        ID_SET_CONTROLLER_MODE               = 0x8D,
+        ID_LOAD_DEFAULT_SETTINGS             = 0x8E,
+        ID_TRIGGER_HAPTIC_PULSE              = 0x8F,
+
+        ID_TURN_OFF_CONTROLLER               = 0x9F,
+
+        ID_GET_DEVICE_INFO                   = 0xA1,
+
+        ID_CALIBRATE_TRACKPADS               = 0xA7,
+        ID_RESERVED_0                        = 0xA8,
+        ID_SET_SERIAL_NUMBER                 = 0xA9,
+        ID_GET_TRACKPAD_CALIBRATION          = 0xAA,
+        ID_GET_TRACKPAD_FACTORY_CALIBRATION  = 0xAB,
+        ID_GET_TRACKPAD_RAW_DATA             = 0xAC,
+        ID_ENABLE_PAIRING                    = 0xAD,
+        ID_GET_STRING_ATTRIBUTE              = 0xAE,
+        ID_RADIO_ERASE_RECORDS               = 0xAF,
+        ID_RADIO_WRITE_RECORD                = 0xB0,
+        ID_SET_DONGLE_SETTING                = 0xB1,
+        ID_DONGLE_DISCONNECT_DEVICE          = 0xB2,
+        ID_DONGLE_COMMIT_DEVICE              = 0xB3,
+        ID_DONGLE_GET_WIRELESS_STATE         = 0xB4,
+        ID_CALIBRATE_GYRO                    = 0xB5,
+        ID_PLAY_AUDIO                        = 0xB6,
+        ID_AUDIO_UPDATE_START                = 0xB7,
+        ID_AUDIO_UPDATE_DATA                 = 0xB8,
+        ID_AUDIO_UPDATE_COMPLETE             = 0xB9,
+        ID_GET_CHIPID                        = 0xBA,
+
+        ID_CALIBRATE_JOYSTICK                = 0xBF,
+        ID_CALIBRATE_ANALOG_TRIGGERS         = 0xC0,
+        ID_SET_AUDIO_MAPPING                 = 0xC1,
+        ID_CHECK_GYRO_FW_LOAD                = 0xC2,
+        ID_CALIBRATE_ANALOG                  = 0xC3,
+        ID_DONGLE_GET_CONNECTED_SLOTS        = 0xC4,
+
+        ID_RESET_IMU                         = 0xCE,
+
+        // Deck only
+        ID_TRIGGER_HAPTIC_CMD                = 0xEA,
+        ID_TRIGGER_RUMBLE_CMD                = 0xEB,
+};
+
+
+// Enumeration of all wireless dongle events
+typedef enum WirelessEventTypes
+{
+        WIRELESS_EVENT_DISCONNECT       = 1,
+        WIRELESS_EVENT_CONNECT          = 2,
+        WIRELESS_EVENT_PAIR                     = 3,
+} EWirelessEventType;
+
+
+// Enumeration of generic digital inputs - not all of these will be supported on all controllers (only add to this enum and never change the order)
+typedef enum
+{
+        IO_DIGITAL_BUTTON_NONE = -1,
+        IO_DIGITAL_BUTTON_RIGHT_TRIGGER,
+        IO_DIGITAL_BUTTON_LEFT_TRIGGER,
+        IO_DIGITAL_BUTTON_1,
+        IO_DIGITAL_BUTTON_Y=IO_DIGITAL_BUTTON_1,
+        IO_DIGITAL_BUTTON_2,
+        IO_DIGITAL_BUTTON_B=IO_DIGITAL_BUTTON_2,
+        IO_DIGITAL_BUTTON_3,
+        IO_DIGITAL_BUTTON_X=IO_DIGITAL_BUTTON_3,
+        IO_DIGITAL_BUTTON_4,
+        IO_DIGITAL_BUTTON_A=IO_DIGITAL_BUTTON_4,
+        IO_DIGITAL_BUTTON_RIGHT_BUMPER,
+        IO_DIGITAL_BUTTON_LEFT_BUMPER,
+        IO_DIGITAL_BUTTON_LEFT_JOYSTICK_CLICK,
+        IO_DIGITAL_BUTTON_ESCAPE,
+        IO_DIGITAL_BUTTON_STEAM,
+        IO_DIGITAL_BUTTON_MENU,
+        IO_DIGITAL_STICK_UP,
+        IO_DIGITAL_STICK_DOWN,
+        IO_DIGITAL_STICK_LEFT,
+        IO_DIGITAL_STICK_RIGHT,
+        IO_DIGITAL_TOUCH_1,
+        IO_DIGITAL_BUTTON_UP=IO_DIGITAL_TOUCH_1,
+        IO_DIGITAL_TOUCH_2,
+        IO_DIGITAL_BUTTON_RIGHT=IO_DIGITAL_TOUCH_2,
+        IO_DIGITAL_TOUCH_3,
+        IO_DIGITAL_BUTTON_LEFT=IO_DIGITAL_TOUCH_3,
+        IO_DIGITAL_TOUCH_4,
+        IO_DIGITAL_BUTTON_DOWN=IO_DIGITAL_TOUCH_4,
+        IO_DIGITAL_BUTTON_BACK_LEFT,
+        IO_DIGITAL_BUTTON_BACK_RIGHT,
+        IO_DIGITAL_LEFT_TRACKPAD_N,
+        IO_DIGITAL_LEFT_TRACKPAD_NE,
+        IO_DIGITAL_LEFT_TRACKPAD_E,
+        IO_DIGITAL_LEFT_TRACKPAD_SE,
+        IO_DIGITAL_LEFT_TRACKPAD_S,
+        IO_DIGITAL_LEFT_TRACKPAD_SW,
+        IO_DIGITAL_LEFT_TRACKPAD_W,
+        IO_DIGITAL_LEFT_TRACKPAD_NW,
+        IO_DIGITAL_RIGHT_TRACKPAD_N,
+        IO_DIGITAL_RIGHT_TRACKPAD_NE,
+        IO_DIGITAL_RIGHT_TRACKPAD_E,
+        IO_DIGITAL_RIGHT_TRACKPAD_SE,
+        IO_DIGITAL_RIGHT_TRACKPAD_S,
+        IO_DIGITAL_RIGHT_TRACKPAD_SW,
+        IO_DIGITAL_RIGHT_TRACKPAD_W,
+        IO_DIGITAL_RIGHT_TRACKPAD_NW,
+        IO_DIGITAL_LEFT_TRACKPAD_DOUBLE_TAP,
+        IO_DIGITAL_RIGHT_TRACKPAD_DOUBLE_TAP,
+        IO_DIGITAL_LEFT_TRACKPAD_OUTER_RADIUS,
+        IO_DIGITAL_RIGHT_TRACKPAD_OUTER_RADIUS,
+        IO_DIGITAL_LEFT_TRACKPAD_CLICK,
+        IO_DIGITAL_RIGHT_TRACKPAD_CLICK,
+        IO_DIGITAL_BATTERY_LOW,
+        IO_DIGITAL_LEFT_TRIGGER_THRESHOLD,
+        IO_DIGITAL_RIGHT_TRIGGER_THRESHOLD,
+        IO_DIGITAL_BUTTON_BACK_LEFT2,
+        IO_DIGITAL_BUTTON_BACK_RIGHT2,
+        IO_DIGITAL_BUTTON_ALWAYS_ON,
+        IO_DIGITAL_BUTTON_ANCILLARY_1,
+        IO_DIGITAL_BUTTON_MACRO_0,
+        IO_DIGITAL_BUTTON_MACRO_1,
+        IO_DIGITAL_BUTTON_MACRO_2,
+        IO_DIGITAL_BUTTON_MACRO_3,
+        IO_DIGITAL_BUTTON_MACRO_4,
+        IO_DIGITAL_BUTTON_MACRO_5,
+        IO_DIGITAL_BUTTON_MACRO_6,
+        IO_DIGITAL_BUTTON_MACRO_7,
+        IO_DIGITAL_BUTTON_MACRO_1FINGER,
+        IO_DIGITAL_BUTTON_MACRO_2FINGER,
+        IO_DIGITAL_COUNT
+} DigitalIO ;
+
+// Enumeration of generic analog inputs - not all of these will be supported on all controllers (only add to this enum and never change the order)
+typedef enum 
+{
+        IO_ANALOG_LEFT_STICK_X,
+        IO_ANALOG_LEFT_STICK_Y,
+        IO_ANALOG_RIGHT_STICK_X,
+        IO_ANALOG_RIGHT_STICK_Y,
+        IO_ANALOG_LEFT_TRIGGER,
+        IO_ANALOG_RIGHT_TRIGGER,
+        IO_MOUSE1_X,
+        IO_MOUSE1_Y,
+        IO_MOUSE1_Z,
+        IO_ACCEL_X,
+        IO_ACCEL_Y,
+        IO_ACCEL_Z,
+        IO_GYRO_X,
+        IO_GYRO_Y,
+        IO_GYRO_Z,
+        IO_GYRO_QUAT_W,
+        IO_GYRO_QUAT_X,
+        IO_GYRO_QUAT_Y,
+        IO_GYRO_QUAT_Z,
+        IO_GYRO_STEERING_VEC,
+        IO_RAW_TRIGGER_LEFT,
+        IO_RAW_TRIGGER_RIGHT,
+        IO_RAW_JOYSTICK_X,
+        IO_RAW_JOYSTICK_Y,
+        IO_GYRO_TILT_VEC,
+        IO_PRESSURE_LEFT_PAD,
+        IO_PRESSURE_RIGHT_PAD,
+        IO_PRESSURE_LEFT_BUMPER,
+        IO_PRESSURE_RIGHT_BUMPER,
+        IO_PRESSURE_LEFT_GRIP,
+        IO_PRESSURE_RIGHT_GRIP,
+        IO_ANALOG_LEFT_TRIGGER_THRESHOLD,
+        IO_ANALOG_RIGHT_TRIGGER_THRESHOLD,
+        IO_PRESSURE_RIGHT_PAD_THRESHOLD,
+        IO_PRESSURE_LEFT_PAD_THRESHOLD,
+        IO_PRESSURE_RIGHT_BUMPER_THRESHOLD,
+        IO_PRESSURE_LEFT_BUMPER_THRESHOLD,
+        IO_PRESSURE_RIGHT_GRIP_THRESHOLD,
+        IO_PRESSURE_LEFT_GRIP_THRESHOLD,
+        IO_PRESSURE_RIGHT_PAD_RAW,
+        IO_PRESSURE_LEFT_PAD_RAW,
+        IO_PRESSURE_RIGHT_BUMPER_RAW,
+        IO_PRESSURE_LEFT_BUMPER_RAW,
+        IO_PRESSURE_RIGHT_GRIP_RAW,
+        IO_PRESSURE_LEFT_GRIP_RAW,
+        IO_PRESSURE_RIGHT_GRIP2_THRESHOLD,
+        IO_PRESSURE_LEFT_GRIP2_THRESHOLD,
+        IO_PRESSURE_LEFT_GRIP2,
+        IO_PRESSURE_RIGHT_GRIP2,
+        IO_PRESSURE_RIGHT_GRIP2_RAW,
+        IO_PRESSURE_LEFT_GRIP2_RAW,
+        IO_ANALOG_COUNT
+} AnalogIO;
+
+
+// Contains list of all types of devices that the controller emulates (only add to this enum and never change the order)
+enum DeviceTypes
+{
+        DEVICE_KEYBOARD,
+        DEVICE_MOUSE,
+        DEVICE_GAMEPAD,
+        DEVICE_MODE_ADJUST,
+        DEVICE_COUNT
+};
+
+// Scan codes for HID keyboards 
+enum HIDKeyboardKeys
+{
+        KEY_INVALID,
+        KEY_FIRST = 0x04,
+        KEY_A = KEY_FIRST, KEY_B, KEY_C, KEY_D, KEY_E, KEY_F, KEY_G, KEY_H, KEY_I, KEY_J, KEY_K, KEY_L, 
+        KEY_M, KEY_N, KEY_O, KEY_P, KEY_Q, KEY_R, KEY_S, KEY_T, KEY_U, KEY_V, KEY_W, KEY_X, KEY_Y, KEY_Z, KEY_1, KEY_2, 
+        KEY_3, KEY_4, KEY_5, KEY_6, KEY_7, KEY_8, KEY_9, KEY_0, KEY_RETURN, KEY_ESCAPE, KEY_BACKSPACE, KEY_TAB, KEY_SPACE, KEY_DASH, KEY_EQUALS, KEY_LEFT_BRACKET,
+        KEY_RIGHT_BRACKET, KEY_BACKSLASH, KEY_UNUSED1, KEY_SEMICOLON, KEY_SINGLE_QUOTE, KEY_BACK_TICK, KEY_COMMA, KEY_PERIOD, KEY_FORWARD_SLASH, KEY_CAPSLOCK, KEY_F1, KEY_F2, KEY_F3, KEY_F4, KEY_F5, KEY_F6,
+        KEY_F7, KEY_F8, KEY_F9, KEY_F10, KEY_F11, KEY_F12, KEY_PRINT_SCREEN, KEY_SCROLL_LOCK, KEY_BREAK, KEY_INSERT, KEY_HOME, KEY_PAGE_UP, KEY_DELETE, KEY_END, KEY_PAGE_DOWN, KEY_RIGHT_ARROW,
+        KEY_LEFT_ARROW, KEY_DOWN_ARROW, KEY_UP_ARROW, KEY_NUM_LOCK, KEY_KEYPAD_FORWARD_SLASH, KEY_KEYPAD_ASTERISK, KEY_KEYPAD_DASH, KEY_KEYPAD_PLUS, KEY_KEYPAD_ENTER, KEY_KEYPAD_1, KEY_KEYPAD_2, KEY_KEYPAD_3, KEY_KEYPAD_4, KEY_KEYPAD_5, KEY_KEYPAD_6, KEY_KEYPAD_7,
+        KEY_KEYPAD_8, KEY_KEYPAD_9, KEY_KEYPAD_0, KEY_KEYPAD_PERIOD,
+        KEY_LALT,
+    KEY_LSHIFT,
+    KEY_LWIN,
+    KEY_LCONTROL,
+    KEY_RALT,
+    KEY_RSHIFT,
+    KEY_RWIN,
+    KEY_RCONTROL,
+        KEY_VOLUP,
+        KEY_VOLDOWN,
+        KEY_MUTE,
+        KEY_PLAY,
+        KEY_STOP,
+        KEY_NEXT,
+        KEY_PREV,
+    KEY_LAST = KEY_PREV
+};
+
+enum ModifierMasks
+{
+  KEY_LCONTROL_MASK = (1<<0),
+  KEY_LSHIFT_MASK = (1<<1),
+  KEY_LALT_MASK = (1<<2),
+  KEY_LWIN_MASK = (1<<3),
+  KEY_RCONTROL_MASK = (1<<4),
+  KEY_RSHIFT_MASK = (1<<5),
+  KEY_RALT_MASK = (1<<6),
+  KEY_RWIN_MASK = (1<<7)
+};
+
+// Standard mouse buttons as specified in the HID mouse spec
+enum MouseButtons
+{
+        MOUSE_BTN_LEFT,
+        MOUSE_BTN_RIGHT,
+        MOUSE_BTN_MIDDLE,
+        MOUSE_BTN_BACK,
+        MOUSE_BTN_FORWARD,
+        MOUSE_SCROLL_UP,
+        MOUSE_SCROLL_DOWN,
+        MOUSE_BTN_COUNT
+};
+
+// Gamepad buttons
+enum GamepadButtons
+{
+        GAMEPAD_BTN_TRIGGER_LEFT=1, 
+        GAMEPAD_BTN_TRIGGER_RIGHT,
+        GAMEPAD_BTN_A,
+        GAMEPAD_BTN_B,
+        GAMEPAD_BTN_Y,
+        GAMEPAD_BTN_X,
+        GAMEPAD_BTN_SHOULDER_LEFT,
+        GAMEPAD_BTN_SHOULDER_RIGHT,
+        GAMEPAD_BTN_LEFT_JOYSTICK,
+        GAMEPAD_BTN_RIGHT_JOYSTICK,
+        GAMEPAD_BTN_START,
+        GAMEPAD_BTN_SELECT,
+        GAMEPAD_BTN_STEAM,
+        GAMEPAD_BTN_DPAD_UP,
+        GAMEPAD_BTN_DPAD_DOWN,
+        GAMEPAD_BTN_DPAD_LEFT,
+        GAMEPAD_BTN_DPAD_RIGHT,
+        GAMEPAD_BTN_LSTICK_UP,
+        GAMEPAD_BTN_LSTICK_DOWN,
+        GAMEPAD_BTN_LSTICK_LEFT,
+        GAMEPAD_BTN_LSTICK_RIGHT,
+        GAMEPAD_BTN_RSTICK_UP,
+        GAMEPAD_BTN_RSTICK_DOWN,
+        GAMEPAD_BTN_RSTICK_LEFT,
+        GAMEPAD_BTN_RSTICK_RIGHT,
+        GAMEPAD_BTN_COUNT
+};
+
+// Mode adjust
+enum ModeAdjustModes
+{
+        MODE_ADJUST_SENSITITY=1,
+        MODE_ADJUST_LEFT_PAD_SECONDARY_MODE,
+        MODE_ADJUST_RIGHT_PAD_SECONDARY_MODE,
+        MODE_ADJUST_COUNT
+};
+
+// Read-only attributes of controllers (only add to this enum and never change the order)
+typedef enum
+{
+        ATTRIB_UNIQUE_ID,
+        ATTRIB_PRODUCT_ID,
+        ATTRIB_PRODUCT_REVISON,                                                                                 // deprecated
+        ATTRIB_CAPABILITIES = ATTRIB_PRODUCT_REVISON,   // intentional aliasing
+        ATTRIB_FIRMWARE_VERSION,                                                                                // deprecated
+        ATTRIB_FIRMWARE_BUILD_TIME,
+        ATTRIB_RADIO_FIRMWARE_BUILD_TIME,
+        ATTRIB_RADIO_DEVICE_ID0,
+        ATTRIB_RADIO_DEVICE_ID1,
+        ATTRIB_DONGLE_FIRMWARE_BUILD_TIME,
+        ATTRIB_BOARD_REVISION,
+        ATTRIB_BOOTLOADER_BUILD_TIME,
+        ATTRIB_CONNECTION_INTERVAL_IN_US,
+        ATTRIB_COUNT
+} ControllerAttributes;
+
+// Read-only string attributes of controllers (only add to this enum and never change the order)
+typedef enum
+{
+        ATTRIB_STR_BOARD_SERIAL,
+        ATTRIB_STR_UNIT_SERIAL,
+        ATTRIB_STR_COUNT
+} ControllerStringAttributes;
+
+typedef enum
+{
+        STATUS_CODE_NORMAL,
+        STATUS_CODE_CRITICAL_BATTERY,
+        STATUS_CODE_GYRO_INIT_ERROR,
+} ControllerStatusEventCodes;
+
+typedef enum
+{
+        STATUS_STATE_LOW_BATTERY=0,
+} ControllerStatusStateFlags;
+
+typedef enum {
+        TRACKPAD_ABSOLUTE_MOUSE,
+        TRACKPAD_RELATIVE_MOUSE,
+        TRACKPAD_DPAD_FOUR_WAY_DISCRETE,
+        TRACKPAD_DPAD_FOUR_WAY_OVERLAP,
+        TRACKPAD_DPAD_EIGHT_WAY,
+        TRACKPAD_RADIAL_MODE,
+        TRACKPAD_ABSOLUTE_DPAD,
+        TRACKPAD_NONE,
+        TRACKPAD_GESTURE_KEYBOARD,
+        TRACKPAD_NUM_MODES
+} TrackpadDPadMode;
+
+// Read-write controller settings (only add to this enum and never change the order)
+typedef enum 
+{
+        SETTING_MOUSE_SENSITIVITY,
+        SETTING_MOUSE_ACCELERATION,
+        SETTING_TRACKBALL_ROTATION_ANGLE,
+        SETTING_HAPTIC_INTENSITY_UNUSED,
+        SETTING_LEFT_GAMEPAD_STICK_ENABLED,
+        SETTING_RIGHT_GAMEPAD_STICK_ENABLED,
+        SETTING_USB_DEBUG_MODE,
+        SETTING_LEFT_TRACKPAD_MODE,
+        SETTING_RIGHT_TRACKPAD_MODE,
+        SETTING_MOUSE_POINTER_ENABLED,
+
+        // 10
+        SETTING_DPAD_DEADZONE,
+        SETTING_MINIMUM_MOMENTUM_VEL,
+        SETTING_MOMENTUM_DECAY_AMOUNT,
+        SETTING_TRACKPAD_RELATIVE_MODE_TICKS_PER_PIXEL,
+        SETTING_HAPTIC_INCREMENT,
+        SETTING_DPAD_ANGLE_SIN,
+        SETTING_DPAD_ANGLE_COS,
+        SETTING_MOMENTUM_VERTICAL_DIVISOR,
+        SETTING_MOMENTUM_MAXIMUM_VELOCITY,
+        SETTING_TRACKPAD_Z_ON,
+
+        // 20
+        SETTING_TRACKPAD_Z_OFF,
+        SETTING_SENSITIVITY_SCALE_AMOUNT,
+        SETTING_LEFT_TRACKPAD_SECONDARY_MODE,
+        SETTING_RIGHT_TRACKPAD_SECONDARY_MODE,
+        SETTING_SMOOTH_ABSOLUTE_MOUSE,
+        SETTING_STEAMBUTTON_POWEROFF_TIME,
+        SETTING_UNUSED_1,
+        SETTING_TRACKPAD_OUTER_RADIUS,
+        SETTING_TRACKPAD_Z_ON_LEFT,
+        SETTING_TRACKPAD_Z_OFF_LEFT,
+
+        // 30
+        SETTING_TRACKPAD_OUTER_SPIN_VEL,
+        SETTING_TRACKPAD_OUTER_SPIN_RADIUS,
+        SETTING_TRACKPAD_OUTER_SPIN_HORIZONTAL_ONLY,
+        SETTING_TRACKPAD_RELATIVE_MODE_DEADZONE,
+        SETTING_TRACKPAD_RELATIVE_MODE_MAX_VEL,
+        SETTING_TRACKPAD_RELATIVE_MODE_INVERT_Y,
+        SETTING_TRACKPAD_DOUBLE_TAP_BEEP_ENABLED,
+        SETTING_TRACKPAD_DOUBLE_TAP_BEEP_PERIOD,
+        SETTING_TRACKPAD_DOUBLE_TAP_BEEP_COUNT,
+        SETTING_TRACKPAD_OUTER_RADIUS_RELEASE_ON_TRANSITION,
+
+        // 40
+        SETTING_RADIAL_MODE_ANGLE,
+        SETTING_HAPTIC_INTENSITY_MOUSE_MODE,
+        SETTING_LEFT_DPAD_REQUIRES_CLICK,
+        SETTING_RIGHT_DPAD_REQUIRES_CLICK,
+        SETTING_LED_BASELINE_BRIGHTNESS,
+        SETTING_LED_USER_BRIGHTNESS,
+        SETTING_ENABLE_RAW_JOYSTICK,
+        SETTING_ENABLE_FAST_SCAN,
+        SETTING_IMU_MODE,
+        SETTING_WIRELESS_PACKET_VERSION,
+
+        // 50
+        SETTING_SLEEP_INACTIVITY_TIMEOUT,
+        SETTING_TRACKPAD_NOISE_THRESHOLD,
+        SETTING_LEFT_TRACKPAD_CLICK_PRESSURE,
+        SETTING_RIGHT_TRACKPAD_CLICK_PRESSURE,
+        SETTING_LEFT_BUMPER_CLICK_PRESSURE,
+        SETTING_RIGHT_BUMPER_CLICK_PRESSURE,
+        SETTING_LEFT_GRIP_CLICK_PRESSURE,
+        SETTING_RIGHT_GRIP_CLICK_PRESSURE,
+        SETTING_LEFT_GRIP2_CLICK_PRESSURE,
+        SETTING_RIGHT_GRIP2_CLICK_PRESSURE,
+
+        // 60
+        SETTING_PRESSURE_MODE,
+        SETTING_CONTROLLER_TEST_MODE,
+        SETTING_TRIGGER_MODE,
+        SETTING_TRACKPAD_Z_THRESHOLD,
+        SETTING_FRAME_RATE,
+        SETTING_TRACKPAD_FILT_CTRL,
+        SETTING_TRACKPAD_CLIP,
+        SETTING_DEBUG_OUTPUT_SELECT,
+        SETTING_TRIGGER_THRESHOLD_PERCENT,
+        SETTING_TRACKPAD_FREQUENCY_HOPPING,
+
+        // 70
+        SETTING_HAPTICS_ENABLED,
+        SETTING_STEAM_WATCHDOG_ENABLE,
+        SETTING_TIMP_TOUCH_THRESHOLD_ON,
+        SETTING_TIMP_TOUCH_THRESHOLD_OFF,
+        SETTING_FREQ_HOPPING,
+        SETTING_TEST_CONTROL,
+        SETTING_HAPTIC_MASTER_GAIN_DB,
+        SETTING_THUMB_TOUCH_THRESH,
+        SETTING_DEVICE_POWER_STATUS,
+        SETTING_HAPTIC_INTENSITY,
+
+        // 80
+        SETTING_STABILIZER_ENABLED,
+        SETTING_TIMP_MODE_MTE,
+        SETTING_COUNT,
+        
+        // This is a special setting value use for callbacks and should not be set/get explicitly.
+        SETTING_ALL=0xFF
+} ControllerSettings;
+
+typedef enum
+{
+        SETTING_DEFAULT,
+        SETTING_MIN,
+        SETTING_MAX,
+        SETTING_DEFAULTMINMAXCOUNT
+} SettingDefaultMinMax;
+
+// Bitmask that define which IMU features to enable.
+typedef enum
+{
+        SETTING_GYRO_MODE_OFF                           = 0x0000,
+        SETTING_GYRO_MODE_STEERING                      = 0x0001,
+        SETTING_GYRO_MODE_TILT                          = 0x0002,
+        SETTING_GYRO_MODE_SEND_ORIENTATION      = 0x0004,
+        SETTING_GYRO_MODE_SEND_RAW_ACCEL        = 0x0008,
+        SETTING_GYRO_MODE_SEND_RAW_GYRO         = 0x0010,
+} SettingGyroMode;
+
+// Bitmask for haptic pulse flags
+typedef enum
+{
+        HAPTIC_PULSE_NORMAL                                     = 0x0000,
+        HAPTIC_PULSE_HIGH_PRIORITY                      = 0x0001,
+        HAPTIC_PULSE_VERY_HIGH_PRIORITY         = 0x0002,
+        HAPTIC_PULSE_IGNORE_USER_PREFS          = 0x0003,
+} SettingHapticPulseFlags;
+
+typedef struct
+{
+        // default,min,max in this array in that order
+        short defaultminmax[SETTING_DEFAULTMINMAXCOUNT]; 
+} SettingValueRange_t;
+
+// below is from controller_constants.c which should be compiled into any code that uses this
+extern const SettingValueRange_t g_DefaultSettingValues[SETTING_COUNT];
+
+// Read-write settings for dongle (only add to this enum and never change the order)
+typedef enum 
+{
+        DONGLE_SETTING_MOUSE_KEYBOARD_ENABLED,
+        DONGLE_SETTING_COUNT,
+} DongleSettings;
+
+typedef enum
+{
+        AUDIO_STARTUP           = 0,
+        AUDIO_SHUTDOWN          = 1,
+        AUDIO_PAIR                      = 2,
+        AUDIO_PAIR_SUCCESS      = 3,
+        AUDIO_IDENTIFY          = 4,
+        AUDIO_LIZARDMODE        = 5,
+        AUDIO_NORMALMODE        = 6,
+
+        AUDIO_MAX_SLOT      = 15
+} ControllerAudio;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _CONTROLLER_CONSTANTS_H
diff --git a/contrib/SDL-3.2.8/src/joystick/hidapi/steam/controller_structs.h b/contrib/SDL-3.2.8/src/joystick/hidapi/steam/controller_structs.h
new file mode 100644
index 0000000..ea2a352
--- /dev/null
+++ b/contrib/SDL-3.2.8/src/joystick/hidapi/steam/controller_structs.h
@@ -0,0 +1,463 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 2020 Valve Corporation
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef _CONTROLLER_STRUCTS_
+#define _CONTROLLER_STRUCTS_
+
+#pragma pack(1)
+
+#define HID_FEATURE_REPORT_BYTES 64
+
+// Header for all host <==> target messages
+typedef struct
+{
+        unsigned char type;
+        unsigned char length;
+} FeatureReportHeader;
+
+// Generic controller settings structure
+typedef struct
+{
+        unsigned char settingNum;
+        unsigned short settingValue;
+} ControllerSetting;
+
+// Generic controller attribute structure
+typedef struct
+{
+        unsigned char attributeTag;
+        uint32_t attributeValue;
+} ControllerAttribute;
+
+// Generic controller settings structure
+typedef struct
+{
+        ControllerSetting settings[ ( HID_FEATURE_REPORT_BYTES - sizeof( FeatureReportHeader ) ) / sizeof( ControllerSetting ) ];
+} MsgSetSettingsValues, MsgGetSettingsValues, MsgGetSettingsDefaults, MsgGetSettingsMaxs;
+
+// Generic controller settings structure
+typedef struct
+{
+        ControllerAttribute attributes[ ( HID_FEATURE_REPORT_BYTES - sizeof( FeatureReportHeader ) ) / sizeof( ControllerAttribute ) ];
+} MsgGetAttributes;
+
+typedef struct
+{
+        unsigned char attributeTag;
+        char attributeValue[20];
+} MsgGetStringAttribute;
+
+typedef struct
+{
+        unsigned char mode;
+} MsgSetControllerMode;
+
+// Trigger a haptic pulse
+typedef struct {
+        unsigned char which_pad;
+        unsigned short pulse_duration;
+        unsigned short pulse_interval;
+        unsigned short pulse_count;
+        short dBgain;
+        unsigned char priority;
+} MsgFireHapticPulse;
+
+typedef struct {
+        uint8_t mode;
+} MsgHapticSetMode;
+
+typedef enum {
+        HAPTIC_TYPE_OFF,
+        HAPTIC_TYPE_TICK,
+        HAPTIC_TYPE_CLICK,
+        HAPTIC_TYPE_TONE,
+        HAPTIC_TYPE_RUMBLE,
+        HAPTIC_TYPE_NOISE,
+        HAPTIC_TYPE_SCRIPT,
+        HAPTIC_TYPE_LOG_SWEEP,
+} haptic_type_t;
+
+typedef enum {
+        HAPTIC_INTENSITY_SYSTEM,
+        HAPTIC_INTENSITY_SHORT,
+        HAPTIC_INTENSITY_MEDIUM,
+        HAPTIC_INTENSITY_LONG,
+        HAPTIC_INTENSITY_INSANE,
+} haptic_intensity_t;
+
+typedef struct {
+        uint8_t side;                           // 0x01 = L, 0x02 = R, 0x03 = Both
+        uint8_t cmd;                            // 0 = Off, 1 = tick, 2 = click, 3 = tone, 4 = rumble, 5 =
+                                                                // rumble_noise, 6 = script, 7 = sweep,
+        uint8_t ui_intensity;           // 0-4 (0 = default)
+        int8_t dBgain;                          // dB Can be positive (reasonable clipping / limiting will apply)
+        uint16_t freq;                          // Frequency of tone (if applicable)
+        int16_t dur_ms;                         // Duration of tone / rumble (if applicable) (neg = infinite)
+
+        uint16_t noise_intensity;
+        uint16_t lfo_freq;                      // Drives both tone and rumble geneators
+        uint8_t lfo_depth;                      // percentage, typically 100
+        uint8_t rand_tone_gain;         // Randomize each LFO cycle's gain
+        uint8_t script_id;                      // Used w/ dBgain for scripted haptics
+
+        uint16_t lss_start_freq;        // Used w/ Log Sine Sweep
+        uint16_t lss_end_freq;          // Ditto
+} MsgTriggerHaptic;
+
+typedef struct {
+        uint8_t unRumbleType;
+        uint16_t unIntensity;
+        uint16_t unLeftMotorSpeed;
+        uint16_t unRightMotorSpeed;
+        int8_t nLeftGain;
+        int8_t nRightGain;
+} MsgSimpleRumbleCmd;
+
+// This is the only message struct that application code should use to interact with feature request messages. Any new
+// messages should be added to the union. The structures defined here should correspond to the ones defined in
+// ValveDeviceCore.cpp.
+//
+typedef struct
+{
+        FeatureReportHeader header;
+        union
+        {
+                MsgSetSettingsValues setSettingsValues;
+                MsgGetSettingsValues getSettingsValues;
+                MsgGetSettingsMaxs getSettingsMaxs;
+                MsgGetSettingsDefaults getSettingsDefaults;
+                MsgGetAttributes getAttributes;
+                MsgSetControllerMode controllerMode;
+                MsgFireHapticPulse fireHapticPulse;
+                MsgGetStringAttribute getStringAttribute;
+                MsgHapticSetMode hapticMode;
+                MsgTriggerHaptic triggerHaptic;
+                MsgSimpleRumbleCmd simpleRumble;
+        } payload;
+
+} FeatureReportMsg;
+
+// Roll this version forward anytime that you are breaking compatibility of existing
+// message types within ValveInReport_t or the header itself.  Hopefully this should
+// be super rare and instead you should just add new message payloads to the union,
+// or just add fields to the end of existing payload structs which is expected to be 
+// safe in all code consuming these as they should just consume/copy up to the prior size 
+// they were aware of when processing.
+#define k_ValveInReportMsgVersion 0x01
+
+typedef enum
+{
+        ID_CONTROLLER_STATE = 1,
+        ID_CONTROLLER_DEBUG = 2,
+        ID_CONTROLLER_WIRELESS = 3,
+        ID_CONTROLLER_STATUS = 4,
+        ID_CONTROLLER_DEBUG2 = 5,
+        ID_CONTROLLER_SECONDARY_STATE = 6,
+        ID_CONTROLLER_BLE_STATE = 7,
+        ID_CONTROLLER_DECK_STATE = 9,
+        ID_CONTROLLER_MSG_COUNT
+} ValveInReportMessageIDs; 
+
+typedef struct 
+{
+        unsigned short unReportVersion;
+        
+        unsigned char ucType;
+        unsigned char ucLength;
+        
+} ValveInReportHeader_t;
+
+// State payload
+typedef struct 
+{
+        // If packet num matches that on your prior call, then the controller state hasn't been changed since 
+        // your last call and there is no need to process it
+        Uint32 unPacketNum;
+        
+        // Button bitmask and trigger data.
+        union
+        {
+                Uint64 ulButtons;
+                struct
+                {
+                        unsigned char _pad0[3];
+                        unsigned char nLeft;
+                        unsigned char nRight;
+                        unsigned char _pad1[3];
+                } Triggers;
+        } ButtonTriggerData;
+        
+        // Left pad coordinates
+        short sLeftPadX;
+        short sLeftPadY;
+        
+        // Right pad coordinates
+        short sRightPadX;
+        short sRightPadY;
+        
+        // This is redundant, packed above, but still sent over wired
+        unsigned short sTriggerL;
+        unsigned short sTriggerR;
+
+        // FIXME figure out a way to grab this stuff over wireless
+        short sAccelX;
+        short sAccelY;
+        short sAccelZ;
+        
+        short sGyroX;
+        short sGyroY;
+        short sGyroZ;
+        
+        short sGyroQuatW;
+        short sGyroQuatX;
+        short sGyroQuatY;
+        short sGyroQuatZ;
+
+} ValveControllerStatePacket_t;
+
+// BLE State payload this has to be re-formatted from the normal state because BLE controller shows up as 
+//a HID device and we don't want to send all the optional parts of the message. Keep in sync with struct above.
+typedef struct
+{
+        // If packet num matches that on your prior call, then the controller state hasn't been changed since 
+        // your last call and there is no need to process it
+        Uint32 unPacketNum;
+
+        // Button bitmask and trigger data.
+        union
+        {
+                Uint64 ulButtons;
+                struct
+                {
+                        unsigned char _pad0[3];
+                        unsigned char nLeft;
+                        unsigned char nRight;
+                        unsigned char _pad1[3];
+                } Triggers;
+        } ButtonTriggerData;
+
+        // Left pad coordinates
+        short sLeftPadX;
+        short sLeftPadY;
+
+        // Right pad coordinates
+        short sRightPadX;
+        short sRightPadY;
+
+        //This mimcs how the dongle reconstitutes HID packets, there will be 0-4 shorts depending on gyro mode
+        unsigned char ucGyroDataType; //TODO could maybe find some unused bits in the button field for this info (is only 2bits)
+        short sGyro[4];
+
+} ValveControllerBLEStatePacket_t;
+
+// Define a payload for reporting debug information
+typedef struct
+{
+        // Left pad coordinates
+        short sLeftPadX;
+        short sLeftPadY;
+
+        // Right pad coordinates
+        short sRightPadX;
+        short sRightPadY;
+
+        // Left mouse deltas
+        short sLeftPadMouseDX;
+        short sLeftPadMouseDY;
+
+        // Right mouse deltas
+        short sRightPadMouseDX;
+        short sRightPadMouseDY;
+        
+        // Left mouse filtered deltas
+        short sLeftPadMouseFilteredDX;
+        short sLeftPadMouseFilteredDY;
+
+        // Right mouse filtered deltas
+        short sRightPadMouseFilteredDX;
+        short sRightPadMouseFilteredDY;
+        
+        // Pad Z values
+        unsigned char ucLeftZ;
+        unsigned char ucRightZ;
+        
+        // FingerPresent
+        unsigned char ucLeftFingerPresent;
+        unsigned char ucRightFingerPresent;
+        
+        // Timestamps
+        unsigned char ucLeftTimestamp;
+        unsigned char ucRightTimestamp;
+        
+        // Double tap state
+        unsigned char ucLeftTapState;
+        unsigned char ucRightTapState;
+        
+        unsigned int unDigitalIOStates0;
+        unsigned int unDigitalIOStates1;
+        
+} ValveControllerDebugPacket_t;
+
+typedef struct
+{
+        unsigned char ucPadNum;
+        unsigned char ucPad[3]; // need Data to be word aligned
+        short Data[20];
+        unsigned short unNoise;
+} ValveControllerTrackpadImage_t;
+
+typedef struct
+{
+        unsigned char ucPadNum;
+        unsigned char ucOffset;
+        unsigned char ucPad[2]; // need Data to be word aligned
+        short rgData[28];
+} ValveControllerRawTrackpadImage_t;
+
+// Payload for wireless metadata
+typedef struct 
+{
+        unsigned char ucEventType;
+} SteamControllerWirelessEvent_t;
+
+typedef struct 
+{
+        // Current packet number.
+    unsigned int unPacketNum;
+        
+        // Event codes and state information.
+    unsigned short sEventCode;
+    unsigned short unStateFlags;
+
+    // Current battery voltage (mV).
+    unsigned short sBatteryVoltage;
+        
+        // Current battery level (0-100).
+        unsigned char ucBatteryLevel;
+} SteamControllerStatusEvent_t;
+
+// Deck State payload
+typedef struct
+{
+        // If packet num matches that on your prior call, then the controller
+        // state hasn't been changed since your last call and there is no need to
+        // process it
+        Uint32 unPacketNum;
+
+        // Button bitmask and trigger data.
+        union
+        {
+                Uint64 ulButtons;
+                struct
+                {
+                        Uint32 ulButtonsL;
+                        Uint32 ulButtonsH;
+                };
+        };
+
+        // Left pad coordinates
+        short sLeftPadX;
+        short sLeftPadY;
+
+        // Right pad coordinates
+        short sRightPadX;
+        short sRightPadY;
+
+        // Accelerometer values
+        short sAccelX;
+        short sAccelY;
+        short sAccelZ;
+
+        // Gyroscope values
+        short sGyroX;
+        short sGyroY;
+        short sGyroZ;
+
+        // Gyro quaternions
+        short sGyroQuatW;
+        short sGyroQuatX;
+        short sGyroQuatY;
+        short sGyroQuatZ;
+
+        // Uncalibrated trigger values
+        unsigned short sTriggerRawL;
+        unsigned short sTriggerRawR;
+
+        // Left stick values
+        short sLeftStickX;
+        short sLeftStickY;
+
+        // Right stick values
+        short sRightStickX;
+        short sRightStickY;
+
+        // Touchpad pressures
+        unsigned short sPressurePadLeft;
+        unsigned short sPressurePadRight;
+} SteamDeckStatePacket_t;
+
+typedef struct
+{
+        ValveInReportHeader_t header;
+        
+        union
+        {
+                ValveControllerStatePacket_t controllerState;
+                ValveControllerBLEStatePacket_t controllerBLEState;
+                ValveControllerDebugPacket_t debugState;
+                ValveControllerTrackpadImage_t padImage;
+                ValveControllerRawTrackpadImage_t rawPadImage;
+                SteamControllerWirelessEvent_t wirelessEvent;
+                SteamControllerStatusEvent_t statusEvent;
+                SteamDeckStatePacket_t deckState;
+        } payload;
+        
+} ValveInReport_t;
+
+
+// Enumeration for BLE packet protocol
+enum EBLEPacketReportNums
+{
+        // Skipping past 2-3 because they are escape characters in Uart protocol
+        k_EBLEReportState = 4,
+        k_EBLEReportStatus = 5,
+};
+
+
+// Enumeration of data chunks in BLE state packets
+enum EBLEOptionDataChunksBitmask
+{
+        // First byte upper nibble
+        k_EBLEButtonChunk1 = 0x10,
+        k_EBLEButtonChunk2 = 0x20,
+        k_EBLEButtonChunk3 = 0x40,
+        k_EBLELeftJoystickChunk = 0x80,
+
+        // Second full byte
+        k_EBLELeftTrackpadChunk = 0x100,
+        k_EBLERightTrackpadChunk = 0x200,
+        k_EBLEIMUAccelChunk = 0x400,
+        k_EBLEIMUGyroChunk = 0x800,
+        k_EBLEIMUQuatChunk = 0x1000,
+};
+
+#pragma pack()
+
+#endif // _CONTROLLER_STRUCTS