kc3-lang/SDL/src/hidapi/SDL_hidapi.c

• Show log

  Commit

• Hash : b8327a4a
  Author :
  Date : 2021-11-08T07:19:45
  

  Added SDL_HIDAPI_DISABLED so it can be disabled like other SDL subsystems

Download

• src/hidapi/SDL_hidapi.c

• /*
    Simple DirectMedia Layer
    Copyright (C) 1997-2021 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.
  */
  
  /* Original hybrid wrapper for Linux by Valve Software. Their original notes:
   *
   * The libusb version doesn't support Bluetooth, but not all Linux
   * distributions allow access to /dev/hidraw*
   *
   * This merges the two, at a small performance cost, until distributions
   * have granted access to /dev/hidraw*
   */
  #include "../SDL_internal.h"
  
  #include "SDL_loadso.h"
  #include "SDL_hidapi.h"
  #include "SDL_hidapi_c.h"
  
  #if !SDL_HIDAPI_DISABLED
  
  /* Platform HIDAPI Implementation */
  
  #define hid_init                        PLATFORM_hid_init
  #define hid_exit                        PLATFORM_hid_exit
  #define hid_enumerate                   PLATFORM_hid_enumerate
  #define hid_free_enumeration            PLATFORM_hid_free_enumeration
  #define hid_open                        PLATFORM_hid_open
  #define hid_open_path                   PLATFORM_hid_open_path
  #define hid_write                       PLATFORM_hid_write
  #define hid_read_timeout                PLATFORM_hid_read_timeout
  #define hid_read                        PLATFORM_hid_read
  #define hid_set_nonblocking             PLATFORM_hid_set_nonblocking
  #define hid_send_feature_report         PLATFORM_hid_send_feature_report
  #define hid_get_feature_report          PLATFORM_hid_get_feature_report
  #define hid_close                       PLATFORM_hid_close
  #define hid_get_manufacturer_string     PLATFORM_hid_get_manufacturer_string
  #define hid_get_product_string          PLATFORM_hid_get_product_string
  #define hid_get_serial_number_string    PLATFORM_hid_get_serial_number_string
  #define hid_get_indexed_string          PLATFORM_hid_get_indexed_string
  #define hid_error                       PLATFORM_hid_error
  #define new_hid_device                  PLATFORM_new_hid_device
  #define free_hid_device                 PLATFORM_free_hid_device
  #define input_report                    PLATFORM_input_report
  #define return_data                     PLATFORM_return_data
  #define make_path                       PLATFORM_make_path
  #define read_thread                     PLATFORM_read_thread
  
  #undef HIDAPI_H__
  #if __LINUX__
  
  #include "../../core/linux/SDL_udev.h"
  #if SDL_USE_LIBUDEV
  static const SDL_UDEV_Symbols *udev_ctx = NULL;
  
  #define udev_device_get_sysattr_value                    udev_ctx->udev_device_get_sysattr_value
  #define udev_new                                         udev_ctx->udev_new
  #define udev_unref                                       udev_ctx->udev_unref
  #define udev_device_new_from_devnum                      udev_ctx->udev_device_new_from_devnum
  #define udev_device_get_parent_with_subsystem_devtype    udev_ctx->udev_device_get_parent_with_subsystem_devtype
  #define udev_device_unref                                udev_ctx->udev_device_unref
  #define udev_enumerate_new                               udev_ctx->udev_enumerate_new
  #define udev_enumerate_add_match_subsystem               udev_ctx->udev_enumerate_add_match_subsystem
  #define udev_enumerate_scan_devices                      udev_ctx->udev_enumerate_scan_devices
  #define udev_enumerate_get_list_entry                    udev_ctx->udev_enumerate_get_list_entry
  #define udev_list_entry_get_name                         udev_ctx->udev_list_entry_get_name
  #define udev_device_new_from_syspath                     udev_ctx->udev_device_new_from_syspath
  #define udev_device_get_devnode                          udev_ctx->udev_device_get_devnode
  #define udev_list_entry_get_next                         udev_ctx->udev_list_entry_get_next
  #define udev_enumerate_unref                             udev_ctx->udev_enumerate_unref
  
  #include "linux/hid.c"
  #define HAVE_PLATFORM_BACKEND 1
  #endif /* SDL_USE_LIBUDEV */
  
  #elif __MACOSX__
  #include "mac/hid.c"
  #define HAVE_PLATFORM_BACKEND 1
  #define udev_ctx 1
  #elif __WINDOWS__
  #include "windows/hid.c"
  #define HAVE_PLATFORM_BACKEND 1
  #define udev_ctx 1
  #elif __ANDROID__
  /* The implementation for Android is in a separate .cpp file */
  #include "hidapi/hidapi.h"
  #define HAVE_PLATFORM_BACKEND 1
  #define udev_ctx 1
  #elif __IPHONEOS__ || __TVOS__
  /* The implementation for iOS and tvOS is in a separate .m file */
  #include "hidapi/hidapi.h"
  #define HAVE_PLATFORM_BACKEND 1
  #define udev_ctx 1
  #endif
  
  #undef hid_init
  #undef hid_exit
  #undef hid_enumerate
  #undef hid_free_enumeration
  #undef hid_open
  #undef hid_open_path
  #undef hid_write
  #undef hid_read_timeout
  #undef hid_read
  #undef hid_set_nonblocking
  #undef hid_send_feature_report
  #undef hid_get_feature_report
  #undef hid_close
  #undef hid_get_manufacturer_string
  #undef hid_get_product_string
  #undef hid_get_serial_number_string
  #undef hid_get_indexed_string
  #undef hid_error
  #undef new_hid_device
  #undef free_hid_device
  #undef input_report
  #undef return_data
  #undef make_path
  #undef read_thread
  
  #ifdef SDL_JOYSTICK_HIDAPI_STEAMXBOX
  #define HAVE_DRIVER_BACKEND 1
  #endif
  
  #ifdef HAVE_DRIVER_BACKEND
  
  /* DRIVER HIDAPI Implementation */
  
  #define hid_init                        DRIVER_hid_init
  #define hid_exit                        DRIVER_hid_exit
  #define hid_enumerate                   DRIVER_hid_enumerate
  #define hid_free_enumeration            DRIVER_hid_free_enumeration
  #define hid_open                        DRIVER_hid_open
  #define hid_open_path                   DRIVER_hid_open_path
  #define hid_write                       DRIVER_hid_write
  #define hid_read_timeout                DRIVER_hid_read_timeout
  #define hid_read                        DRIVER_hid_read
  #define hid_set_nonblocking             DRIVER_hid_set_nonblocking
  #define hid_send_feature_report         DRIVER_hid_send_feature_report
  #define hid_get_feature_report          DRIVER_hid_get_feature_report
  #define hid_close                       DRIVER_hid_close
  #define hid_get_manufacturer_string     DRIVER_hid_get_manufacturer_string
  #define hid_get_product_string          DRIVER_hid_get_product_string
  #define hid_get_serial_number_string    DRIVER_hid_get_serial_number_string
  #define hid_get_indexed_string          DRIVER_hid_get_indexed_string
  #define hid_error                       DRIVER_hid_error
  
  #ifdef SDL_JOYSTICK_HIDAPI_STEAMXBOX
  #undef HIDAPI_H__
  #include "steamxbox/hid.c"
  #else
  #error Need a driver hid.c for this platform!
  #endif
  
  #undef hid_init
  #undef hid_exit
  #undef hid_enumerate
  #undef hid_free_enumeration
  #undef hid_open
  #undef hid_open_path
  #undef hid_write
  #undef hid_read_timeout
  #undef hid_read
  #undef hid_set_nonblocking
  #undef hid_send_feature_report
  #undef hid_get_feature_report
  #undef hid_close
  #undef hid_get_manufacturer_string
  #undef hid_get_product_string
  #undef hid_get_serial_number_string
  #undef hid_get_indexed_string
  #undef hid_error
  
  #endif /* HAVE_DRIVER_BACKEND */
  
  
  #ifdef SDL_LIBUSB_DYNAMIC
  /* libusb HIDAPI Implementation */
  
  /* Include this now, for our dynamically-loaded libusb context */
  #include <libusb.h>
  
  static struct
  {
      void* libhandle;
  
      int (*init)(libusb_context **ctx);
      void (*exit)(libusb_context *ctx);
      ssize_t (*get_device_list)(libusb_context *ctx, libusb_device ***list);
      void (*free_device_list)(libusb_device **list, int unref_devices);
      int (*get_device_descriptor)(libusb_device *dev, struct libusb_device_descriptor *desc);
      int (*get_active_config_descriptor)(libusb_device *dev,    struct libusb_config_descriptor **config);
      int (*get_config_descriptor)(
          libusb_device *dev,
          uint8_t config_index,
          struct libusb_config_descriptor **config
      );
      void (*free_config_descriptor)(struct libusb_config_descriptor *config);
      uint8_t (*get_bus_number)(libusb_device *dev);
      uint8_t (*get_device_address)(libusb_device *dev);
      int (*open)(libusb_device *dev, libusb_device_handle **dev_handle);
      void (*close)(libusb_device_handle *dev_handle);
      int (*claim_interface)(libusb_device_handle *dev_handle, int interface_number);
      int (*release_interface)(libusb_device_handle *dev_handle, int interface_number);
      int (*kernel_driver_active)(libusb_device_handle *dev_handle, int interface_number);
      int (*detach_kernel_driver)(libusb_device_handle *dev_handle, int interface_number);
      int (*attach_kernel_driver)(libusb_device_handle *dev_handle, int interface_number);
      int (*set_interface_alt_setting)(libusb_device_handle *dev, int interface_number, int alternate_setting);
      struct libusb_transfer * (*alloc_transfer)(int iso_packets);
      int (*submit_transfer)(struct libusb_transfer *transfer);
      int (*cancel_transfer)(struct libusb_transfer *transfer);
      void (*free_transfer)(struct libusb_transfer *transfer);
      int (*control_transfer)(
          libusb_device_handle *dev_handle,
          uint8_t request_type,
          uint8_t bRequest,
          uint16_t wValue,
          uint16_t wIndex,
          unsigned char *data,
          uint16_t wLength,
          unsigned int timeout
      );
      int (*interrupt_transfer)(
          libusb_device_handle *dev_handle,
          unsigned char endpoint,
          unsigned char *data,
          int length,
          int *actual_length,
          unsigned int timeout
      );
      int (*handle_events)(libusb_context *ctx);
      int (*handle_events_completed)(libusb_context *ctx, int *completed);
  } libusb_ctx;
  
  #define libusb_init                            libusb_ctx.init
  #define libusb_exit                            libusb_ctx.exit
  #define libusb_get_device_list                 libusb_ctx.get_device_list
  #define libusb_free_device_list                libusb_ctx.free_device_list
  #define libusb_get_device_descriptor           libusb_ctx.get_device_descriptor
  #define libusb_get_active_config_descriptor    libusb_ctx.get_active_config_descriptor
  #define libusb_get_config_descriptor           libusb_ctx.get_config_descriptor
  #define libusb_free_config_descriptor          libusb_ctx.free_config_descriptor
  #define libusb_get_bus_number                  libusb_ctx.get_bus_number
  #define libusb_get_device_address              libusb_ctx.get_device_address
  #define libusb_open                            libusb_ctx.open
  #define libusb_close                           libusb_ctx.close
  #define libusb_claim_interface                 libusb_ctx.claim_interface
  #define libusb_release_interface               libusb_ctx.release_interface
  #define libusb_kernel_driver_active            libusb_ctx.kernel_driver_active
  #define libusb_detach_kernel_driver            libusb_ctx.detach_kernel_driver
  #define libusb_attach_kernel_driver            libusb_ctx.attach_kernel_driver
  #define libusb_set_interface_alt_setting       libusb_ctx.set_interface_alt_setting
  #define libusb_alloc_transfer                  libusb_ctx.alloc_transfer
  #define libusb_submit_transfer                 libusb_ctx.submit_transfer
  #define libusb_cancel_transfer                 libusb_ctx.cancel_transfer
  #define libusb_free_transfer                   libusb_ctx.free_transfer
  #define libusb_control_transfer                libusb_ctx.control_transfer
  #define libusb_interrupt_transfer              libusb_ctx.interrupt_transfer
  #define libusb_handle_events                   libusb_ctx.handle_events
  #define libusb_handle_events_completed         libusb_ctx.handle_events_completed
  
  #define hid_init                        LIBUSB_hid_init
  #define hid_exit                        LIBUSB_hid_exit
  #define hid_enumerate                   LIBUSB_hid_enumerate
  #define hid_free_enumeration            LIBUSB_hid_free_enumeration
  #define hid_open                        LIBUSB_hid_open
  #define hid_open_path                   LIBUSB_hid_open_path
  #define hid_write                       LIBUSB_hid_write
  #define hid_read_timeout                LIBUSB_hid_read_timeout
  #define hid_read                        LIBUSB_hid_read
  #define hid_set_nonblocking             LIBUSB_hid_set_nonblocking
  #define hid_send_feature_report         LIBUSB_hid_send_feature_report
  #define hid_get_feature_report          LIBUSB_hid_get_feature_report
  #define hid_close                       LIBUSB_hid_close
  #define hid_get_manufacturer_string     LIBUSB_hid_get_manufacturer_string
  #define hid_get_product_string          LIBUSB_hid_get_product_string
  #define hid_get_serial_number_string    LIBUSB_hid_get_serial_number_string
  #define hid_get_indexed_string          LIBUSB_hid_get_indexed_string
  #define hid_error                       LIBUSB_hid_error
  #define new_hid_device                  LIBUSB_new_hid_device
  #define free_hid_device                 LIBUSB_free_hid_device
  #define input_report                    LIBUSB_input_report
  #define return_data                     LIBUSB_return_data
  #define make_path                       LIBUSB_make_path
  #define read_thread                     LIBUSB_read_thread
  
  #ifndef __FreeBSD__
  /* this is awkwardly inlined, so we need to re-implement it here
   * so we can override the libusb_control_transfer call */
  static int
  SDL_libusb_get_string_descriptor(libusb_device_handle *dev,
                                   uint8_t descriptor_index, uint16_t lang_id,
                                   unsigned char *data, int length)
  {
      return libusb_control_transfer(dev,
                                     LIBUSB_ENDPOINT_IN | 0x0, /* Endpoint 0 IN */
                                     LIBUSB_REQUEST_GET_DESCRIPTOR,
                                     (LIBUSB_DT_STRING << 8) | descriptor_index,
                                     lang_id,
                                     data,
                                     (uint16_t) length,
                                     1000);
  }
  #define libusb_get_string_descriptor SDL_libusb_get_string_descriptor
  #endif /* __FreeBSD__ */
  
  #undef HIDAPI_H__
  #include "libusb/hid.c"
  
  #undef hid_init
  #undef hid_exit
  #undef hid_enumerate
  #undef hid_free_enumeration
  #undef hid_open
  #undef hid_open_path
  #undef hid_write
  #undef hid_read_timeout
  #undef hid_read
  #undef hid_set_nonblocking
  #undef hid_send_feature_report
  #undef hid_get_feature_report
  #undef hid_close
  #undef hid_get_manufacturer_string
  #undef hid_get_product_string
  #undef hid_get_serial_number_string
  #undef hid_get_indexed_string
  #undef hid_error
  #undef new_hid_device
  #undef free_hid_device
  #undef input_report
  #undef return_data
  #undef make_path
  #undef read_thread
  
  #endif /* SDL_LIBUSB_DYNAMIC */
  
  #endif /* !SDL_HIDAPI_DISABLED */
  
  /* Shared HIDAPI Implementation */
  
  struct hidapi_backend {
      int  (*hid_write)(SDL_hid_device* device, const unsigned char* data, size_t length);
      int  (*hid_read_timeout)(SDL_hid_device* device, unsigned char* data, size_t length, int milliseconds);
      int  (*hid_read)(SDL_hid_device* device, unsigned char* data, size_t length);
      int  (*hid_set_nonblocking)(SDL_hid_device* device, int nonblock);
      int  (*hid_send_feature_report)(SDL_hid_device* device, const unsigned char* data, size_t length);
      int  (*hid_get_feature_report)(SDL_hid_device* device, unsigned char* data, size_t length);
      void (*hid_close)(SDL_hid_device* device);
      int  (*hid_get_manufacturer_string)(SDL_hid_device* device, wchar_t* string, size_t maxlen);
      int  (*hid_get_product_string)(SDL_hid_device* device, wchar_t* string, size_t maxlen);
      int  (*hid_get_serial_number_string)(SDL_hid_device* device, wchar_t* string, size_t maxlen);
      int  (*hid_get_indexed_string)(SDL_hid_device* device, int string_index, wchar_t* string, size_t maxlen);
      const wchar_t* (*hid_error)(SDL_hid_device* device);
  };
  
  #if HAVE_PLATFORM_BACKEND
  static const struct hidapi_backend PLATFORM_Backend = {
      (void*)PLATFORM_hid_write,
      (void*)PLATFORM_hid_read_timeout,
      (void*)PLATFORM_hid_read,
      (void*)PLATFORM_hid_set_nonblocking,
      (void*)PLATFORM_hid_send_feature_report,
      (void*)PLATFORM_hid_get_feature_report,
      (void*)PLATFORM_hid_close,
      (void*)PLATFORM_hid_get_manufacturer_string,
      (void*)PLATFORM_hid_get_product_string,
      (void*)PLATFORM_hid_get_serial_number_string,
      (void*)PLATFORM_hid_get_indexed_string,
      (void*)PLATFORM_hid_error
  };
  #endif /* HAVE_PLATFORM_BACKEND */
  
  #if HAVE_DRIVER_BACKEND
  static const struct hidapi_backend DRIVER_Backend = {
      (void*)DRIVER_hid_write,
      (void*)DRIVER_hid_read_timeout,
      (void*)DRIVER_hid_read,
      (void*)DRIVER_hid_set_nonblocking,
      (void*)DRIVER_hid_send_feature_report,
      (void*)DRIVER_hid_get_feature_report,
      (void*)DRIVER_hid_close,
      (void*)DRIVER_hid_get_manufacturer_string,
      (void*)DRIVER_hid_get_product_string,
      (void*)DRIVER_hid_get_serial_number_string,
      (void*)DRIVER_hid_get_indexed_string,
      (void*)DRIVER_hid_error
  };
  #endif /* HAVE_DRIVER_BACKEND */
  
  #ifdef SDL_LIBUSB_DYNAMIC
  static const struct hidapi_backend LIBUSB_Backend = {
      (void*)LIBUSB_hid_write,
      (void*)LIBUSB_hid_read_timeout,
      (void*)LIBUSB_hid_read,
      (void*)LIBUSB_hid_set_nonblocking,
      (void*)LIBUSB_hid_send_feature_report,
      (void*)LIBUSB_hid_get_feature_report,
      (void*)LIBUSB_hid_close,
      (void*)LIBUSB_hid_get_manufacturer_string,
      (void*)LIBUSB_hid_get_product_string,
      (void*)LIBUSB_hid_get_serial_number_string,
      (void*)LIBUSB_hid_get_indexed_string,
      (void*)LIBUSB_hid_error
  };
  #endif /* SDL_LIBUSB_DYNAMIC */
  
  typedef struct _HIDDeviceWrapper HIDDeviceWrapper;
  struct _HIDDeviceWrapper
  {
      const void *magic;
      SDL_hid_device *device;
      const struct hidapi_backend *backend;
  };
  static char device_magic;
  
  #if HAVE_PLATFORM_BACKEND || HAVE_DRIVER_BACKEND || defined(SDL_LIBUSB_DYNAMIC)
  
  static HIDDeviceWrapper *
  CreateHIDDeviceWrapper(SDL_hid_device *device, const struct hidapi_backend *backend)
  {
      HIDDeviceWrapper *wrapper = (HIDDeviceWrapper *)SDL_malloc(sizeof(*wrapper));
      wrapper->magic = &device_magic;
      wrapper->device = device;
      wrapper->backend = backend;
      return wrapper;
  }
  
  static SDL_hid_device *
  WrapHIDDevice(HIDDeviceWrapper *wrapper)
  {
      return (SDL_hid_device *)wrapper;
  }
  
  #endif /* HAVE_PLATFORM_BACKEND || HAVE_DRIVER_BACKEND || SDL_LIBUSB_DYNAMIC */
  
  static HIDDeviceWrapper *
  UnwrapHIDDevice(SDL_hid_device *device)
  {
      return (HIDDeviceWrapper *)device;
  }
  
  static void
  DeleteHIDDeviceWrapper(HIDDeviceWrapper *device)
  {
      device->magic = NULL;
      SDL_free(device);
  }
  
  #define CHECK_DEVICE_MAGIC(device, retval) \
      SDL_assert(device && device->magic == &device_magic); \
      if (!device || device->magic != &device_magic) { \
          SDL_SetError("Invalid device"); \
          return retval; \
      }
  
  #if !SDL_HIDAPI_DISABLED
  
  #define COPY_IF_EXISTS(var) \
      if (pSrc->var != NULL) { \
          pDst->var = SDL_strdup(pSrc->var); \
      } else { \
          pDst->var = NULL; \
      }
  #define WCOPY_IF_EXISTS(var) \
      if (pSrc->var != NULL) { \
          pDst->var = SDL_wcsdup(pSrc->var); \
      } else { \
          pDst->var = NULL; \
      }
  
  static void
  CopyHIDDeviceInfo(struct SDL_hid_device_info *pSrc, struct SDL_hid_device_info *pDst)
  {
      COPY_IF_EXISTS(path)
      pDst->vendor_id = pSrc->vendor_id;
      pDst->product_id = pSrc->product_id;
      WCOPY_IF_EXISTS(serial_number)
      pDst->release_number = pSrc->release_number;
      WCOPY_IF_EXISTS(manufacturer_string)
      WCOPY_IF_EXISTS(product_string)
      pDst->usage_page = pSrc->usage_page;
      pDst->usage = pSrc->usage;
      pDst->interface_number = pSrc->interface_number;
      pDst->interface_class = pSrc->interface_class;
      pDst->interface_subclass = pSrc->interface_subclass;
      pDst->interface_protocol = pSrc->interface_protocol;
      pDst->next = NULL;
  }
  
  #undef COPY_IF_EXISTS
  #undef WCOPY_IF_EXISTS
  
  #endif /* !SDL_HIDAPI_DISABLED */
  
  static SDL_bool SDL_hidapi_wasinit = SDL_FALSE;
  
  static void SDL_SetHIDAPIError( const wchar_t *error )
  {
      if (error) {
          char *error_utf8 = SDL_iconv_wchar_utf8(error);
          if (error_utf8) {
              SDL_SetError("%s", error_utf8);
              SDL_free(error_utf8);
          }
      }
  }
  
  int SDL_hid_init(void)
  {
      int attempts = 0, success = 0;
  
      if (SDL_hidapi_wasinit == SDL_TRUE) {
          return 0;
      }
  
  #ifdef SDL_LIBUSB_DYNAMIC
      ++attempts;
      libusb_ctx.libhandle = SDL_LoadObject(SDL_LIBUSB_DYNAMIC);
      if (libusb_ctx.libhandle != NULL) {
          SDL_bool loaded = SDL_TRUE;
          #define LOAD_LIBUSB_SYMBOL(func) \
              if (!(libusb_ctx.func = SDL_LoadFunction(libusb_ctx.libhandle, "libusb_" #func))) {loaded = SDL_FALSE;}
          LOAD_LIBUSB_SYMBOL(init)
          LOAD_LIBUSB_SYMBOL(exit)
          LOAD_LIBUSB_SYMBOL(get_device_list)
          LOAD_LIBUSB_SYMBOL(free_device_list)
          LOAD_LIBUSB_SYMBOL(get_device_descriptor)
          LOAD_LIBUSB_SYMBOL(get_active_config_descriptor)
          LOAD_LIBUSB_SYMBOL(get_config_descriptor)
          LOAD_LIBUSB_SYMBOL(free_config_descriptor)
          LOAD_LIBUSB_SYMBOL(get_bus_number)
          LOAD_LIBUSB_SYMBOL(get_device_address)
          LOAD_LIBUSB_SYMBOL(open)
          LOAD_LIBUSB_SYMBOL(close)
          LOAD_LIBUSB_SYMBOL(claim_interface)
          LOAD_LIBUSB_SYMBOL(release_interface)
          LOAD_LIBUSB_SYMBOL(kernel_driver_active)
          LOAD_LIBUSB_SYMBOL(detach_kernel_driver)
          LOAD_LIBUSB_SYMBOL(attach_kernel_driver)
          LOAD_LIBUSB_SYMBOL(set_interface_alt_setting)
          LOAD_LIBUSB_SYMBOL(alloc_transfer)
          LOAD_LIBUSB_SYMBOL(submit_transfer)
          LOAD_LIBUSB_SYMBOL(cancel_transfer)
          LOAD_LIBUSB_SYMBOL(free_transfer)
          LOAD_LIBUSB_SYMBOL(control_transfer)
          LOAD_LIBUSB_SYMBOL(interrupt_transfer)
          LOAD_LIBUSB_SYMBOL(handle_events)
          LOAD_LIBUSB_SYMBOL(handle_events_completed)
          #undef LOAD_LIBUSB_SYMBOL
  
          if (!loaded) {
              SDL_UnloadObject(libusb_ctx.libhandle);
              libusb_ctx.libhandle = NULL;
              /* SDL_LogWarn(SDL_LOG_CATEGORY_INPUT, SDL_LIBUSB_DYNAMIC " found but could not load function"); */
          } else if (LIBUSB_hid_init() < 0) {
              SDL_UnloadObject(libusb_ctx.libhandle);
              libusb_ctx.libhandle = NULL;
          } else {
              ++success;
          }
      }
  #endif /* SDL_LIBUSB_DYNAMIC */
  
  #if HAVE_PLATFORM_BACKEND
      ++attempts;
  #if __LINUX__
      udev_ctx = SDL_UDEV_GetUdevSyms();
  #endif /* __LINUX __ */
      if (udev_ctx && PLATFORM_hid_init() == 0) {
          ++success;
      }
  #endif /* HAVE_PLATFORM_BACKEND */
  
      if (attempts > 0 && success == 0) {
          return -1;
      }
  
      SDL_hidapi_wasinit = SDL_TRUE;
      return 0;
  }
  
  int SDL_hid_exit(void)
  {
      int result = 0;
  
      if (SDL_hidapi_wasinit == SDL_FALSE) {
          return 0;
      }
      SDL_hidapi_wasinit = SDL_FALSE;
  
  #if HAVE_PLATFORM_BACKEND
      if (udev_ctx) {
          result |= PLATFORM_hid_exit();
      }
  #endif /* HAVE_PLATFORM_BACKEND */
  
  #ifdef SDL_LIBUSB_DYNAMIC
      if (libusb_ctx.libhandle) {
          result |= LIBUSB_hid_exit();
          SDL_UnloadObject(libusb_ctx.libhandle);
          libusb_ctx.libhandle = NULL;
      }
  #endif /* SDL_LIBUSB_DYNAMIC */
  
      return result;
  }
  
  struct SDL_hid_device_info *SDL_hid_enumerate(unsigned short vendor_id, unsigned short product_id)
  {
  #if HAVE_PLATFORM_BACKEND || HAVE_DRIVER_BACKEND || defined(SDL_LIBUSB_DYNAMIC)
  #ifdef SDL_LIBUSB_DYNAMIC
      struct SDL_hid_device_info *usb_devs = NULL;
      struct SDL_hid_device_info *usb_dev;
  #endif
  #if HAVE_DRIVER_BACKEND
      struct SDL_hid_device_info* driver_devs = NULL;
      struct SDL_hid_device_info* driver_dev;
  #endif
  #if HAVE_PLATFORM_BACKEND
      struct SDL_hid_device_info *raw_devs = NULL;
      struct SDL_hid_device_info *raw_dev;
  #endif
      struct SDL_hid_device_info *devs = NULL, *last = NULL, *new_dev;
  
      if (SDL_hid_init() != 0) {
          return NULL;
      }
  
  #ifdef SDL_LIBUSB_DYNAMIC
      if (libusb_ctx.libhandle) {
          usb_devs = LIBUSB_hid_enumerate(vendor_id, product_id);
    #ifdef DEBUG_HIDAPI
          SDL_Log("libusb devices found:");
    #endif
          for (usb_dev = usb_devs; usb_dev; usb_dev = usb_dev->next) {
              new_dev = (struct SDL_hid_device_info*) SDL_malloc(sizeof(struct SDL_hid_device_info));
              if (!new_dev) {
                  LIBUSB_hid_free_enumeration(usb_devs);
                  SDL_hid_free_enumeration(devs);
                  SDL_OutOfMemory();
                  return NULL;
              }
              CopyHIDDeviceInfo(usb_dev, new_dev);
    #ifdef DEBUG_HIDAPI
              SDL_Log(" - %ls %ls 0x%.4hx 0x%.4hx",
                      usb_dev->manufacturer_string, usb_dev->product_string,
                      usb_dev->vendor_id, usb_dev->product_id);
    #endif
  
              if (last != NULL) {
                  last->next = new_dev;
              } else {
                  devs = new_dev;
              }
              last = new_dev;
          }
      }
  #endif /* SDL_LIBUSB_DYNAMIC */
  
  #ifdef HAVE_DRIVER_BACKEND
      driver_devs = DRIVER_hid_enumerate(vendor_id, product_id);
      for (driver_dev = driver_devs; driver_dev; driver_dev = driver_dev->next) {
          new_dev = (struct SDL_hid_device_info*) SDL_malloc(sizeof(struct SDL_hid_device_info));
          CopyHIDDeviceInfo(driver_dev, new_dev);
  
          if (last != NULL) {
              last->next = new_dev;
          } else {
              devs = new_dev;
          }
          last = new_dev;
      }
  #endif /* HAVE_DRIVER_BACKEND */
  
  #if HAVE_PLATFORM_BACKEND
      if (udev_ctx) {
          raw_devs = PLATFORM_hid_enumerate(vendor_id, product_id);
  #ifdef DEBUG_HIDAPI
          SDL_Log("hidraw devices found:");
  #endif
          for (raw_dev = raw_devs; raw_dev; raw_dev = raw_dev->next) {
              SDL_bool bFound = SDL_FALSE;
  #ifdef DEBUG_HIDAPI
              SDL_Log(" - %ls %ls 0x%.4hx 0x%.4hx",
                      raw_dev->manufacturer_string, raw_dev->product_string,
                      raw_dev->vendor_id, raw_dev->product_id);
  #endif
  #ifdef SDL_LIBUSB_DYNAMIC
              for (usb_dev = usb_devs; usb_dev; usb_dev = usb_dev->next) {
                  if (raw_dev->vendor_id == usb_dev->vendor_id &&
                      raw_dev->product_id == usb_dev->product_id &&
                      (raw_dev->interface_number < 0 || raw_dev->interface_number == usb_dev->interface_number)) {
                      bFound = SDL_TRUE;
                      break;
                  }
              }
  #endif
  #ifdef HAVE_DRIVER_BACKEND
              for (driver_dev = driver_devs; driver_dev; driver_dev = driver_dev->next) {
                  if (raw_dev->vendor_id == driver_dev->vendor_id &&
                      raw_dev->product_id == driver_dev->product_id &&
                      (raw_dev->interface_number < 0 || raw_dev->interface_number == driver_dev->interface_number)) {
                      bFound = SDL_TRUE;
                      break;
                  }
              }
  #endif
              if (!bFound) {
                  new_dev = (struct SDL_hid_device_info*) SDL_malloc(sizeof(struct SDL_hid_device_info));
                  if (!new_dev) {
  #ifdef SDL_LIBUSB_DYNAMIC
                      if (libusb_ctx.libhandle) {
                          LIBUSB_hid_free_enumeration(usb_devs);
                      }
  #endif
                      PLATFORM_hid_free_enumeration(raw_devs);
                      SDL_hid_free_enumeration(devs);
                      SDL_OutOfMemory();
                      return NULL;
                  }
                  CopyHIDDeviceInfo(raw_dev, new_dev);
                  new_dev->next = NULL;
  
                  if (last != NULL) {
                      last->next = new_dev;
                  } else {
                      devs = new_dev;
                  }
                  last = new_dev;
              }
          }
          PLATFORM_hid_free_enumeration(raw_devs);
      }
  #endif /* HAVE_PLATFORM_BACKEND */
  
  #ifdef SDL_LIBUSB_DYNAMIC
      if (libusb_ctx.libhandle) {
          LIBUSB_hid_free_enumeration(usb_devs);
      }
  #endif
      return devs;
  
  #else
      return NULL;
  #endif /* HAVE_PLATFORM_BACKEND || HAVE_DRIVER_BACKEND || SDL_LIBUSB_DYNAMIC */
  }
  
  void SDL_hid_free_enumeration(struct SDL_hid_device_info *devs)
  {
      while (devs) {
          struct SDL_hid_device_info *next = devs->next;
          SDL_free(devs->path);
          SDL_free(devs->serial_number);
          SDL_free(devs->manufacturer_string);
          SDL_free(devs->product_string);
          SDL_free(devs);
          devs = next;
      }
  }
  
  SDL_hid_device *SDL_hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)
  {
  #if HAVE_PLATFORM_BACKEND || HAVE_DRIVER_BACKEND || defined(SDL_LIBUSB_DYNAMIC)
      SDL_hid_device *pDevice = NULL;
  
      if (SDL_hid_init() != 0) {
          return NULL;
      }
  
  #if HAVE_PLATFORM_BACKEND
      if (udev_ctx &&
          (pDevice = (SDL_hid_device*) PLATFORM_hid_open(vendor_id, product_id, serial_number)) != NULL) {
  
          HIDDeviceWrapper *wrapper = CreateHIDDeviceWrapper(pDevice, &PLATFORM_Backend);
          return WrapHIDDevice(wrapper);
      }
  #endif /* HAVE_PLATFORM_BACKEND */
  
  #if HAVE_DRIVER_BACKEND
      if ((pDevice = (SDL_hid_device*) DRIVER_hid_open(vendor_id, product_id, serial_number)) != NULL) {
  
          HIDDeviceWrapper *wrapper = CreateHIDDeviceWrapper(pDevice, &DRIVER_Backend);
          return WrapHIDDevice(wrapper);
      }
  #endif /* HAVE_DRIVER_BACKEND */
  
  #ifdef SDL_LIBUSB_DYNAMIC
      if (libusb_ctx.libhandle &&
          (pDevice = (SDL_hid_device*) LIBUSB_hid_open(vendor_id, product_id, serial_number)) != NULL) {
  
          HIDDeviceWrapper *wrapper = CreateHIDDeviceWrapper(pDevice, &LIBUSB_Backend);
          return WrapHIDDevice(wrapper);
      }
  #endif /* SDL_LIBUSB_DYNAMIC */
  
  #endif /* HAVE_PLATFORM_BACKEND || HAVE_DRIVER_BACKEND || SDL_LIBUSB_DYNAMIC */
  
      return NULL;
  }
  
  SDL_hid_device *SDL_hid_open_path(const char *path, int bExclusive /* = false */)
  {
  #if HAVE_PLATFORM_BACKEND || HAVE_DRIVER_BACKEND || defined(SDL_LIBUSB_DYNAMIC)
      SDL_hid_device *pDevice = NULL;
  
      if (SDL_hid_init() != 0) {
          return NULL;
      }
  
  #if HAVE_PLATFORM_BACKEND
      if (udev_ctx &&
          (pDevice = (SDL_hid_device*) PLATFORM_hid_open_path(path, bExclusive)) != NULL) {
  
          HIDDeviceWrapper *wrapper = CreateHIDDeviceWrapper(pDevice, &PLATFORM_Backend);
          return WrapHIDDevice(wrapper);
      }
  #endif /* HAVE_PLATFORM_BACKEND */
  
  #if HAVE_DRIVER_BACKEND
      if ((pDevice = (SDL_hid_device*) DRIVER_hid_open_path(path, bExclusive)) != NULL) {
  
          HIDDeviceWrapper *wrapper = CreateHIDDeviceWrapper(pDevice, &DRIVER_Backend);
          return WrapHIDDevice(wrapper);
      }
  #endif /* HAVE_DRIVER_BACKEND */
  
  #ifdef SDL_LIBUSB_DYNAMIC
      if (libusb_ctx.libhandle &&
          (pDevice = (SDL_hid_device*) LIBUSB_hid_open_path(path, bExclusive)) != NULL) {
  
          HIDDeviceWrapper *wrapper = CreateHIDDeviceWrapper(pDevice, &LIBUSB_Backend);
          return WrapHIDDevice(wrapper);
      }
  #endif /* SDL_LIBUSB_DYNAMIC */
  
  #endif /* HAVE_PLATFORM_BACKEND || HAVE_DRIVER_BACKEND || SDL_LIBUSB_DYNAMIC */
  
      return NULL;
  }
  
  int SDL_hid_write(SDL_hid_device *device, const unsigned char *data, size_t length)
  {
      HIDDeviceWrapper *wrapper = UnwrapHIDDevice(device);
      int result;
  
      CHECK_DEVICE_MAGIC(wrapper, -1);
  
      result = wrapper->backend->hid_write(wrapper->device, data, length);
      if (result < 0) {
          SDL_SetHIDAPIError(wrapper->backend->hid_error(wrapper->device));
      }
      return result;
  }
  
  int SDL_hid_read_timeout(SDL_hid_device *device, unsigned char *data, size_t length, int milliseconds)
  {
      HIDDeviceWrapper *wrapper = UnwrapHIDDevice(device);
      int result;
  
      CHECK_DEVICE_MAGIC(wrapper, -1);
  
      result = wrapper->backend->hid_read_timeout(wrapper->device, data, length, milliseconds);
      if (result < 0) {
          SDL_SetHIDAPIError(wrapper->backend->hid_error(wrapper->device));
      }
      return result;
  }
  
  int SDL_hid_read(SDL_hid_device *device, unsigned char *data, size_t length)
  {
      HIDDeviceWrapper *wrapper = UnwrapHIDDevice(device);
      int result;
  
      CHECK_DEVICE_MAGIC(wrapper, -1);
  
      result = wrapper->backend->hid_read(wrapper->device, data, length);
      if (result < 0) {
          SDL_SetHIDAPIError(wrapper->backend->hid_error(wrapper->device));
      }
      return result;
  }
  
  int SDL_hid_set_nonblocking(SDL_hid_device *device, int nonblock)
  {
      HIDDeviceWrapper *wrapper = UnwrapHIDDevice(device);
      int result;
  
      CHECK_DEVICE_MAGIC(wrapper, -1);
  
      result = wrapper->backend->hid_set_nonblocking(wrapper->device, nonblock);
      if (result < 0) {
          SDL_SetHIDAPIError(wrapper->backend->hid_error(wrapper->device));
      }
      return result;
  }
  
  int SDL_hid_send_feature_report(SDL_hid_device *device, const unsigned char *data, size_t length)
  {
      HIDDeviceWrapper *wrapper = UnwrapHIDDevice(device);
      int result;
  
      CHECK_DEVICE_MAGIC(wrapper, -1);
  
      result = wrapper->backend->hid_send_feature_report(wrapper->device, data, length);
      if (result < 0) {
          SDL_SetHIDAPIError(wrapper->backend->hid_error(wrapper->device));
      }
      return result;
  }
  
  int SDL_hid_get_feature_report(SDL_hid_device *device, unsigned char *data, size_t length)
  {
      HIDDeviceWrapper *wrapper = UnwrapHIDDevice(device);
      int result;
  
      CHECK_DEVICE_MAGIC(wrapper, -1);
  
      result = wrapper->backend->hid_get_feature_report(wrapper->device, data, length);
      if (result < 0) {
          SDL_SetHIDAPIError(wrapper->backend->hid_error(wrapper->device));
      }
      return result;
  }
  
  void SDL_hid_close(SDL_hid_device *device)
  {
      HIDDeviceWrapper *wrapper = UnwrapHIDDevice(device);
  
      CHECK_DEVICE_MAGIC(wrapper,);
  
      wrapper->backend->hid_close(wrapper->device);
      DeleteHIDDeviceWrapper(wrapper);
  }
  
  int SDL_hid_get_manufacturer_string(SDL_hid_device *device, wchar_t *string, size_t maxlen)
  {
      HIDDeviceWrapper *wrapper = UnwrapHIDDevice(device);
      int result;
  
      CHECK_DEVICE_MAGIC(wrapper, -1);
  
      result = wrapper->backend->hid_get_manufacturer_string(wrapper->device, string, maxlen);
      if (result < 0) {
          SDL_SetHIDAPIError(wrapper->backend->hid_error(wrapper->device));
      }
      return result;
  }
  
  int SDL_hid_get_product_string(SDL_hid_device *device, wchar_t *string, size_t maxlen)
  {
      HIDDeviceWrapper *wrapper = UnwrapHIDDevice(device);
      int result;
  
      CHECK_DEVICE_MAGIC(wrapper, -1);
  
      result = wrapper->backend->hid_get_product_string(wrapper->device, string, maxlen);
      if (result < 0) {
          SDL_SetHIDAPIError(wrapper->backend->hid_error(wrapper->device));
      }
      return result;
  }
  
  int SDL_hid_get_serial_number_string(SDL_hid_device *device, wchar_t *string, size_t maxlen)
  {
      HIDDeviceWrapper *wrapper = UnwrapHIDDevice(device);
      int result;
  
      CHECK_DEVICE_MAGIC(wrapper, -1);
  
      result = wrapper->backend->hid_get_serial_number_string(wrapper->device, string, maxlen);
      if (result < 0) {
          SDL_SetHIDAPIError(wrapper->backend->hid_error(wrapper->device));
      }
      return result;
  }
  
  int SDL_hid_get_indexed_string(SDL_hid_device *device, int string_index, wchar_t *string, size_t maxlen)
  {
      HIDDeviceWrapper *wrapper = UnwrapHIDDevice(device);
      int result;
  
      CHECK_DEVICE_MAGIC(wrapper, -1);
  
      result = wrapper->backend->hid_get_indexed_string(wrapper->device, string_index, string, maxlen);
      if (result < 0) {
          SDL_SetHIDAPIError(wrapper->backend->hid_error(wrapper->device));
      }
      return result;
  }
  
  #ifdef HAVE_ENABLE_GAMECUBE_ADAPTORS
  /* This is needed to enable input for Nyko and EVORETRO GameCube adaptors */
  void SDL_EnableGameCubeAdaptors(void)
  {
  #ifdef SDL_LIBUSB_DYNAMIC
      libusb_context *usb_context = NULL;
      libusb_device **devs = NULL;
      libusb_device_handle *handle = NULL;
      struct libusb_device_descriptor desc;
      ssize_t i, num_devs;
      int kernel_detached = 0;
  
      if (libusb_ctx.libhandle == NULL) {
          return;
      }
  
      if (libusb_init(&usb_context) == 0) {
          num_devs = libusb_get_device_list(usb_context, &devs);
          for (i = 0; i < num_devs; ++i) {
              if (libusb_get_device_descriptor(devs[i], &desc) != 0) {
                  continue;
              }
  
              if (desc.idVendor != 0x057e || desc.idProduct != 0x0337) {
                  continue;
              }
  
              if (libusb_open(devs[i], &handle) != 0) {
                  continue;
              }
  
              if (libusb_kernel_driver_active(handle, 0)) {
                  if (libusb_detach_kernel_driver(handle, 0) == 0) {
                      kernel_detached = 1;
                  }
              }
  
              if (libusb_claim_interface(handle, 0) == 0) {
                  libusb_control_transfer(handle, 0x21, 11, 0x0001, 0, NULL, 0, 1000);
                  libusb_release_interface(handle, 0);
              }
  
              if (kernel_detached) {
                  libusb_attach_kernel_driver(handle, 0);
              }
  
              libusb_close(handle);
          }
  
          libusb_free_device_list(devs, 1);
  
          libusb_exit(usb_context);
      }
  #endif /* SDL_LIBUSB_DYNAMIC */
  }
  #endif /* HAVE_ENABLE_GAMECUBE_ADAPTORS */
  
  /* vi: set sts=4 ts=4 sw=4 expandtab: */
  

Download