+ GNU General Public License v3, a BSD-Style license, or the

+#include <libusb.h>

+#ifndef __ANDROID__

+#include <iconv.h>

+#endif

+#ifdef __ANDROID__

+

+/* Barrier implementation because Android/Bionic don't have pthread_barrier.

+ This implementation came from Brent Priddy and was posted on

+ StackOverflow. It is used with his permission. */

+typedef int pthread_barrierattr_t;

+typedef struct pthread_barrier {

+ pthread_mutex_t mutex;

+ pthread_cond_t cond;

+ int count;

+ int trip_count;

+} pthread_barrier_t;

+

+static int pthread_barrier_init(pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count)

+{

+ if(count == 0) {

+ errno = EINVAL;

+ return -1;

+ }

+

+ if(pthread_mutex_init(&barrier->mutex, 0) < 0) {

+ return -1;

+ }

+ if(pthread_cond_init(&barrier->cond, 0) < 0) {

+ pthread_mutex_destroy(&barrier->mutex);

+ return -1;

+ }

+ barrier->trip_count = count;

+ barrier->count = 0;

+

+ return 0;

+}

+

+static int pthread_barrier_destroy(pthread_barrier_t *barrier)

+{

+ pthread_cond_destroy(&barrier->cond);

+ pthread_mutex_destroy(&barrier->mutex);

+ return 0;

+}

+

+static int pthread_barrier_wait(pthread_barrier_t *barrier)

+{

+ pthread_mutex_lock(&barrier->mutex);

+ ++(barrier->count);

+ if(barrier->count >= barrier->trip_count)

+ {

+ barrier->count = 0;

+ pthread_cond_broadcast(&barrier->cond);

+ pthread_mutex_unlock(&barrier->mutex);

+ return 1;

+ }

+ else

+ {

+ pthread_cond_wait(&barrier->cond, &(barrier->mutex));

+ pthread_mutex_unlock(&barrier->mutex);

+ return 0;

+ }

+}

+

+#endif

+

+#if defined(__FreeBSD__) && __FreeBSD__ < 10

+/* The libusb version included in FreeBSD < 10 doesn't have this function. In

+ mainline libusb, it's inlined in libusb.h. This function will bear a striking

+ resemblance to that one, because there's about one way to code it.

+#ifndef __ANDROID__ /* we don't use iconv on Android */

+ wchar_t wbuf[256];

+#endif

+#ifdef __ANDROID__

+

+ /* Bionic does not have iconv support nor wcsdup() function, so it

+ has to be done manually. The following code will only work for

+ code points that can be represented as a single UTF-16 character,

+ and will incorrectly convert any code points which require more

+ than one UTF-16 character.

+

+ Skip over the first character (2-bytes). */

+ len -= 2;

+ str = malloc((len / 2 + 1) * sizeof(wchar_t));

+ int i;

+ for (i = 0; i < len / 2; i++) {

+ str[i] = buf[i * 2 + 2] | (buf[i * 2 + 3] << 8);

+ }

+ str[len / 2] = 0x00000000;

+

+#else

+

+#endif

+

+hid_device * hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)

+ if (cur_dev->serial_number &&

+ wcscmp(serial_number, cur_dev->serial_number) == 0) {

+ the condition actually will go to sleep before the condition is

+ dev = new_hid_device();

+

+ /* Decide whether to use it for input or output. */

+ /* No interrupt out endpoint. Use the Control Endpoint */

+ GNU General Public License v3, a BSD-Style license, or the

+

+ If @p vendor_id is set to 0 then any vendor matches.

+ If @p product_id is set to 0 then any product matches.

+ HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number);

+ @param device A device handle returned from hid_open().

+ -1 on error. If no packet was available to be read within

+ the timeout period, this function returns 0.

+ -1 on error. If no packet was available to be read and

+ the handle is in non-blocking mode, this function returns 0.

+ Set the first byte of @p data[] to the Report ID of the

+ report to be read. Make sure to allow space for this

+ extra byte in @p data[]. Upon return, the first byte will

+ still contain the Report ID, and the report data will

+ start in data[1].

+ Report ID of the report to be read, or set it to zero

+ if your device does not use numbered reports.

+ This function returns the number of bytes read plus

+ one for the report ID (which is still in the first

+ byte), or -1 on error.

+ GNU General Public License v3, a BSD-Style license, or the

+#include <IOKit/IOKitLib.h>

+#include <dlfcn.h>

+static IOHIDManagerRef hid_mgr = 0x0;

+ CFStringRef str;

+ if (!len)

+ str = IOHIDDeviceGetProperty(device, prop);

