Embedded_Drivers
/
libusbsio
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
libusbsio/src/hid_api/linux/hid.c

1010 lines
31 KiB
C
Raw Blame History

/*******************************************************
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:
http://github.com/signal11/hidapi .
********************************************************/
/*
* Copyright 2014, 2021 NXP
* Modified for use in NXP LIBUSBSIO Library
*/
/* 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"
/* 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
/* Definitions from linux/include/linux/usb.h. Timeouts, in milliseconds,
used for sending receiving control messages. */
#define USB_CTRL_GET_TIMEOUT 5000
#define USB_CTRL_SET_TIMEOUT 5000
/* 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; /* non-zero if numbered records are used */
unsigned short input_report_length; /* maximum size of an input report */
unsigned short output_report_length; /* maximum size of an output report */
unsigned int usage_page; /* unlike Windows/Mac, we are only able to find out usage_page after opening the device */
};
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 = calloc(1, sizeof(hid_device));
dev->device_handle = -1;
dev->blocking = 1;
dev->uses_numbered_reports = 0;
dev->input_report_length = 0;
dev->output_report_length = 0;
dev->usage_page = 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 = 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));
}
/*
* 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 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;
/* 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. */
fstat(dev->device_handle, &s);
/* 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:
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;
}
void parse_report_descriptor(struct hid_device_ *dev, unsigned char *hid_desc, size_t hid_desc_len)
{
/* report sizes in bits */
int last_report_count = 0;
int last_report_size = 0;
int total_input_bits = 0;
int total_output_bits = 0;
/* descriptor processing index */
int i = 0;
/* while parsing the report descriptor, we will set the following fields */
dev->output_report_length = 0; /* total size of ouput report */
dev->input_report_length = 0; /* total size of input report */
dev->uses_numbered_reports = 0; /* wheather device uses numbered records */
dev->usage_page = 0; /* the first usage_page seen */
while (i < hid_desc_len)
{
int data_len, key_size;
int key_valid = 0;
unsigned int value = 0;
unsigned char key = hid_desc[i];
/* Determine type of the item */
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 */
if ((i+1) < hid_desc_len)
data_len = hid_desc[i+1];
else
data_len = 0; /* malformed report */
key_size = 3;
/* note that we leave key_valid 'false' because we are not interested in long items */
}
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 */
int 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:
data_len = 0;
break;
}
key_size = 1;
if((i+data_len) < hid_desc_len)
{
int b;
/* little endian value follows */
value = 0;
for(b=0; b<data_len; b++)
value = value | (hid_desc[i+1+b] << (8*b));
key_valid = 1;
}
else
{
key_valid = 0;
}
}
if(key_valid)
{
/* Usage Page (data_len 1 or 2) */
if(key == 0x05 || key == 0x06)
{
dev->usage_page = value;
}
/* Report size in bits (data_len 1) */
else if(key == 0x75)
{
last_report_size = value;
}
/* Report count (data_len 1 or 2) */
else if(key == 0x95 || key == 0x96)
{
last_report_count = value;
}
/* Input record */
else if(key == 0x81 || key == 0x82)
{
total_input_bits += last_report_size * last_report_count;
}
/* Output record */
else if(key == 0x91 || key == 0x92)
{
total_output_bits += last_report_size * last_report_count;
}
/* A new Report ID flushes the reports collected so far */
else if(key == 0x85)
{
dev->uses_numbered_reports = 1;
/* keep track of maximum input report size */
if(total_input_bits)
{
int total = (total_input_bits + 7) / 8;
if(total > dev->input_report_length)
dev->input_report_length = total;
}
/* the same for output report */
if(total_output_bits)
{
int total = (total_output_bits + 7) / 8;
if(total > dev->output_report_length)
dev->output_report_length = total;
}
/* start measuring the next report lengths */
total_input_bits = 0;
total_output_bits = 0;
}
}
/* Skip over this key and it's associated data */
i += data_len + key_size;
}
/* FIXME: We do not add 1 to report sizes when 'uses_numbered_reports' is detected. This may be different from Windows;
they claim they do add the byte: https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/hidpi/ns-hidpi-_hidp_caps.
If needed, use the dev->uses_numbered_reports flag to add an extra byte when reading/writing the reports */
/* process the last pending input report size */
if(total_input_bits)
{
int total = (total_input_bits + 7) / 8;
if(total > dev->input_report_length)
dev->input_report_length = total;
}
/* the same for output report */
if(total_output_bits)
{
int total = (total_output_bits + 7) / 8;
if(total > dev->output_report_length)
dev->output_report_length = total;
}
/* general sanity check */
if(dev->output_report_length > 0x1000)
dev->output_report_length = 0x1000;
if(dev->input_report_length > 0x1000)
dev->input_report_length = 0x1000;
}
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;
wchar_t *intf_str;
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;
}
/* 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 = malloc(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;
/* use interface descriptor instead of product name if possible (same as on Windows) */
intf_str = copy_udev_string(intf_dev, "interface");
if(intf_str) {
if(cur_dev->product_string)
free(cur_dev->product_string);
cur_dev->product_string = intf_str;
}
}
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 && (wcslen(serial_number) > 0))
{
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);
}
hid_free_enumeration(devs);
return handle;
}
hid_device *HID_API_EXPORT hid_open_path(const char *path)
{
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
{
/* Parse report descriptor to get uses_numbered_reports, output_report_length, etc... */
parse_report_descriptor(dev, rpt_desc.value, rpt_desc.size);
}
return dev;
}
else
{
/* Unable to open any devices. */
free(dev);
return NULL;
}
}
int HID_API_EXPORT hid_write_timeout(hid_device *dev, const unsigned char *data, size_t length, int milliseconds)
{
unsigned char* padded = NULL;
int bytes_written = 0;
if (length <= 0)
return 0;
if (length < (size_t)dev->output_report_length)
{
padded = calloc(1, dev->output_report_length);
if(padded != NULL)
{
/* use buffer of report_length size padded with zeroes instead of original data */
memcpy(padded, data, length);
length = (size_t)dev->output_report_length;
data = padded;
}
}
/*
* Note:
* 1. Blocking Write for USB is not real blocking. There is a build-in timeout in Linux, which
* is defined by USB_CTRL_SET_TIMEOUT in linux/include/linux/usb.h
* 2. Do not use poll()/ppoll() for timeout control. POLLOUT wouldn't be triggered by HIDRAW.
*/
if (milliseconds >= 0)
{
while (milliseconds >= 0)
{
bytes_written = write(dev->device_handle, data, length);
milliseconds -= USB_CTRL_SET_TIMEOUT;
if ((bytes_written < 0) && (errno == ETIMEDOUT) && (milliseconds > 0))
{
// timeout for current write, but still some time left.
continue;
}
else
{
break;
}
}
}
else
{
// Infinite blocking
while (1)
{
bytes_written = write(dev->device_handle, data, length);
if ((bytes_written < 0) && (errno == ETIMEDOUT))
{
continue;
}
else
{
break;
}
}
}
if(padded)
free(padded);
return bytes_written;
}
int HID_API_EXPORT hid_write(hid_device *dev, const unsigned char *data, size_t length)
{
return hid_write_timeout(dev, data, length, (dev->blocking) ? -1 : 0);
}
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;
res = ioctl(dev->device_handle, HIDIOCGFEATURE(length), data);
if (res < 0)
perror("ioctl (GFEATURE)");
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;
}
int HID_API_EXPORT hid_get_report_lengths(hid_device* device, unsigned short* output_report_length, unsigned short* input_report_length)
{
if (output_report_length)
*output_report_length = device->output_report_length;
if (input_report_length)
*input_report_length = device->input_report_length;
return 0;
}
int HID_API_EXPORT hid_get_usage(hid_device* device, unsigned short* usage_page, unsigned short* usage)
{
if (usage_page)
*usage_page = device->usage_page;
if (usage)
*usage = 0; // TODO: device->usage; (does a single usage value even make sense?)
return 0;
}
Reference in New Issue View Git Blame Copy Permalink