From: Alexander Ponyatykh Date: Fri, 15 Nov 2019 08:46:54 +0300 Subject: Migrate from legacy libusb-0.1 to libusb-1.0 --- configure.in | 5 +- libg15.c | 476 +++++++++++++++++++++++++++++------------------------------ 2 files changed, 234 insertions(+), 247 deletions(-) --- a/configure.in +++ b/configure.in @@ -31,7 +31,8 @@ esac # Checks for libraries. -AC_CHECK_LIB([usb], [main], ,AC_MSG_ERROR(["libusb not found. please install it"])) +AC_CHECK_LIB([usb-1.0], [main], ,AC_MSG_ERROR(["libusb-1.0 not found. Please install it."])) +AC_CHECK_LIB([usb-1.0], [libusb_set_option], ,AC_MSG_ERROR(["libusb-1.0 is too old. Please upgrade to version 1.0.22 or later."])) dnl Some versions of libusb do not honour timeout and block. Suns' version is one of them. if test "x$libusb_blocks" == "xtrue"; then @@ -41,7 +42,7 @@ # Checks for header files. AC_HEADER_STDC AC_CHECK_HEADERS([string.h]) -AC_CHECK_HEADERS([usb.h]) +AC_CHECK_HEADERS([libusb-1.0/libusb.h]) # Checks for typedefs, structures, and compiler characteristics. AC_C_CONST --- a/libg15.c +++ b/libg15.c @@ -24,20 +24,21 @@ #include "libg15.h" #include #include -#include +#include #include #include +#include #include "config.h" -static usb_dev_handle *keyboard_device = 0; +static libusb_device_handle *keyboard_device = 0; static int libg15_debugging_enabled = 0; -static int enospc_slowdown = 0; static int found_devicetype = -1; static int shared_device = 0; static int g15_keys_endpoint = 0; static int g15_lcd_endpoint = 0; static pthread_mutex_t libusb_mutex; +static libusb_context *libg15_libusb_context = NULL; /* to add a new device, simply create a new DEVICE() in this list */ /* Fields are: "Name",VendorID,ProductID,Capabilities */ @@ -67,7 +68,9 @@ void libg15Debug(int option) { libg15_debugging_enabled = option; - usb_set_debug(option); + if (option && libg15_libusb_context) { + libusb_set_option(libg15_libusb_context, LIBUSB_OPTION_LOG_LEVEL, LIBUSB_LOG_LEVEL_WARNING); + } } /* debugging wrapper */ @@ -86,191 +89,207 @@ /* return number of connected and supported devices */ int g15NumberOfConnectedDevices() { - struct usb_bus *bus = 0; - struct usb_device *dev = 0; - int i=0; + struct libusb_device_descriptor desc; + libusb_device **list; unsigned int found = 0; - for (i=0; g15_devices[i].name !=NULL;i++) - for (bus = usb_busses; bus; bus = bus->next) + ssize_t cnt = libusb_get_device_list(libg15_libusb_context, &list); + + if (cnt < 0) + { + g15_log(stderr, G15_LOG_INFO, "Unable to list USB devices: %s\n", libusb_strerror(cnt)); + return 0; + } + + for (ssize_t i = 0; i < cnt; i++) { - for (dev = bus->devices; dev; dev = dev->next) + libusb_get_device_descriptor(list[i], &desc); + + for (int j = 0; g15_devices[i].name != NULL; j++) { - if ((dev->descriptor.idVendor == g15_devices[i].vendorid && dev->descriptor.idProduct == g15_devices[i].productid)) + if ((desc.idVendor == g15_devices[j].vendorid && desc.idProduct == g15_devices[j].productid)) found++; + break; } } + + libusb_free_device_list(list, 1); + g15_log(stderr,G15_LOG_INFO,"Found %i supported devices\n",found); return found; } static int initLibUsb() { - usb_init(); + int errcode = libusb_init(&libg15_libusb_context); - /** - * usb_find_busses and usb_find_devices both report the number of devices - * / busses added / removed since the last call. since this is the first - * call we have to return values != 0 or else we didnt find anything */ - - if (!usb_find_busses()) + if (errcode != 0) + { + g15_log(stderr, G15_LOG_INFO, "Failed to initialize libusb-1.0: %s\n", libusb_strerror(errcode)); return G15_ERROR_OPENING_USB_DEVICE; + } - if (!usb_find_devices()) - return G15_ERROR_OPENING_USB_DEVICE; + libg15Debug(libg15_debugging_enabled); return G15_NO_ERROR; } -static usb_dev_handle * findAndOpenDevice(libg15_devices_t handled_device, int device_index) +static libusb_device_handle * findAndOpenDevice(libg15_devices_t handled_device, int device_index) { - struct usb_bus *bus = 0; - struct usb_device *dev = 0; - int retries=0; - int j,i,k,l; - int interface=0; + struct libusb_device_descriptor desc; + libusb_device_handle *devh = 0; + libusb_device **list = 0; + libusb_device *dev = 0; + int interface = 0; + int retries = 0; + int ret; + + ssize_t cnt = libusb_get_device_list(libg15_libusb_context, &list); - for (bus = usb_busses; bus; bus = bus->next) + if (cnt < 0) { - for (dev = bus->devices; dev; dev = dev->next) + g15_log(stderr, G15_LOG_INFO, "Unable to list USB devices: %s\n", libusb_strerror(cnt)); + return 0; + } + + for (ssize_t devno = 0; devno < cnt; devno++) + { + libusb_get_device_descriptor(list[devno], &desc); + if (desc.idVendor == handled_device.vendorid && desc.idProduct == handled_device.productid) { - if ((dev->descriptor.idVendor == handled_device.vendorid && dev->descriptor.idProduct == handled_device.productid)) - { - int ret=0; - char name_buffer[65535]; - name_buffer[0] = 0; - usb_dev_handle *devh = 0; - found_devicetype = device_index; - g15_log(stderr,G15_LOG_INFO,"Found %s, trying to open it\n",handled_device.name); -#if 0 - devh = usb_open(dev); - usb_reset(devh); - usleep(50*1000); - usb_close(devh); -#endif - devh = usb_open(dev); - if (!devh) - { - g15_log(stderr,G15_LOG_INFO, "Error, could not open the keyboard\n"); - g15_log(stderr,G15_LOG_INFO, "Perhaps you don't have enough permissions to access it\n"); - return 0; - } + dev = list[devno]; + break; + } + } + + if (!dev) { + libusb_free_device_list(list, 1); + return 0; + } + + found_devicetype = device_index; + + g15_log(stderr,G15_LOG_INFO,"Found %s, trying to open it\n",handled_device.name); - usleep(50*1000); + ret = libusb_open(dev, &devh); + libusb_free_device_list(list, 1); - g15_log(stderr, G15_LOG_INFO, "Device has %i possible configurations\n",dev->descriptor.bNumConfigurations); + if (ret || !devh) + { + g15_log(stderr,G15_LOG_INFO, "Error, could not open the keyboard: %s\n", libusb_strerror(ret)); + return 0; + } + + usleep(50*1000); + + g15_log(stderr, G15_LOG_INFO, "Device has %i possible configurations\n", desc.bNumConfigurations); - /* if device is shared with another driver, such as the Z-10 speakers sharing with alsa, we have to disable some calls */ - if(g15DeviceCapabilities() & G15_DEVICE_IS_SHARED) - shared_device = 1; + /* if device is shared with another driver, such as the Z-10 speakers sharing with alsa, we have to disable some calls */ + if(g15DeviceCapabilities() & G15_DEVICE_IS_SHARED) + shared_device = 1; - for (j = 0; jdescriptor.bNumConfigurations;j++){ - struct usb_config_descriptor *cfg = &dev->config[j]; + for (int j = 0; j < desc.bNumConfigurations; j++) + { + struct libusb_config_descriptor *cfg; + if (libusb_get_config_descriptor(dev, j, &cfg)) continue; + + for (int i = 0; i < cfg->bNumInterfaces; i++) + { + if (g15DeviceCapabilities() & G15_DEVICE_G510) + { + if (i==G510_STANDARD_KEYBOARD_INTERFACE) continue; + } - for (i=0;ibNumInterfaces; i++){ - if (g15DeviceCapabilities()&G15_DEVICE_G510){ - if (i==G510_STANDARD_KEYBOARD_INTERFACE) continue; + const struct libusb_interface *ifp = &cfg->interface[i]; + /* if endpoints are already known, finish up */ + if (g15_keys_endpoint && g15_lcd_endpoint) + break; + g15_log(stderr, G15_LOG_INFO, "Device has %i Alternate Settings\n", ifp->num_altsetting); + + for (int k=0; k < ifp->num_altsetting; k++) + { + const struct libusb_interface_descriptor *as = &ifp->altsetting[k]; + /* verify that the interface is for a HID device */ + if (as->bInterfaceClass == LIBUSB_CLASS_HID) + { + g15_log(stderr, G15_LOG_INFO, "Interface %i has %i Endpoints\n", i, as->bNumEndpoints); + usleep(50*1000); + + if (libusb_kernel_driver_active(devh, i) == 1) + { + g15_log(stderr, G15_LOG_INFO, "Trying to detach driver currently attached.\n"); + + ret = libusb_detach_kernel_driver(devh, i); + if (!ret) + { + g15_log(stderr,G15_LOG_INFO,"Success, detached the driver\n"); + } + else + { + g15_log(stderr,G15_LOG_INFO,"Could not detach the driver, giving up: %s\n", libusb_strerror(ret)); + break; } - struct usb_interface *ifp = &cfg->interface[i]; - /* if endpoints are already known, finish up */ - if(g15_keys_endpoint && g15_lcd_endpoint) - break; - g15_log(stderr, G15_LOG_INFO, "Device has %i Alternate Settings\n", ifp->num_altsetting); - - for(k=0;knum_altsetting;k++){ - struct usb_interface_descriptor *as = &ifp->altsetting[k]; - /* verify that the interface is for a HID device */ - if(as->bInterfaceClass==USB_CLASS_HID){ - g15_log(stderr, G15_LOG_INFO, "Interface %i has %i Endpoints\n", i, as->bNumEndpoints); - usleep(50*1000); - /* libusb functions ending in _np are not portable between OS's - * Non-linux users will need some way to detach the HID driver from - * the G15 until we work out how to do this for other OS's automatically. - * For the moment, we just skip this code.. - */ -#ifdef LIBUSB_HAS_GET_DRIVER_NP - ret = usb_get_driver_np(devh, i, name_buffer, 65535); - /* some kernel versions say that a driver is attached even though there is none - in this case the name buffer has not been changed - thanks to RobEngle for pointing this out */ - if (!ret && name_buffer[0]) - { - g15_log(stderr,G15_LOG_INFO,"Trying to detach driver currently attached: \"%s\"\n",name_buffer); - - ret = usb_detach_kernel_driver_np(devh, i); - if (!ret) - { - g15_log(stderr,G15_LOG_INFO,"Success, detached the driver\n"); - } - else - { - g15_log(stderr,G15_LOG_INFO,"Sorry, I could not detach the driver, giving up\n"); - return 0; - } - - } -#endif - /* don't set configuration if device is shared */ - if(0 == shared_device) { - ret = usb_set_configuration(devh, 1); - if (ret) - { - g15_log(stderr,G15_LOG_INFO,"Error setting the configuration, this is fatal\n"); - return 0; - } - } - usleep(50*1000); - while((ret = usb_claim_interface(devh,i)) && retries <10) { - usleep(50*1000); - retries++; - g15_log(stderr,G15_LOG_INFO,"Trying to claim interface\n"); - } - - if (ret) - { - g15_log(stderr,G15_LOG_INFO,"Error claiming interface, good day cruel world\n"); - return 0; - } - - for (l=0; l< as->bNumEndpoints;l++){ - struct usb_endpoint_descriptor *ep=&as->endpoint[l]; - g15_log(stderr, G15_LOG_INFO, "Found %s endpoint %i with address 0x%X maxtransfersize=%i \n", - 0x80&ep->bEndpointAddress?"\"Extra Keys\"":"\"LCD\"", - ep->bEndpointAddress&0x0f,ep->bEndpointAddress, ep->wMaxPacketSize - ); - - if(0x80 & ep->bEndpointAddress) { - g15_keys_endpoint = ep->bEndpointAddress; - } else { - g15_lcd_endpoint = ep->bEndpointAddress; - } -#if 0 - usb_resetep(devh,ep->bEndpointAddress); -#endif - } - - if (ret) - { - g15_log(stderr, G15_LOG_INFO, "Error setting Alternate Interface\n"); - } - } + } + /* don't set configuration if device is shared */ + if (0 == shared_device) { + ret = libusb_set_configuration(devh, 1); + if (ret) + { + g15_log(stderr,G15_LOG_INFO,"Error setting the configuration, this is fatal: %s\n", libusb_strerror(ret)); + break; } } - } + usleep(50*1000); + while((ret = libusb_claim_interface(devh,i)) && retries <10) { + usleep(50*1000); + retries++; + g15_log(stderr,G15_LOG_INFO,"Trying to claim interface\n"); + } + if (ret) + { + g15_log(stderr,G15_LOG_INFO,"Error claiming interface, good day cruel world: %s\n", libusb_strerror(ret)); + break; + } - g15_log(stderr,G15_LOG_INFO,"Done opening the keyboard\n"); - usleep(500*1000); // sleep a bit for good measure - return devh; + for (int l = 0; l < as->bNumEndpoints; l++) + { + const struct libusb_endpoint_descriptor *ep=&as->endpoint[l]; + g15_log(stderr, G15_LOG_INFO, "Found %s endpoint %i with address 0x%X maxtransfersize=%i \n", + 0x80&ep->bEndpointAddress?"\"Extra Keys\"":"\"LCD\"", + ep->bEndpointAddress&0x0f,ep->bEndpointAddress, ep->wMaxPacketSize + ); + + if(0x80 & ep->bEndpointAddress) + { + g15_keys_endpoint = ep->bEndpointAddress; + } else { + g15_lcd_endpoint = ep->bEndpointAddress; + } + } + } } } + + libusb_free_config_descriptor(cfg); + } + + if (g15_keys_endpoint || g15_lcd_endpoint) { + g15_log(stderr,G15_LOG_INFO,"Done opening the keyboard\n"); + usleep(500*1000); // sleep a bit for good measure + return devh; + } else { + found_devicetype = -1; + libusb_release_interface(devh, 0); + libusb_attach_kernel_driver(devh, 0); + libusb_close(devh); + return 0; } - return 0; } -static usb_dev_handle * findAndOpenG15() { +static libusb_device_handle * findAndOpenG15() { int i; for (i=0; g15_devices[i].name !=NULL ;i++){ g15_log(stderr,G15_LOG_INFO,"Trying to find %s\n",g15_devices[i].name); @@ -288,19 +307,13 @@ { int retval = G15_NO_ERROR; - enospc_slowdown = shared_device = g15_keys_endpoint = g15_lcd_endpoint = 0; + shared_device = g15_keys_endpoint = g15_lcd_endpoint = 0; found_devicetype = -1; - if (keyboard_device){ -#ifndef SUN_LIBUSB - retval = usb_release_interface (keyboard_device, 0); - usleep(50*1000); -#endif -#if 0 - retval = usb_reset(keyboard_device); - usleep(50*1000); -#endif - usb_close(keyboard_device); + if (keyboard_device) { + retval = libusb_release_interface(keyboard_device, 0); + libusb_attach_kernel_driver(keyboard_device, 0); + libusb_close(keyboard_device); keyboard_device=0; return retval; } @@ -311,9 +324,6 @@ { closeKeyboardDevice(); - usb_find_busses(); - usb_find_devices(); - keyboard_device = findAndOpenG15(); if (!keyboard_device) return G15_ERROR_OPENING_USB_DEVICE; @@ -330,10 +340,6 @@ g15_log(stderr,G15_LOG_INFO,"%s\n",PACKAGE_STRING); -#ifdef SUN_LIBUSB - g15_log(stderr,G15_LOG_INFO,"Using Sun libusb.\n"); -#endif - g15NumberOfConnectedDevices(); keyboard_device = findAndOpenG15(); @@ -347,7 +353,9 @@ int exitLibG15() { pthread_mutex_destroy(&libusb_mutex); - return closeKeyboardDevice(); + int ret = closeKeyboardDevice(); + libusb_exit(libg15_libusb_context); + libg15_libusb_context = NULL; } static void dumpPixmapIntoLCDFormat(unsigned char *lcd_buffer, unsigned char const *data) @@ -428,36 +436,6 @@ } } -int handle_usb_errors(const char *prefix, int ret) { - - switch (ret){ - case -ETIMEDOUT: - return G15_ERROR_READING_USB_DEVICE; /* backward-compatibility */ - break; - case -ENOSPC: /* the we don't have enough bandwidth, apparently.. something has to give here.. */ - g15_log(stderr,G15_LOG_INFO,"usb error: ENOSPC.. reducing speed\n"); - enospc_slowdown = 1; - break; - case -ENODEV: /* the device went away - we probably should attempt to reattach */ - case -ENXIO: /* host controller bug */ - case -EINVAL: /* invalid request */ - case -EAGAIN: /* try again */ - case -EFBIG: /* too many frames to handle */ - case -EMSGSIZE: /* msgsize is invalid */ - g15_log(stderr,G15_LOG_INFO,"usb error: %s %s (%i)\n",prefix,usb_strerror(),ret); - break; - case -EPIPE: /* endpoint is stalled */ - g15_log(stderr,G15_LOG_INFO,"usb error: %s EPIPE! clearing...\n",prefix); - pthread_mutex_lock(&libusb_mutex); - usb_clear_halt(keyboard_device, 0x81); - pthread_mutex_unlock(&libusb_mutex); - break; - default: /* timed out */ - g15_log(stderr,G15_LOG_INFO,"Unknown usb error: %s !! (err is %i (%s))\n",prefix,ret,usb_strerror()); - } - return ret; -} - int writePixmapToLCD(unsigned char const *data) { int ret = 0; @@ -474,43 +452,27 @@ /* the keyboard needs this magic byte */ lcd_buffer[0] = 0x03; - /* in an attempt to reduce peak bus utilisation, we break the transfer into 32 byte chunks and sleep a bit in between. - It shouldnt make much difference, but then again, the g15 shouldnt be flooding the bus enough to cause ENOSPC, yet - apparently does on some machines... - I'm not sure how successful this will be in combatting ENOSPC, but we'll give it try in the real-world. */ - - if(enospc_slowdown != 0){ -#ifndef LIBUSB_BLOCKS - pthread_mutex_lock(&libusb_mutex); -#endif - for(transfercount = 0;transfercount<=31;transfercount++){ - ret = usb_interrupt_write(keyboard_device, g15_lcd_endpoint, (char*)lcd_buffer+(32*transfercount), 32, 1000); - if (ret != 32) - { - handle_usb_errors ("LCDPixmap Slow Write",ret); - return G15_ERROR_WRITING_PIXMAP; - } - usleep(100); + + /* transfer entire buffer in one hit */ + int transferred = 0; + pthread_mutex_lock(&libusb_mutex); + ret = libusb_interrupt_transfer(keyboard_device, g15_lcd_endpoint, (char*)lcd_buffer, G15_BUFFER_LEN, &transferred, 1000); + pthread_mutex_unlock(&libusb_mutex); + if (ret || transferred != G15_BUFFER_LEN) + { + if (!ret) { + g15_log(stderr,G15_LOG_INFO,"LCDPixmap write error: short write.\n"); + } else { + g15_log(stderr,G15_LOG_INFO,"LCDPixmap write error: %s.\n", libusb_strerror(ret)); } -#ifndef LIBUSB_BLOCKS - pthread_mutex_unlock(&libusb_mutex); -#endif - }else{ - /* transfer entire buffer in one hit */ -#ifdef LIBUSB_BLOCKS - ret = usb_interrupt_write(keyboard_device, g15_lcd_endpoint, (char*)lcd_buffer, G15_BUFFER_LEN, 1000); -#else - pthread_mutex_lock(&libusb_mutex); - ret = usb_interrupt_write(keyboard_device, g15_lcd_endpoint, (char*)lcd_buffer, G15_BUFFER_LEN, 1000); - pthread_mutex_unlock(&libusb_mutex); -#endif - if (ret != G15_BUFFER_LEN) - { - handle_usb_errors ("LCDPixmap Write",ret); - return G15_ERROR_WRITING_PIXMAP; + if (ret == LIBUSB_ERROR_PIPE) { + pthread_mutex_lock(&libusb_mutex); + libusb_clear_halt(keyboard_device, g15_lcd_endpoint); + pthread_mutex_unlock(&libusb_mutex); } - usleep(100); + return G15_ERROR_WRITING_PIXMAP; } + usleep(100); return 0; } @@ -535,7 +497,9 @@ usb_data[3] = 18; } pthread_mutex_lock(&libusb_mutex); - retval = usb_control_msg(keyboard_device, USB_TYPE_CLASS + USB_RECIP_INTERFACE, 9, 0x302, 0, (char*)usb_data, 4, 10000); + retval = libusb_control_transfer(keyboard_device, + LIBUSB_REQUEST_TYPE_CLASS + LIBUSB_RECIPIENT_INTERFACE + LIBUSB_ENDPOINT_OUT, + 9, 0x302, 0, (char*)usb_data, 4, 10000); pthread_mutex_unlock(&libusb_mutex); return retval; } @@ -553,7 +517,9 @@ return G15_ERROR_UNSUPPORTED; pthread_mutex_lock(&libusb_mutex); - retval = usb_control_msg(keyboard_device, USB_TYPE_CLASS + USB_RECIP_INTERFACE, 9, 0x302, 0, (char*)m_led_buf, 4, 10000); + retval = libusb_control_transfer(keyboard_device, + LIBUSB_REQUEST_TYPE_CLASS + LIBUSB_RECIPIENT_INTERFACE + LIBUSB_ENDPOINT_OUT, + 9, 0x302, 0, (char*)m_led_buf, 4, 10000); pthread_mutex_unlock(&libusb_mutex); return retval; } @@ -578,7 +544,9 @@ usb_data[2] = 0x00; } pthread_mutex_lock(&libusb_mutex); - retval = usb_control_msg(keyboard_device, USB_TYPE_CLASS + USB_RECIP_INTERFACE, 9, 0x302, 0, (char*)usb_data, 4, 10000); + retval = libusb_control_transfer(keyboard_device, + LIBUSB_REQUEST_TYPE_CLASS + LIBUSB_RECIPIENT_INTERFACE + LIBUSB_ENDPOINT_OUT, + 9, 0x302, 0, (char*)usb_data, 4, 10000); pthread_mutex_unlock(&libusb_mutex); return retval; } @@ -604,7 +572,9 @@ usb_data[2] = 0x0; } pthread_mutex_lock(&libusb_mutex); - retval = usb_control_msg(keyboard_device, USB_TYPE_CLASS + USB_RECIP_INTERFACE, 9, 0x302, 0, (char*)usb_data, 4, 10000); + retval = libusb_control_transfer(keyboard_device, + LIBUSB_REQUEST_TYPE_CLASS + LIBUSB_RECIPIENT_INTERFACE + LIBUSB_ENDPOINT_OUT, + 9, 0x302, 0, (char*)usb_data, 4, 10000); pthread_mutex_unlock(&libusb_mutex); return retval; } @@ -619,7 +589,9 @@ usb_data[3] = b; pthread_mutex_lock(&libusb_mutex); - retval = usb_control_msg(keyboard_device, USB_TYPE_CLASS + USB_RECIP_INTERFACE, 9, 0x305, 1, (char*)usb_data, 4, 10000); + retval = libusb_control_transfer(keyboard_device, + LIBUSB_REQUEST_TYPE_CLASS + LIBUSB_RECIPIENT_INTERFACE + LIBUSB_ENDPOINT_OUT, + 9, 0x305, 1, (char*)usb_data, 4, 10000); pthread_mutex_unlock(&libusb_mutex); return retval; } @@ -1033,18 +1005,30 @@ int getPressedKeys(unsigned int *pressed_keys, unsigned int timeout) { unsigned char buffer[G15_KEY_READ_LENGTH]; + int transferred = 0; int ret = 0; int caps = 0; -#ifdef LIBUSB_BLOCKS - ret = usb_interrupt_read(keyboard_device, g15_keys_endpoint, (char*)buffer, G15_KEY_READ_LENGTH, timeout); -#else pthread_mutex_lock(&libusb_mutex); - ret = usb_interrupt_read(keyboard_device, g15_keys_endpoint, (char*)buffer, G15_KEY_READ_LENGTH, timeout); + ret = libusb_interrupt_transfer(keyboard_device, g15_keys_endpoint, (char*)buffer, G15_KEY_READ_LENGTH, &transferred, timeout); pthread_mutex_unlock(&libusb_mutex); -#endif - if(ret>0) { - if(buffer[0] == 1) + + switch (ret) + { + case 0: + break; + case LIBUSB_ERROR_TIMEOUT: + return G15_ERROR_TIMEOUT; + case LIBUSB_ERROR_PIPE: + pthread_mutex_lock(&libusb_mutex); + libusb_clear_halt(keyboard_device, g15_keys_endpoint); + pthread_mutex_unlock(&libusb_mutex); + //no break + default: + g15_log(stderr,G15_LOG_INFO,"USB error on keybaord read: %s.\n", libusb_strerror(ret)); + } + + if (transferred > 0 && buffer[0] == 1) { return G15_ERROR_TRY_AGAIN; } @@ -1054,7 +1038,7 @@ return G15_NO_ERROR; } - switch(ret) { + switch(transferred) { case 4: processKeyEvent4Byte(pressed_keys, buffer); return G15_NO_ERROR; @@ -1065,6 +1049,6 @@ processKeyEvent9Byte(pressed_keys, buffer); return G15_NO_ERROR; default: - return handle_usb_errors("Keyboard Read", ret); /* allow the app to deal with errors */ + return G15_ERROR_READING_USB_DEVICE; } }