+ buf[0] = 0;

+ CFIndex str_len = CFStringGetLength(str);

+ CFIndex chars_copied;

+

+ len --;

+

+ range.location = 0;

+ range.length = ((size_t)str_len > len)? len: (size_t)str_len;

+ chars_copied = CFStringGetBytes(str,

+ kCFStringEncodingUTF32LE,

+ len * sizeof(wchar_t),

+

+ if (chars_copied == len)

+ buf[len] = 0; /* len is decremented above */

+ else

+ buf[chars_copied] = 0;

+

+ return 0;

+ return -1;

+/* hidapi_IOHIDDeviceGetService()

+ *

+ * Return the io_service_t corresponding to a given IOHIDDeviceRef, either by:

+ * - on OS X 10.6 and above, calling IOHIDDeviceGetService()

+ * - on OS X 10.5, extract it from the IOHIDDevice struct

+ */

+static io_service_t hidapi_IOHIDDeviceGetService(IOHIDDeviceRef device)

+ static void *iokit_framework = NULL;

+ static io_service_t (*dynamic_IOHIDDeviceGetService)(IOHIDDeviceRef device) = NULL;

+

+ /* Use dlopen()/dlsym() to get a pointer to IOHIDDeviceGetService() if it exists.

+ * If any of these steps fail, dynamic_IOHIDDeviceGetService will be left NULL

+ * and the fallback method will be used.

+ */

+ if (iokit_framework == NULL) {

+ iokit_framework = dlopen("/System/Library/IOKit.framework/IOKit", RTLD_LAZY);

+

+ if (iokit_framework != NULL)

+ dynamic_IOHIDDeviceGetService = dlsym(iokit_framework, "IOHIDDeviceGetService");

+ }

+ if (dynamic_IOHIDDeviceGetService != NULL) {

+ /* Running on OS X 10.6 and above: IOHIDDeviceGetService() exists */

+ return dynamic_IOHIDDeviceGetService(device);

+ }

+ else

+ {

+ /* Running on OS X 10.5: IOHIDDeviceGetService() doesn't exist.

+ *

+ * Be naughty and pull the service out of the IOHIDDevice.

+ * IOHIDDevice is an opaque struct not exposed to applications, but its

+ * layout is stable through all available versions of OS X.

+ * Tested and working on OS X 10.5.8 i386, x86_64, and ppc.

+ */

+ struct IOHIDDevice_internal {

+ /* The first field of the IOHIDDevice struct is a

+ * CFRuntimeBase (which is a private CF struct).

+ *

+ * a, b, and c are the 3 fields that make up a CFRuntimeBase.

+ * See http://opensource.apple.com/source/CF/CF-476.18/CFRuntime.h

+ *

+ * The second field of the IOHIDDevice is the io_service_t we're looking for.

+ */

+ uintptr_t a;

+ uint8_t b[4];

+#if __LP64__

+ uint32_t c;

+#endif

+ io_service_t service;

+ };

+ struct IOHIDDevice_internal *tmp = (struct IOHIDDevice_internal *)device;

+ return tmp->service;

+ }

+/* Initialize the IOHIDManager. Return 0 for success and -1 for failure. */

+ if (hid_mgr) {

+ IOHIDManagerSetDeviceMatching(hid_mgr, NULL);

+ IOHIDManagerScheduleWithRunLoop(hid_mgr, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);

+ return 0;

+ }

+

+ return -1;

+/* Initialize the IOHIDManager if necessary. This is the public function, and

+ it is safe to call this function repeatedly. Return 0 for success and -1

+ for failure. */

+ return init_hid_manager();

+

+ /* Already initialized. */

+static void process_pending_events(void) {

+ SInt32 res;

+ do {

+ res = CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.001, FALSE);

+ } while(res != kCFRunLoopRunFinished && res != kCFRunLoopRunTimedOut);

+}

+

+ struct hid_device_info *root = NULL; /* return object */

+ if (hid_init() < 0)

+ return NULL;

+

+ /* give the IOHIDManager a chance to update itself */

+ process_pending_events();

+ IOHIDManagerSetDeviceMatching(hid_mgr, NULL);

+ if ((vendor_id == 0x0 || vendor_id == dev_vid) &&

+ (product_id == 0x0 || product_id == dev_pid)) {

+ io_object_t iokit_dev;

+ kern_return_t res;

+ io_string_t path;

+ /* VID/PID match. Create the record. */

+ /* Get the Usage Page and Usage for this device. */

+

+ /* Fill in the path (IOService plane) */

+ iokit_dev = hidapi_IOHIDDeviceGetService(dev);

+ res = IORegistryEntryGetPath(iokit_dev, kIOServicePlane, path);

+ if (res == KERN_SUCCESS)

+ cur_dev->path = strdup(path);

+ else

+ cur_dev->path = strdup("");

+hid_device * HID_API_EXPORT hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)

