| /* |
| Simple DirectMedia Layer |
| Copyright (C) 1997-2026 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_STEAMDECK |
| &SDL_HIDAPI_DriverSteamTriton, |
| #endif |
| #ifdef SDL_JOYSTICK_HIDAPI_SWITCH |
| &SDL_HIDAPI_DriverNintendoClassic, |
| &SDL_HIDAPI_DriverJoyCons, |
| &SDL_HIDAPI_DriverSwitch, |
| #endif |
| #ifdef SDL_JOYSTICK_HIDAPI_SWITCH2 |
| &SDL_HIDAPI_DriverSwitch2, |
| #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_GIP |
| &SDL_HIDAPI_DriverGIP, |
| #endif |
| #ifdef SDL_JOYSTICK_HIDAPI_XBOXONE |
| &SDL_HIDAPI_DriverXboxOne, |
| #endif |
| #ifdef SDL_JOYSTICK_HIDAPI_LG4FF |
| &SDL_HIDAPI_DriverLg4ff, |
| #endif |
| #ifdef SDL_JOYSTICK_HIDAPI_8BITDO |
| &SDL_HIDAPI_Driver8BitDo, |
| #endif |
| #ifdef SDL_JOYSTICK_HIDAPI_FLYDIGI |
| &SDL_HIDAPI_DriverFlydigi, |
| #endif |
| #ifdef SDL_JOYSTICK_HIDAPI_SINPUT |
| &SDL_HIDAPI_DriverSInput, |
| #endif |
| #ifdef SDL_JOYSTICK_HIDAPI_ZUIKI |
| &SDL_HIDAPI_DriverZUIKI, |
| #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_LogDebug(SDL_LOG_CATEGORY_INPUT, "%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 |
| 0x294b, // Snakebyte |
| 0x2dc8, // 8BitDo |
| 0x2e24, // Hyperkin |
| 0x2e95, // SCUF |
| 0x3285, // Nacon |
| 0x3537, // GameSir |
| 0x366c, // ByoWave |
| }; |
| |
| 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 && device->vendor_id != USB_VENDOR_FLYDIGI_V1 && device->vendor_id != USB_VENDOR_FLYDIGI_V2) { |
| 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 || |
| device->product_id == USB_PRODUCT_NINTENDO_SWITCH2_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; |
| |
| if (pJoystickID) { |
| *pJoystickID = joystickID; |
| } |
| |
| SDL_PrivateJoystickAdded(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); |
| if (info->path) { |
| device->path = SDL_strdup(info->path); |
| } |
| 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; |
| if (joycons[0]->product_id == USB_PRODUCT_NINTENDO_SWITCH_JOYCON_LEFT) { |
| info.product_id = USB_PRODUCT_NINTENDO_SWITCH_JOYCON_PAIR; |
| } else { |
| info.product_id = USB_PRODUCT_NINTENDO_SWITCH2_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)"; |
| if (children[0]->is_bluetooth || children[1]->is_bluetooth) { |
| info.bus_type = SDL_HID_API_BUS_BLUETOOTH; |
| } else { |
| info.bus_type = SDL_HID_API_BUS_USB; |
| } |
| |
| 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) { |
| // The HIDAPI functionality will be available when the FlyDigi Space Station app has |
| // enabled third party controller mapping, so the driver needs to be active to watch |
| // for that change. Since this is dynamic and we don't have a way to re-trigger device |
| // changes when that happens, we'll pretend the driver isn't available so the XInput |
| // interface will always show up (but won't have any input when the controller is in |
| // enhanced mode) |
| if (device->vendor_id == USB_VENDOR_FLYDIGI_V2) { |
| continue; |
| } |
| |
| 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 |
