kc3-lang/SDL/src/hidapi/linux/hid.c

• Show log

  Commit

• Hash : 494af7a6
  Author :
  Date : 2019-11-25T15:02:45
  

  Backed out change to dynamically load udev - it's already happening in SDL_hidapi.c

Download

• src/hidapi/linux/hid.c

• /*******************************************************
   HIDAPI - Multi-Platform library for
   communication with HID devices.
  
   Alan Ott
   Signal 11 Software
  
   8/22/2009
   Linux Version - 6/2/2009
  
   Copyright 2009, All Rights Reserved.
  
   At the discretion of the user of this library,
   this software may be licensed under the terms of the
   GNU General Public License v3, a BSD-Style license, or the
   original HIDAPI license as outlined in the LICENSE.txt,
   LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt
   files located at the root of the source distribution.
   These files may also be found in the public source
   code repository located at:
          https://github.com/libusb/hidapi .
  ********************************************************/
  #include "../../SDL_internal.h"
  
  #ifdef SDL_JOYSTICK_HIDAPI
  
  #ifndef _GNU_SOURCE
  #define _GNU_SOURCE /* needed for wcsdup() before glibc 2.10 */
  #endif
  
  /* C */
  #include <stdio.h>
  #include <string.h>
  #include <stdlib.h>
  #include <locale.h>
  #include <errno.h>
  
  /* Unix */
  #include <unistd.h>
  #include <sys/types.h>
  #include <sys/stat.h>
  #include <sys/ioctl.h>
  #include <sys/utsname.h>
  #include <fcntl.h>
  #include <poll.h>
  
  /* Linux */
  #include <linux/hidraw.h>
  #include <linux/version.h>
  #include <linux/input.h>
  #include <libudev.h>
  
  #include "hidapi.h"
  
  #ifdef NAMESPACE
  namespace NAMESPACE
  {
  #endif
  
  /* Definitions from linux/hidraw.h. Since these are new, some distros
     may not have header files which contain them. */
  #ifndef HIDIOCSFEATURE
  #define HIDIOCSFEATURE(len)    _IOC(_IOC_WRITE|_IOC_READ, 'H', 0x06, len)
  #endif
  #ifndef HIDIOCGFEATURE
  #define HIDIOCGFEATURE(len)    _IOC(_IOC_WRITE|_IOC_READ, 'H', 0x07, len)
  #endif
  
  /* USB HID device property names */
  const char *device_string_names[] = {
  	"manufacturer",
  	"product",
  	"serial",
  };
  
  /* Symbolic names for the properties above */
  enum device_string_id {
  	DEVICE_STRING_MANUFACTURER,
  	DEVICE_STRING_PRODUCT,
  	DEVICE_STRING_SERIAL,
  
  	DEVICE_STRING_COUNT,
  };
  
  struct hid_device_ {
  	int device_handle;
  	int blocking;
  	int uses_numbered_reports;
  	int is_bluetooth;
  };
  
  
  static __u32 kernel_version = 0;
  
  static __u32 detect_kernel_version(void)
  {
  	struct utsname name;
  	int major, minor, release;
  	int ret;
  
  	uname(&name);
  	ret = sscanf(name.release, "%d.%d.%d", &major, &minor, &release);
  	if (ret == 3) {
  		return KERNEL_VERSION(major, minor, release);
  	}
  
  	ret = sscanf(name.release, "%d.%d", &major, &minor);
  	if (ret == 2) {
  		return KERNEL_VERSION(major, minor, 0);
  	}
  
  	printf("Couldn't determine kernel version from version string \"%s\"\n", name.release);
  	return 0;
  }
  
  static hid_device *new_hid_device(void)
  {
  	hid_device *dev = (hid_device *)calloc(1, sizeof(hid_device));
  	dev->device_handle = -1;
  	dev->blocking = 1;
  	dev->uses_numbered_reports = 0;
  	dev->is_bluetooth = 0;
  
  	return dev;
  }
  
  
  /* The caller must free the returned string with free(). */
  static wchar_t *utf8_to_wchar_t(const char *utf8)
  {
  	wchar_t *ret = NULL;
  
  	if (utf8) {
  		size_t wlen = mbstowcs(NULL, utf8, 0);
  		if ((size_t) -1 == wlen) {
  			return wcsdup(L"");
  		}
  		ret = (wchar_t *)calloc(wlen+1, sizeof(wchar_t));
  		mbstowcs(ret, utf8, wlen+1);
  		ret[wlen] = 0x0000;
  	}
  
  	return ret;
  }
  
  /* Get an attribute value from a udev_device and return it as a whar_t
     string. The returned string must be freed with free() when done.*/
  static wchar_t *copy_udev_string(struct udev_device *dev, const char *udev_name)
  {
  	return utf8_to_wchar_t(udev_device_get_sysattr_value(dev, udev_name));
  }
  
  /* uses_numbered_reports() returns 1 if report_descriptor describes a device
     which contains numbered reports. */
  static int uses_numbered_reports(__u8 *report_descriptor, __u32 size) {
  	unsigned int i = 0;
  	int size_code;
  	int data_len, key_size;
  
  	while (i < size) {
  		int key = report_descriptor[i];
  
  		/* Check for the Report ID key */
  		if (key == 0x85/*Report ID*/) {
  			/* This device has a Report ID, which means it uses
  			   numbered reports. */
  			return 1;
  		}
  
  		//printf("key: %02hhx\n", key);
  
  		if ((key & 0xf0) == 0xf0) {
  			/* This is a Long Item. The next byte contains the
  			   length of the data section (value) for this key.
  			   See the HID specification, version 1.11, section
  			   6.2.2.3, titled "Long Items." */
  			if (i+1 < size)
  				data_len = report_descriptor[i+1];
  			else
  				data_len = 0; /* malformed report */
  			key_size = 3;
  		}
  		else {
  			/* This is a Short Item. The bottom two bits of the
  			   key contain the size code for the data section
  			   (value) for this key.  Refer to the HID
  			   specification, version 1.11, section 6.2.2.2,
  			   titled "Short Items." */
  			size_code = key & 0x3;
  			switch (size_code) {
  			case 0:
  			case 1:
  			case 2:
  				data_len = size_code;
  				break;
  			case 3:
  				data_len = 4;
  				break;
  			default:
  				/* Can't ever happen since size_code is & 0x3 */
  				data_len = 0;
  				break;
  			};
  			key_size = 1;
  		}
  
  		/* Skip over this key and it's associated data */
  		i += data_len + key_size;
  	}
  
  	/* Didn't find a Report ID key. Device doesn't use numbered reports. */
  	return 0;
  }
  
  /*
   * The caller is responsible for free()ing the (newly-allocated) character
   * strings pointed to by serial_number_utf8 and product_name_utf8 after use.
   */
  static int
  parse_uevent_info(const char *uevent, int *bus_type,
  	unsigned short *vendor_id, unsigned short *product_id,
  	char **serial_number_utf8, char **product_name_utf8)
  {
  	char *tmp = strdup(uevent);
  	char *saveptr = NULL;
  	char *line;
  	char *key;
  	char *value;
  
  	int found_id = 0;
  	int found_serial = 0;
  	int found_name = 0;
  
  	line = strtok_r(tmp, "\n", &saveptr);
  	while (line != NULL) {
  		/* line: "KEY=value" */
  		key = line;
  		value = strchr(line, '=');
  		if (!value) {
  			goto next_line;
  		}
  		*value = '\0';
  		value++;
  
  		if (strcmp(key, "HID_ID") == 0) {
  			/**
  			 *        type vendor   product
  			 * HID_ID=0003:000005AC:00008242
  			 **/
  			int ret = sscanf(value, "%x:%hx:%hx", bus_type, vendor_id, product_id);
  			if (ret == 3) {
  				found_id = 1;
  			}
  		} else if (strcmp(key, "HID_NAME") == 0) {
  			/* The caller has to free the product name */
  			*product_name_utf8 = strdup(value);
  			found_name = 1;
  		} else if (strcmp(key, "HID_UNIQ") == 0) {
  			/* The caller has to free the serial number */
  			*serial_number_utf8 = strdup(value);
  			found_serial = 1;
  		}
  
  next_line:
  		line = strtok_r(NULL, "\n", &saveptr);
  	}
  
  	free(tmp);
  	return (found_id && found_name && found_serial);
  }
  
  static int is_bluetooth(hid_device *dev)
  {
  	struct udev *udev;
  	struct udev_device *udev_dev, *hid_dev;
  	struct stat s;
  	int ret = -1;
  
  	/* Create the udev object */
  	udev = udev_new();
  	if (!udev) {
  		printf("Can't create udev\n");
  		return -1;
  	}
  
  	/* Get the dev_t (major/minor numbers) from the file handle. */
  	ret = fstat(dev->device_handle, &s);
  	if (-1 == ret) {
  		udev_unref(udev);
  		return ret;
  	}
  
  	/* Open a udev device from the dev_t. 'c' means character device. */
  	udev_dev = udev_device_new_from_devnum(udev, 'c', s.st_rdev);
  	if (udev_dev) {
  		hid_dev = udev_device_get_parent_with_subsystem_devtype(
  			udev_dev,
  			"hid",
  			NULL);
  		if (hid_dev) {
  			unsigned short dev_vid;
  			unsigned short dev_pid;
  			int bus_type;
  			char *serial_number_utf8 = NULL;
  			char *product_name_utf8 = NULL;
  
  			ret = parse_uevent_info(
  			           udev_device_get_sysattr_value(hid_dev, "uevent"),
  			           &bus_type,
  			           &dev_vid,
  			           &dev_pid,
  			           &serial_number_utf8,
  			           &product_name_utf8);
  			free(serial_number_utf8);
  			free(product_name_utf8);
  
  			ret = (bus_type == BUS_BLUETOOTH);
  
  			/* hid_dev doesn't need to be (and can't be) unref'd.
  			   I'm not sure why, but it'll throw double-free() errors. */
  		}
  		udev_device_unref(udev_dev);
  	}
  
  	udev_unref(udev);
  
  	return ret;
  }
  
  
  static int get_device_string(hid_device *dev, enum device_string_id key, wchar_t *string, size_t maxlen)
  {
  	struct udev *udev;
  	struct udev_device *udev_dev, *parent, *hid_dev;
  	struct stat s;
  	int ret = -1;
          char *serial_number_utf8 = NULL;
          char *product_name_utf8 = NULL;
  	char *tmp;
  
  	/* Create the udev object */
  	udev = udev_new();
  	if (!udev) {
  		printf("Can't create udev\n");
  		return -1;
  	}
  
  	/* Get the dev_t (major/minor numbers) from the file handle. */
  	ret = fstat(dev->device_handle, &s);
  	if (-1 == ret) {
  		udev_unref(udev);
  		return ret;
  	}
  	/* Open a udev device from the dev_t. 'c' means character device. */
  	udev_dev = udev_device_new_from_devnum(udev, 'c', s.st_rdev);
  	if (udev_dev) {
  		hid_dev = udev_device_get_parent_with_subsystem_devtype(
  			udev_dev,
  			"hid",
  			NULL);
  		if (hid_dev) {
  			unsigned short dev_vid;
  			unsigned short dev_pid;
  			int bus_type;
  			size_t retm;
  
  			ret = parse_uevent_info(
  			           udev_device_get_sysattr_value(hid_dev, "uevent"),
  			           &bus_type,
  			           &dev_vid,
  			           &dev_pid,
  			           &serial_number_utf8,
  			           &product_name_utf8);
  
  			if (bus_type == BUS_BLUETOOTH) {
  				switch (key) {
  					case DEVICE_STRING_MANUFACTURER:
  						wcsncpy(string, L"", maxlen);
  						ret = 0;
  						break;
  					case DEVICE_STRING_PRODUCT:
  						retm = mbstowcs(string, product_name_utf8, maxlen);
  						ret = (retm == (size_t)-1)? -1: 0;
  						break;
  					case DEVICE_STRING_SERIAL:
  						/* Bluetooth serial numbers are often the bluetooth device address
  						   and we want that with the colons stripped out, which is the correct
  						   serial number for PS4 controllers
  						 */
  						while ((tmp = strchr(serial_number_utf8, ':')) != NULL) {
  							memmove(tmp, tmp+1, strlen(tmp));
  						}
  						retm = mbstowcs(string, serial_number_utf8, maxlen);
  						ret = (retm == (size_t)-1)? -1: 0;
  						break;
  					case DEVICE_STRING_COUNT:
  					default:
  						ret = -1;
  						break;
  				}
  			}
  			else {
  				/* This is a USB device. Find its parent USB Device node. */
  				parent = udev_device_get_parent_with_subsystem_devtype(
  					   udev_dev,
  					   "usb",
  					   "usb_device");
  				if (parent) {
  					const char *str;
  					const char *key_str = NULL;
  
  					if (key >= 0 && key < DEVICE_STRING_COUNT) {
  						key_str = device_string_names[key];
  					} else {
  						ret = -1;
  						goto end;
  					}
  
  					str = udev_device_get_sysattr_value(parent, key_str);
  					if (str) {
  						/* Convert the string from UTF-8 to wchar_t */
  						retm = mbstowcs(string, str, maxlen);
  						ret = (retm == (size_t)-1)? -1: 0;
  						goto end;
  					}
  				}
  			}
  		}
  	}
  
  end:
          free(serial_number_utf8);
          free(product_name_utf8);
  
  	udev_device_unref(udev_dev);
  	/* parent and hid_dev don't need to be (and can't be) unref'd.
  	   I'm not sure why, but they'll throw double-free() errors. */
  	udev_unref(udev);
  
  	return ret;
  }
  
  int HID_API_EXPORT hid_init(void)
  {
  	const char *locale;
  
  	/* Set the locale if it's not set. */
  	locale = setlocale(LC_CTYPE, NULL);
  	if (!locale)
  		setlocale(LC_CTYPE, "");
  
  	kernel_version = detect_kernel_version();
  
  	return 0;
  }
  
  int HID_API_EXPORT hid_exit(void)
  {
  	/* Nothing to do for this in the Linux/hidraw implementation. */
  	return 0;
  }
  
  
  struct hid_device_info  HID_API_EXPORT *hid_enumerate(unsigned short vendor_id, unsigned short product_id)
  {
  	struct udev *udev;
  	struct udev_enumerate *enumerate;
  	struct udev_list_entry *devices, *dev_list_entry;
  
  	struct hid_device_info *root = NULL; /* return object */
  	struct hid_device_info *cur_dev = NULL;
  	struct hid_device_info *prev_dev = NULL; /* previous device */
  
  	hid_init();
  
  	/* Create the udev object */
  	udev = udev_new();
  	if (!udev) {
  		printf("Can't create udev\n");
  		return NULL;
  	}
  
  	/* Create a list of the devices in the 'hidraw' subsystem. */
  	enumerate = udev_enumerate_new(udev);
  	udev_enumerate_add_match_subsystem(enumerate, "hidraw");
  	udev_enumerate_scan_devices(enumerate);
  	devices = udev_enumerate_get_list_entry(enumerate);
  	/* For each item, see if it matches the vid/pid, and if so
  	   create a udev_device record for it */
  	udev_list_entry_foreach(dev_list_entry, devices) {
  		const char *sysfs_path;
  		const char *dev_path;
  		const char *str;
  		struct udev_device *raw_dev; /* The device's hidraw udev node. */
  		struct udev_device *hid_dev; /* The device's HID udev node. */
  		struct udev_device *usb_dev; /* The device's USB udev node. */
  		struct udev_device *intf_dev; /* The device's interface (in the USB sense). */
  		unsigned short dev_vid;
  		unsigned short dev_pid;
  		char *serial_number_utf8 = NULL;
  		char *product_name_utf8 = NULL;
  		int bus_type;
  		int result;
  
  		/* Get the filename of the /sys entry for the device
  		   and create a udev_device object (dev) representing it */
  		sysfs_path = udev_list_entry_get_name(dev_list_entry);
  		raw_dev = udev_device_new_from_syspath(udev, sysfs_path);
  		dev_path = udev_device_get_devnode(raw_dev);
  
  		hid_dev = udev_device_get_parent_with_subsystem_devtype(
  			raw_dev,
  			"hid",
  			NULL);
  
  		if (!hid_dev) {
  			/* Unable to find parent hid device. */
  			goto next;
  		}
  
  		result = parse_uevent_info(
  			udev_device_get_sysattr_value(hid_dev, "uevent"),
  			&bus_type,
  			&dev_vid,
  			&dev_pid,
  			&serial_number_utf8,
  			&product_name_utf8);
  
  		if (!result) {
  			/* parse_uevent_info() failed for at least one field. */
  			goto next;
  		}
  
  		if (bus_type != BUS_USB && bus_type != BUS_BLUETOOTH) {
  			/* We only know how to handle USB and BT devices. */
  			goto next;
  		}
  
  		if (access(dev_path, R_OK|W_OK) != 0) {
  			/* We can't open this device, ignore it */
  			goto next;
  		}
  
  		/* Check the VID/PID against the arguments */
  		if ((vendor_id == 0x0 || vendor_id == dev_vid) &&
  		    (product_id == 0x0 || product_id == dev_pid)) {
  			struct hid_device_info *tmp;
  
  			/* VID/PID match. Create the record. */
  			tmp = (struct hid_device_info *)calloc(1, sizeof(struct hid_device_info));
  			if (cur_dev) {
  				cur_dev->next = tmp;
  			}
  			else {
  				root = tmp;
  			}
  			prev_dev = cur_dev;
  			cur_dev = tmp;
  
  			/* Fill out the record */
  			cur_dev->next = NULL;
  			cur_dev->path = dev_path? strdup(dev_path): NULL;
  
  			/* VID/PID */
  			cur_dev->vendor_id = dev_vid;
  			cur_dev->product_id = dev_pid;
  
  			/* Serial Number */
  			cur_dev->serial_number = utf8_to_wchar_t(serial_number_utf8);
  
  			/* Release Number */
  			cur_dev->release_number = 0x0;
  
  			/* Interface Number */
  			cur_dev->interface_number = -1;
  
  			switch (bus_type) {
  				case BUS_USB:
  					/* The device pointed to by raw_dev contains information about
  					   the hidraw device. In order to get information about the
  					   USB device, get the parent device with the
  					   subsystem/devtype pair of "usb"/"usb_device". This will
  					   be several levels up the tree, but the function will find
  					   it. */
  					usb_dev = udev_device_get_parent_with_subsystem_devtype(
  							raw_dev,
  							"usb",
  							"usb_device");
  
  					if (!usb_dev) {
  						/* Free this device */
  						free(cur_dev->serial_number);
  						free(cur_dev->path);
  						free(cur_dev);
  
  						/* Take it off the device list. */
  						if (prev_dev) {
  							prev_dev->next = NULL;
  							cur_dev = prev_dev;
  						}
  						else {
  							cur_dev = root = NULL;
  						}
  
  						goto next;
  					}
  
  					/* Manufacturer and Product strings */
  					cur_dev->manufacturer_string = copy_udev_string(usb_dev, device_string_names[DEVICE_STRING_MANUFACTURER]);
  					cur_dev->product_string = copy_udev_string(usb_dev, device_string_names[DEVICE_STRING_PRODUCT]);
  
  					/* Release Number */
  					str = udev_device_get_sysattr_value(usb_dev, "bcdDevice");
  					cur_dev->release_number = (str)? strtol(str, NULL, 16): 0x0;
  
  					/* Get a handle to the interface's udev node. */
  					intf_dev = udev_device_get_parent_with_subsystem_devtype(
  							raw_dev,
  							"usb",
  							"usb_interface");
  					if (intf_dev) {
  						str = udev_device_get_sysattr_value(intf_dev, "bInterfaceNumber");
  						cur_dev->interface_number = (str)? strtol(str, NULL, 16): -1;
  					}
  
  					break;
  
  				case BUS_BLUETOOTH:
  					/* Manufacturer and Product strings */
  					cur_dev->manufacturer_string = wcsdup(L"");
  					cur_dev->product_string = utf8_to_wchar_t(product_name_utf8);
  
  					break;
  
  				default:
  					/* Unknown device type - this should never happen, as we
  					 * check for USB and Bluetooth devices above */
  					break;
  			}
  		}
  
  	next:
  		free(serial_number_utf8);
  		free(product_name_utf8);
  		udev_device_unref(raw_dev);
  		/* hid_dev, usb_dev and intf_dev don't need to be (and can't be)
  		   unref()d.  It will cause a double-free() error.  I'm not
  		   sure why.  */
  	}
  	/* Free the enumerator and udev objects. */
  	udev_enumerate_unref(enumerate);
  	udev_unref(udev);
  
  	return root;
  }
  
  void  HID_API_EXPORT hid_free_enumeration(struct hid_device_info *devs)
  {
  	struct hid_device_info *d = devs;
  	while (d) {
  		struct hid_device_info *next = d->next;
  		free(d->path);
  		free(d->serial_number);
  		free(d->manufacturer_string);
  		free(d->product_string);
  		free(d);
  		d = next;
  	}
  }
  
  hid_device * hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)
  {
  	struct hid_device_info *devs, *cur_dev;
  	const char *path_to_open = NULL;
  	hid_device *handle = NULL;
  
  	devs = hid_enumerate(vendor_id, product_id);
  	cur_dev = devs;
  	while (cur_dev) {
  		if (cur_dev->vendor_id == vendor_id &&
  		    cur_dev->product_id == product_id) {
  			if (serial_number) {
  				if (wcscmp(serial_number, cur_dev->serial_number) == 0) {
  					path_to_open = cur_dev->path;
  					break;
  				}
  			}
  			else {
  				path_to_open = cur_dev->path;
  				break;
  			}
  		}
  		cur_dev = cur_dev->next;
  	}
  
  	if (path_to_open) {
  		/* Open the device */
  		handle = hid_open_path(path_to_open, 0);
  	}
  
  	hid_free_enumeration(devs);
  
  	return handle;
  }
  
  hid_device * HID_API_EXPORT hid_open_path(const char *path, int bExclusive)
  {
  	hid_device *dev = NULL;
  
  	hid_init();
  
  	dev = new_hid_device();
  
  	/* OPEN HERE */
  	dev->device_handle = open(path, O_RDWR);
  
  	/* If we have a good handle, return it. */
  	if (dev->device_handle > 0) {
  
  		/* Get the report descriptor */
  		int res, desc_size = 0;
  		struct hidraw_report_descriptor rpt_desc;
  
  		memset(&rpt_desc, 0x0, sizeof(rpt_desc));
  
  		/* Get Report Descriptor Size */
  		res = ioctl(dev->device_handle, HIDIOCGRDESCSIZE, &desc_size);
  		if (res < 0)
  			perror("HIDIOCGRDESCSIZE");
  
  
  		/* Get Report Descriptor */
  		rpt_desc.size = desc_size;
  		res = ioctl(dev->device_handle, HIDIOCGRDESC, &rpt_desc);
  		if (res < 0) {
  			perror("HIDIOCGRDESC");
  		} else {
  			/* Determine if this device uses numbered reports. */
  			dev->uses_numbered_reports =
  				uses_numbered_reports(rpt_desc.value,
  				                      rpt_desc.size);
  		}
  
  		dev->is_bluetooth = (is_bluetooth(dev) == 1);
  
  		return dev;
  	}
  	else {
  		/* Unable to open any devices. */
  		free(dev);
  		return NULL;
  	}
  }
  
  
  int HID_API_EXPORT hid_write(hid_device *dev, const unsigned char *data, size_t length)
  {
  	int bytes_written;
  
  	bytes_written = write(dev->device_handle, data, length);
  
  	return bytes_written;
  }
  
  
  int HID_API_EXPORT hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds)
  {
  	int bytes_read;
  
  	if (milliseconds >= 0) {
  		/* Milliseconds is either 0 (non-blocking) or > 0 (contains
  		   a valid timeout). In both cases we want to call poll()
  		   and wait for data to arrive.  Don't rely on non-blocking
  		   operation (O_NONBLOCK) since some kernels don't seem to
  		   properly report device disconnection through read() when
  		   in non-blocking mode.  */
  		int ret;
  		struct pollfd fds;
  
  		fds.fd = dev->device_handle;
  		fds.events = POLLIN;
  		fds.revents = 0;
  		ret = poll(&fds, 1, milliseconds);
  		if (ret == -1 || ret == 0) {
  			/* Error or timeout */
  			return ret;
  		}
  		else {
  			/* Check for errors on the file descriptor. This will
  			   indicate a device disconnection. */
  			if (fds.revents & (POLLERR | POLLHUP | POLLNVAL))
  				return -1;
  		}
  	}
  
  	bytes_read = read(dev->device_handle, data, length);
  	if (bytes_read < 0 && (errno == EAGAIN || errno == EINPROGRESS))
  		bytes_read = 0;
  
  	if (bytes_read >= 0 &&
  	    kernel_version != 0 &&
  	    kernel_version < KERNEL_VERSION(2,6,34) &&
  	    dev->uses_numbered_reports) {
  		/* Work around a kernel bug. Chop off the first byte. */
  		memmove(data, data+1, bytes_read);
  		bytes_read--;
  	}
  
  	return bytes_read;
  }
  
  int HID_API_EXPORT hid_read(hid_device *dev, unsigned char *data, size_t length)
  {
  	return hid_read_timeout(dev, data, length, (dev->blocking)? -1: 0);
  }
  
  int HID_API_EXPORT hid_set_nonblocking(hid_device *dev, int nonblock)
  {
  	/* Do all non-blocking in userspace using poll(), since it looks
  	   like there's a bug in the kernel in some versions where
  	   read() will not return -1 on disconnection of the USB device */
  
  	dev->blocking = !nonblock;
  	return 0; /* Success */
  }
  
  
  int HID_API_EXPORT hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length)
  {
  	int res;
  
  	res = ioctl(dev->device_handle, HIDIOCSFEATURE(length), data);
  	if (res < 0)
  		perror("ioctl (SFEATURE)");
  
  	return res;
  }
  
  int HID_API_EXPORT hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length)
  {
  	int res;
  
  	/* It looks like HIDIOCGFEATURE() on Bluetooth devices doesn't return the report number */
  	if (dev->is_bluetooth) {
  		data[1] = data[0];
  		++data;
  		--length;
  	}
  	res = ioctl(dev->device_handle, HIDIOCGFEATURE(length), data);
  	if (res < 0)
  		perror("ioctl (GFEATURE)");
  	else if (dev->is_bluetooth)
  		++res;
  
  	return res;
  }
  
  
  void HID_API_EXPORT hid_close(hid_device *dev)
  {
  	if (!dev)
  		return;
  	close(dev->device_handle);
  	free(dev);
  }
  
  
  int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen)
  {
  	return get_device_string(dev, DEVICE_STRING_MANUFACTURER, string, maxlen);
  }
  
  int HID_API_EXPORT_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen)
  {
  	return get_device_string(dev, DEVICE_STRING_PRODUCT, string, maxlen);
  }
  
  int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen)
  {
  	return get_device_string(dev, DEVICE_STRING_SERIAL, string, maxlen);
  }
  
  int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen)
  {
  	return -1;
  }
  
  
  HID_API_EXPORT const wchar_t * HID_API_CALL  hid_error(hid_device *dev)
  {
  	return NULL;
  }
  
  #ifdef NAMESPACE
  }
  #endif
  
  #endif /* SDL_JOYSTICK_HIDAPI */
  

Download