+ void *sender)

+ hid_device *d = context;

+ d->disconnected = 1;

+ CFRunLoopStop(d->run_loop);

+/* This gets called when the read_thread's run loop gets signaled by

+ CFRunLoopStop(dev->run_loop); /*TODO: CFRunLoopGetCurrent()*/

+ SInt32 code;

+ the condition actually will go to sleep before the condition is

+/* hid_open_path()

+ *

+ * path must be a valid path to an IOHIDDevice in the IOService plane

+ * Example: "IOService:/AppleACPIPlatformExpert/PCI0@0/AppleACPIPCI/EHC1@1D,7/AppleUSBEHCI/PLAYSTATION(R)3 Controller@fd120000/IOUSBInterface@0/IOUSBHIDDriver"

+ */

+ io_registry_entry_t entry = MACH_PORT_NULL;

+ if (hid_init() < 0)

+ return NULL;

+

+ /* Get the IORegistry entry for the given path */

+ entry = IORegistryEntryFromPath(kIOMasterPortDefault, path);

+ if (entry == MACH_PORT_NULL) {

+ /* Path wasn't valid (maybe device was removed?) */

+ goto return_error;

+ }

+ /* Create an IOHIDDevice for the entry */

+ dev->device_handle = IOHIDDeviceCreate(kCFAllocatorDefault, entry);

+ if (dev->device_handle == NULL) {

+ /* Error creating the HID device */

+ goto return_error;

+ }

+ /* Open the IOHIDDevice */

+ IOReturn ret = IOHIDDeviceOpen(dev->device_handle, kIOHIDOptionsTypeSeizeDevice);

+ if (ret == kIOReturnSuccess) {

+ char str[32];

+

+ /* Create the buffers for receiving data */

+ dev->max_input_report_len = (CFIndex) get_max_report_length(dev->device_handle);

+ dev->input_report_buf = calloc(dev->max_input_report_len, sizeof(uint8_t));

+

+ /* Create the Run Loop Mode for this device.

+ printing the reference seems to work. */

+ sprintf(str, "HIDAPI_%p", dev->device_handle);

+ dev->run_loop_mode =

+ CFStringCreateWithCString(NULL, str, kCFStringEncodingASCII);

+

+ /* Attach the device to a Run Loop */

+ IOHIDDeviceRegisterInputReportCallback(

+ dev->device_handle, dev->input_report_buf, dev->max_input_report_len,

+ &hid_report_callback, dev);

+ IOHIDDeviceRegisterRemovalCallback(dev->device_handle, hid_device_removal_callback, dev);

+

+ /* Start the read thread */

+ pthread_create(&dev->thread, NULL, read_thread, dev);

+

+ /* Wait here for the read thread to be initialized. */

+ pthread_barrier_wait(&dev->barrier);

+

+ IOObjectRelease(entry);

+ return dev;

+ }

+ else {

+ goto return_error;

+ if (dev->device_handle != NULL)

+ CFRelease(dev->device_handle);

+

+ if (entry != MACH_PORT_NULL)

+ IOObjectRelease(entry);

+

+ if (dev->disconnected)

+ return -1;

+ IOHIDDeviceRegisterRemovalCallback(dev->device_handle, NULL, dev);

+ IOHIDDeviceClose(dev->device_handle, kIOHIDOptionsTypeSeizeDevice);

+ CFRelease(dev->device_handle);

+ /* TODO: */

+ /* TODO: */

+

+

+ GNU General Public License v3, a BSD-Style license, or the

+/* The maximum number of characters that can be passed into the

+ HidD_Get*String() functions without it failing.*/

+#define MAX_STRING_WCHARS 0xFFF

+

+/*#define HIDAPI_USE_DDK*/

+ /* Copied from inc/ddk/hidclass.h, part of the Windows DDK. */

+} /* extern "C" */

+#undef MIN

+#define MIN(x,y) ((x) < (y)? (x): (y))

+

+ /* Thanks Microsoft, but I know how to use strncpy(). */

+ /* Since we're not building with the DDK, and the HID header

+ files aren't part of the SDK, we have to define all this

+ stuff here. In lookup_functions(), the function pointers

+ defined below are set. */

+ typedef void* PHIDP_PREPARSED_DATA;

+ #define HIDP_STATUS_SUCCESS 0x110000

