| /******************************************************* |
| 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" |
| |
| #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/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 needs_ble_hack; |
| }; |
| |
| |
| 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->needs_ble_hack = 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, unsigned *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_BLE(hid_device *dev) |
| { |
| struct udev *udev; |
| struct udev_device *udev_dev, *hid_dev; |
| struct stat s; |
| int ret; |
| |
| /* 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. */ |
| if (fstat(dev->device_handle, &s) < 0) { |
| udev_unref(udev); |
| return -1; |
| } |
| |
| /* Open a udev device from the dev_t. 'c' means character device. */ |
| ret = 0; |
| 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 = 0; |
| unsigned short dev_pid = 0; |
| unsigned bus_type = 0; |
| char *serial_number_utf8 = NULL; |
| char *product_name_utf8 = NULL; |
| |
| 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); |
| |
| if (bus_type == BUS_BLUETOOTH) { |
| /* Right now the Steam Controller is the only BLE device that we send feature reports to */ |
| if (dev_vid == 0x28de /* Valve */) { |
| ret = 1; |
| } |
| } |
| |
| /* 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; |
| unsigned 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; |
| unsigned 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 | O_CLOEXEC); |
| |
| /* 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->needs_ble_hack = (is_BLE(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) |
| { |
| static const int MAX_RETRIES = 50; |
| int retry; |
| int res; |
| |
| for (retry = 0; retry < MAX_RETRIES; ++retry) { |
| res = ioctl(dev->device_handle, HIDIOCSFEATURE(length), data); |
| if (res < 0 && errno == EPIPE) { |
| /* Try again... */ |
| continue; |
| } |
| |
| if (res < 0) |
| perror("ioctl (SFEATURE)"); |
| break; |
| } |
| return res; |
| } |
| |
| int HID_API_EXPORT hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length) |
| { |
| int res; |
| unsigned char report = data[0]; |
| |
| res = ioctl(dev->device_handle, HIDIOCGFEATURE(length), data); |
| if (res < 0) |
| perror("ioctl (GFEATURE)"); |
| else if (dev->needs_ble_hack) { |
| /* Versions of BlueZ before 5.56 don't include the report in the data, |
| * and versions of BlueZ >= 5.56 include 2 copies of the report. |
| * We'll fix it so that there is a single copy of the report in both cases |
| */ |
| if (data[0] == report && data[1] == report) { |
| memmove(&data[0], &data[1], res); |
| } else if (data[0] != report) { |
| memmove(&data[1], &data[0], res); |
| data[0] = report; |
| ++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) |
| { |
| (void)dev; |
| (void)string_index; |
| (void)string; |
| (void)maxlen; |
| return -1; |
| } |
| |
| |
| HID_API_EXPORT const wchar_t * HID_API_CALL hid_error(hid_device *dev) |
| { |
| return NULL; |
| } |
| |
| #ifdef NAMESPACE |
| } |
| #endif |