/* Simple DirectMedia Layer Copyright (C) 1997-2026 Sam Lantinga 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_report_descriptor.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 #if 0 #define DEBUG_XBOX_PROTOCOL #endif #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; bool has_separate_back_button; bool has_separate_guide_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; SDL_ReportDescriptor *descriptor; Uint32 last_buttons; 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) { // The PDP Rock Candy (PID 0x0246) and PowerA Fusion Pro 4 (PID 0x400b) // don't send the announce packet on Linux for some reason. // // Just to be safe and cover future products, we'll always send the startup // protocol sequence for PDP and PowerA controllers if (vendor_id == USB_VENDOR_PDP || vendor_id == USB_VENDOR_POWERA || vendor_id == USB_VENDOR_POWERA_ALT) { 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) { static const int LIBUSB_CLASS_VENDOR_SPEC = 0xFF; static const int XBONE_IFACE_SUBCLASS = 71; static const int XBONE_IFACE_PROTOCOL = 208; #if defined(SDL_PLATFORM_MACOS) && defined(SDL_JOYSTICK_MFI) if (SDL_GetHintBoolean(SDL_HINT_JOYSTICK_MFI, true) && !SDL_IsJoystickBluetoothXboxOne(vendor_id, product_id) && (device && SDL_strncmp(device->path, "DevSrvsID", 9) == 0)) { // 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, if available. return false; } #endif #ifdef SDL_PLATFORM_WIN32 if (device && SDL_strncmp(device->path, "\\\\?\\HID#", 8) == 0) { // Windows provides a fake HID endpoint for XGIP controllers, don't use this return false; } #endif if (interface_class && (interface_class != LIBUSB_CLASS_VENDOR_SPEC || interface_subclass != XBONE_IFACE_SUBCLASS || interface_protocol != XBONE_IFACE_PROTOCOL)) { // This isn't the Xbox gamepad interface return false; } 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; // The Xbox controller doesn't have real HID report descriptors, but Linux synthesizes them for us #ifdef SDL_PLATFORM_LINUX Uint8 descriptor[1024]; int descriptor_len = SDL_hid_get_report_descriptor(device->dev, descriptor, sizeof(descriptor)); if (descriptor_len > 0) { HIDAPI_DumpPacket("Xbox One report descriptor: size = %d", descriptor, descriptor_len); ctx->descriptor = SDL_ParseReportDescriptor(descriptor, descriptor_len); if (ctx->descriptor) { // Collapse the buttons into a single field read int field_count = ctx->descriptor->field_count; DescriptorInputField *fields = ctx->descriptor->fields; int button_count = 0; for (int i = 0; i < field_count; ++i) { DescriptorInputField *field = &fields[i]; if (field->usage == MAKE_USAGE(USB_USAGEPAGE_BUTTON, 1)) { Uint32 expected_usage = field->usage; int expected_offset = field->bit_offset; for (int j = i; j < field_count; ++j) { DescriptorInputField *other = &fields[j]; if (other->usage != expected_usage || other->bit_offset != expected_offset) { break; } ++button_count; ++expected_usage; ++expected_offset; } field->bit_size = button_count; int next_field = i + button_count; int fields_left = (field_count - next_field); SDL_memmove(&fields[i+1], &fields[next_field], (fields_left * sizeof(fields[0]))); ctx->descriptor->field_count -= (button_count - 1); break; } } if (!SDL_DescriptorHasUsage(ctx->descriptor, USB_USAGEPAGE_GENERIC_DESKTOP, USB_USAGE_GENERIC_X) || !SDL_DescriptorHasUsage(ctx->descriptor, USB_USAGEPAGE_GENERIC_DESKTOP, USB_USAGE_GENERIC_Y) || (button_count != 12 && button_count != 15)) { SDL_LogWarn(SDL_LOG_CATEGORY_INPUT, "Xbox report descriptor missing expected usages, ignoring"); SDL_DestroyDescriptor(ctx->descriptor); ctx->descriptor = NULL; } } else { SDL_LogWarn(SDL_LOG_CATEGORY_INPUT, "Couldn't parse Xbox report descriptor: %s", SDL_GetError()); } } else { SDL_LogDebug(SDL_LOG_CATEGORY_INPUT, "Xbox report descriptor not available"); } #endif // SDL_PLATFORM_LINUX 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(); } static void HIDAPI_DriverXboxOne_HandleBatteryState(SDL_Joystick *joystick, Uint32 flags) { 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 HandleDescriptorAxis(Uint64 timestamp, SDL_Joystick *joystick, SDL_GamepadAxis axis, Uint32 value) { Sint16 axis_value = (Sint16)((int)value - 0x8000); SDL_SendJoystickAxis(timestamp, joystick, axis, axis_value); } static void HandleDescriptorTrigger(Uint64 timestamp, SDL_Joystick *joystick, SDL_GamepadAxis axis, Uint32 value) { Sint16 axis_value = (Sint16)(((int)value * 64) - 32768); if (axis_value == 32704) { axis_value = 32767; } SDL_SendJoystickAxis(timestamp, joystick, axis, axis_value); } static bool HIDAPI_DriverXboxOne_HandleDescriptorReport(SDL_Joystick *joystick, SDL_DriverXboxOne_Context *ctx, Uint8 *data, int size) { const SDL_ReportDescriptor *descriptor = ctx->descriptor; Uint64 timestamp = SDL_GetTicksNS(); // Skip the report ID const Uint8 report_id = *data; ++data; --size; for (int i = 0; i < descriptor->field_count; ++i) { DescriptorInputField *field = &descriptor->fields[i]; if (field->report_id != report_id) { continue; } Uint32 value; if (!SDL_ReadReportData(data, size, field->bit_offset, field->bit_size, &value)) { continue; } switch (field->usage) { case MAKE_USAGE(USB_USAGEPAGE_GENERIC_DESKTOP, USB_USAGE_GENERIC_X): { HandleDescriptorAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, value); break; } case MAKE_USAGE(USB_USAGEPAGE_GENERIC_DESKTOP, USB_USAGE_GENERIC_Y): { HandleDescriptorAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, value); break; } // Some controllers use Z+RZ for the right thumbstick and BRAKE and ACCEL for the left and right triggers // and others use RX+RY for the right thumbstick and Z and RZ for the left and right triggers case MAKE_USAGE(USB_USAGEPAGE_GENERIC_DESKTOP, USB_USAGE_GENERIC_Z): { if (field->bit_size == 16) { HandleDescriptorAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, value); } else if (field->bit_size == 10) { HandleDescriptorTrigger(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, value); } break; } case MAKE_USAGE(USB_USAGEPAGE_GENERIC_DESKTOP, USB_USAGE_GENERIC_RX): { HandleDescriptorAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, value); break; } case MAKE_USAGE(USB_USAGEPAGE_GENERIC_DESKTOP, USB_USAGE_GENERIC_RY): { HandleDescriptorAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, value); break; } case MAKE_USAGE(USB_USAGEPAGE_GENERIC_DESKTOP, USB_USAGE_GENERIC_RZ): { if (field->bit_size == 16) { HandleDescriptorAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTY, value); } else if (field->bit_size == 10) { HandleDescriptorTrigger(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, value); } break; } case MAKE_USAGE(USB_USAGEPAGE_SIMULATION, USB_USAGE_SIMULATION_BRAKE): { HandleDescriptorTrigger(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, value); break; } case MAKE_USAGE(USB_USAGEPAGE_SIMULATION, USB_USAGE_SIMULATION_ACCELERATOR): { HandleDescriptorTrigger(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, value); break; } case MAKE_USAGE(USB_USAGEPAGE_GENERIC_DESKTOP, USB_USAGE_GENERIC_HAT): { Uint8 hat; switch (value) { 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); break; } case MAKE_USAGE(USB_USAGEPAGE_BUTTON, 1): { static const SDL_GamepadButton button_map_12[] = { // 0x0001 SDL_GAMEPAD_BUTTON_SOUTH, // 0x0002 SDL_GAMEPAD_BUTTON_EAST, // 0x0004 SDL_GAMEPAD_BUTTON_WEST, // 0x0008 SDL_GAMEPAD_BUTTON_NORTH, // 0x0010 SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, // 0x0020 SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, // 0x0040 SDL_GAMEPAD_BUTTON_BACK, // 0x0080 SDL_GAMEPAD_BUTTON_START, // 0x0100 SDL_GAMEPAD_BUTTON_LEFT_STICK, // 0x0200 SDL_GAMEPAD_BUTTON_RIGHT_STICK, // 0x0400 SDL_GAMEPAD_BUTTON_GUIDE, // 0x0800 SDL_GAMEPAD_BUTTON_INVALID, }; static const SDL_GamepadButton button_map_15[] = { // 0x0001 SDL_GAMEPAD_BUTTON_SOUTH, // 0x0002 SDL_GAMEPAD_BUTTON_EAST, // 0x0004 SDL_GAMEPAD_BUTTON_INVALID, // 0x0008 SDL_GAMEPAD_BUTTON_WEST, // 0x0010 SDL_GAMEPAD_BUTTON_NORTH, // 0x0020 SDL_GAMEPAD_BUTTON_INVALID, // 0x0040 SDL_GAMEPAD_BUTTON_LEFT_SHOULDER, // 0x0080 SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER, // 0x0100 SDL_GAMEPAD_BUTTON_INVALID, // 0x0200 SDL_GAMEPAD_BUTTON_INVALID, // 0x0400 SDL_GAMEPAD_BUTTON_BACK, // 0x0800 SDL_GAMEPAD_BUTTON_START, // 0x1000 SDL_GAMEPAD_BUTTON_GUIDE, // 0x2000 SDL_GAMEPAD_BUTTON_LEFT_STICK, // 0x4000 SDL_GAMEPAD_BUTTON_RIGHT_STICK, }; if (value == ctx->last_buttons) { break; } ctx->last_buttons = value; const SDL_GamepadButton *button_map; if (field->bit_size == 12) { button_map = button_map_12; } else if (field->bit_size == 15) { button_map = button_map_15; } else { // Should never happen break; } for (int button_index = 0; button_index < field->bit_size; ++button_index, value >>= 1) { SDL_GamepadButton button = button_map[button_index]; if (button == SDL_GAMEPAD_BUTTON_INVALID) { continue; } if (button == SDL_GAMEPAD_BUTTON_BACK && ctx->has_separate_back_button) { continue; } if (button == SDL_GAMEPAD_BUTTON_GUIDE && ctx->has_separate_guide_button) { continue; } bool pressed = ((value & 1) != 0); SDL_SendJoystickButton(timestamp, joystick, button, pressed); } break; } case MAKE_USAGE(USB_USAGEPAGE_CONSUMER, USB_USAGE_CONSUMER_AC_BACK): { bool pressed = (value != 0); if (pressed) { ctx->has_separate_back_button = true; } SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_BACK, pressed); break; } case MAKE_USAGE(USB_USAGEPAGE_CONSUMER, USB_USAGE_CONSUMER_AC_HOME): { bool pressed = (value != 0); if (pressed) { ctx->has_separate_guide_button = true; } SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_GUIDE, pressed); break; } case MAKE_USAGE(USB_USAGEPAGE_CONSUMER, USB_USAGE_CONSUMER_RECORD): { if (ctx->has_share_button) { bool pressed = (value != 0); SDL_SendJoystickButton(timestamp, joystick, SDL_GAMEPAD_BUTTON_XBOX_SHARE_BUTTON, pressed); } break; } case MAKE_USAGE(USB_USAGEPAGE_CONSUMER, USB_USAGE_CONSUMER_ORDER_MOVIE): { // This value is the currently selected profile ctx->has_unmapped_state = (value == 0); break; } case MAKE_USAGE(USB_USAGEPAGE_CONSUMER, USB_USAGE_CONSUMER_ASSIGN_SELECTION): { if (ctx->has_paddles) { if (!ctx->has_unmapped_state) { value = 0; } Uint8 button = (Uint8)(SDL_GAMEPAD_BUTTON_XBOX_SHARE_BUTTON + ctx->has_share_button); // Next available button SDL_SendJoystickButton(timestamp, joystick, button++, ((value & 0x1) != 0)); SDL_SendJoystickButton(timestamp, joystick, button++, ((value & 0x2) != 0)); SDL_SendJoystickButton(timestamp, joystick, button++, ((value & 0x4) != 0)); SDL_SendJoystickButton(timestamp, joystick, button++, ((value & 0x8) != 0)); } break; } case MAKE_USAGE(USB_USAGEPAGE_DEVICE_CONTROLS, USB_USAGE_DEVICE_CONTROLS_BATTERY_STRENGTH): { HIDAPI_DriverXboxOne_HandleBatteryState(joystick, value); break; } default: break; } } return true; } /* * 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)LOAD16(data[2], data[3]) * 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)LOAD16(data[4], data[5]) * 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 = LOAD16(data[6], data[7]); SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, axis); axis = LOAD16(data[8], data[9]); SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, ~axis); axis = LOAD16(data[10], data[11]); SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, axis); axis = LOAD16(data[12], data[13]); 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)LOAD16(data[9], data[10]) * 64) - 32768; if (axis == 32704) { axis = 32767; } SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, axis); axis = ((int)LOAD16(data[11], data[12]) * 64) - 32768; if (axis == 32704) { axis = 32767; } SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, axis); axis = (int)(Uint16)LOAD16(data[1], data[2]) - 0x8000; SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTX, axis); axis = (int)(Uint16)LOAD16(data[3], data[4]) - 0x8000; SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_LEFTY, axis); axis = (int)(Uint16)LOAD16(data[5], data[6]) - 0x8000; SDL_SendJoystickAxis(timestamp, joystick, SDL_GAMEPAD_AXIS_RIGHTX, axis); axis = (int)(Uint16)LOAD16(data[7], data[8]) - 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) { HIDAPI_DriverXboxOne_HandleBatteryState(joystick, data[1]); } 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 (ctx->descriptor) { if (!joystick) { break; } HIDAPI_DriverXboxOne_HandleDescriptorReport(joystick, ctx, data, size); } else 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; SDL_DestroyDescriptor(ctx->descriptor); 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