+ typedef BOOLEAN (__stdcall *HidD_GetPreparsedData_)(HANDLE handle, PHIDP_PREPARSED_DATA *preparsed_data);

+ typedef BOOLEAN (__stdcall *HidD_FreePreparsedData_)(PHIDP_PREPARSED_DATA preparsed_data);

+ typedef NTSTATUS (__stdcall *HidP_GetCaps_)(PHIDP_PREPARSED_DATA preparsed_data, HIDP_CAPS *caps);

+ typedef BOOLEAN (__stdcall *HidD_SetNumInputBuffers_)(HANDLE handle, ULONG number_buffers);

+ static HidD_SetNumInputBuffers_ HidD_SetNumInputBuffers;

+#endif /* HIDAPI_USE_DDK */

+ USHORT output_report_length;

+ dev->output_report_length = 0;

+ dev->ol.hEvent = CreateEvent(NULL, FALSE, FALSE /*initial state f=nonsignaled*/, NULL);

+static void free_hid_device(hid_device *dev)

+{

+ CloseHandle(dev->ol.hEvent);

+ CloseHandle(dev->device_handle);

+ LocalFree(dev->last_error_str);

+ free(dev->read_buf);

+ free(dev);

+}

+ (LPVOID)&msg, 0/*sz*/,

+

+ /* Get rid of the CR and LF that FormatMessage() sticks at the

+ end of the message. Thanks Microsoft! */

+ /* Store the message off in the Device entry so that

+ the hid_error() function can pick it up. */

+ RESOLVE(HidD_SetNumInputBuffers);

+static HANDLE open_device(const char *path, BOOL enumerate)

+ DWORD desired_access = (enumerate)? 0: (GENERIC_WRITE | GENERIC_READ);

+ DWORD share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;

+ desired_access,

+ share_mode,

+ FILE_FLAG_OVERLAPPED,/*FILE_ATTRIBUTE_NORMAL,*/

+ struct hid_device_info *root = NULL; /* return object */

+ /* Windows objects for interacting with the driver. */

+ int i;

+ /* Initialize the Windows objects. */

+ memset(&devinfo_data, 0x0, sizeof(devinfo_data));

+ /* Get information for all the devices belonging to the HID class. */

+

+ /* Iterate over each device in the HID class, looking for the right one. */

+

+

+ /* A return of FALSE from this function means that

+ there are no more devices. */

+ /* Call with 0-sized detail size, and let the function

+ tell us how long the detail struct needs to be. The

+ size is put in &required_size. */

+ /* Allocate a long enough structure for device_interface_detail_data. */

+ /* Get the detailed data for this device. The detail data gives us

+ the device path for this device, which is then passed into

+ CreateFile() to get a handle to the device. */

+ /* register_error(dev, "Unable to call SetupDiGetDeviceInterfaceDetail");

+ Continue to the next device. */

+ /* Make sure this device is of Setup Class "HIDClass" and has a

+ driver bound to it. */

+ for (i = 0; ; i++) {

+ char driver_name[256];

+

+ /* Populate devinfo_data. This function will return failure

+ when there are no more interfaces left. */

+ res = SetupDiEnumDeviceInfo(device_info_set, i, &devinfo_data);

+ if (!res)

+ goto cont;

+

+ res = SetupDiGetDeviceRegistryPropertyA(device_info_set, &devinfo_data,

+ SPDRP_CLASS, NULL, (PBYTE)driver_name, sizeof(driver_name), NULL);

+ if (!res)

+ goto cont;

+

+ if (strcmp(driver_name, "HIDClass") == 0) {

+ /* See if there's a driver bound. */

+ res = SetupDiGetDeviceRegistryPropertyA(device_info_set, &devinfo_data,

+ SPDRP_DRIVER, NULL, (PBYTE)driver_name, sizeof(driver_name), NULL);

+ if (res)

+ break;

+ }

+ }

+

+ /* Open a handle to the device */

+ write_handle = open_device(device_interface_detail_data->DevicePath, TRUE);

+ /* Check validity of write_handle. */

+ /* Unable to open the device. */

+ }

+ /* Get the Vendor ID and Product ID for this device. */

+ /* Check the VID/PID to see if we should add this

+ device to the enumeration list. */

+ if ((vendor_id == 0x0 || attrib.VendorID == vendor_id) &&

+ (product_id == 0x0 || attrib.ProductID == product_id)) {

+ PHIDP_PREPARSED_DATA pp_data = NULL;

+ wchar_t wstr[WSTR_LEN]; /* TODO: Determine Size */

+ /* Get the Usage Page and Usage for this device. */

+

+ /* We no longer need the detail data. It can be freed */

+ /* Close the device information handle. */

+ /* TODO: Merge this with the Linux version. This function is platform-independent. */

+HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number)

+ /* TODO: Merge this functions with the Linux version. This function should be platform independent. */

+

+

+ PHIDP_PREPARSED_DATA pp_data = NULL;

+ /* Open a handle to the device */

+ dev->device_handle = open_device(path, FALSE);

+ /* Check validity of write_handle. */

+ /* Unable to open the device. */

+ /* Set the Input Report buffer size to 64 reports. */

+ res = HidD_SetNumInputBuffers(dev->device_handle, 64);

+ if (!res) {

+ register_error(dev, "HidD_SetNumInputBuffers");

+ goto err;

+ }

+

+ /* Get the Input Report length for the device. */

+ register_error(dev, "HidP_GetCaps");

+ dev->output_report_length = caps.OutputReportByteLength;

+err:

+ free_hid_device(dev);

+ unsigned char *buf;

+ /* Make sure the right number of bytes are passed to WriteFile. Windows

+ expects the number of bytes which are in the _longest_ report (plus

+ one for the report number) bytes even if the data is a report

+ which is shorter than that. Windows gives us this value in

+ caps.OutputReportByteLength. If a user passes in fewer bytes than this,

+ create a temporary buffer which is the proper size. */

+ if (length >= dev->output_report_length) {

+ /* The user passed the right number of bytes. Use the buffer as-is. */

+ buf = (unsigned char *) data;

+ } else {

+ /* Create a temporary buffer and copy the user's data

+ into it, padding the rest with zeros. */

+ buf = (unsigned char *) malloc(dev->output_report_length);

+ memcpy(buf, data, length);

+ memset(buf + length, 0, dev->output_report_length - length);

+ length = dev->output_report_length;

+ }

+ res = WriteFile(dev->device_handle, buf, length, NULL, &ol);

+

+ /* WriteFile() failed. Return error. */

+ bytes_written = -1;

+ goto end_of_function;

+ /* Wait here until the write is done. This makes

+ hid_write() synchronous. */

+ /* The Write operation failed. */

+ bytes_written = -1;

+ goto end_of_function;

+end_of_function:

+ if (buf != data)

+ free(buf);

+

+ size_t copy_len = 0;

+ /* Copy the handle for convenience. */

+ /* Start an Overlapped I/O read. */

+ memset(dev->read_buf, 0, dev->input_report_length);

+

+ /* ReadFile() has failed.

+ Clean up and return error. */

+ /* See if there is any data yet. */

+ /* There was no data this time. Return zero bytes available,

+ but leave the Overlapped I/O running. */

+ /* Either WaitForSingleObject() told us that ReadFile has completed, or

+ we are in non-blocking mode. Get the number of bytes read. The actual

+ data has been copied to the data[] array which was passed to ReadFile(). */

+

+ /* Set pending back to false, even if GetOverlappedResult() returned error. */

+ copy_len = length > bytes_read ? bytes_read : length;

+ memcpy(data, dev->read_buf+1, copy_len);

+ copy_len = length > bytes_read ? bytes_read : length;

+ memcpy(data, dev->read_buf, copy_len);

+

+

+ return copy_len;

+ /* DeviceIoControl() failed. Return error. */

+ /* Wait here until the write is done. This makes

+ hid_get_feature_report() synchronous. */

+ /* The operation failed. */

+

+ /* bytes_returned does not include the first byte which contains the

+ report ID. The data buffer actually contains one more byte than

+ bytes_returned. */

+ bytes_returned++;

+

+ free_hid_device(dev);

+ res = HidD_GetManufacturerString(dev->device_handle, string, sizeof(wchar_t) * MIN(maxlen, MAX_STRING_WCHARS));

+ res = HidD_GetProductString(dev->device_handle, string, sizeof(wchar_t) * MIN(maxlen, MAX_STRING_WCHARS));

+ res = HidD_GetSerialNumberString(dev->device_handle, string, sizeof(wchar_t) * MIN(maxlen, MAX_STRING_WCHARS));

+ res = HidD_GetIndexedString(dev->device_handle, string_index, string, sizeof(wchar_t) * MIN(maxlen, MAX_STRING_WCHARS));

+/*#define PICPGM*/

+/*#define S11*/

+#ifdef S11

+ /* Set up the command buffer. */

+

+ /* Open the device. */

+ /* Toggle LED (cmd 0x80) */

+ /* Request state (cmd 0x81) */

+ /* Read requested state */

+ /* Print out the returned buffer. */

+} /* extern "C" */