CMakeLists.txt

@@ -1,14 +1,11 @@
 cmake_minimum_required(VERSION 3.20)
 
-project(eismultiplexer C)
+project(eismultiplexer)
 
 find_package(PkgConfig REQUIRED)
 find_package(Doxygen)
 pkg_check_modules(LIBUSB REQUIRED libusb-1.0)
 
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_C_STANDARD 11)
-
 set(SRC_FILES eismultiplexer.c usbshm.c)
 
 message("Platform " ${CMAKE_SYSTEM_NAME})

README.md

@@ -1,5 +1,3 @@
-[comment]: \page README Readme
-
 # libeismultiplexer
 
 libeismultiplexer is a shared library that allows you to control EISmultiplexer devices.

doc/libeismulitplexer.doxygen.in

@@ -864,7 +864,7 @@ WARN_LOGFILE           =
 # spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
 # Note: If this tag is empty the current directory is searched.
 
-INPUT                  = @CMAKE_CURRENT_SOURCE_DIR@/eismultiplexer.h @CMAKE_CURRENT_SOURCE_DIR@/doc/mainpage.txt @CMAKE_CURRENT_SOURCE_DIR@/README.md
+INPUT                  = @CMAKE_CURRENT_SOURCE_DIR@/eismultiplexer.h @CMAKE_CURRENT_SOURCE_DIR@/doc/mainpage.txt
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses

doc/mainpage.txt

@@ -1,6 +1,6 @@
 /*! \mainpage libeismultiplexer manual
 
-libeismultiplexer is a shared library that allows you to control EISmultiplexer devices. For build instructions please see the \ref README.
+libeismultiplexer is a shared library that allows you to control EISmultiplexer devices
 
 An API reference can be found here: \subpage API
 

eismultiplexer.c

@@ -34,20 +34,12 @@
 #include <time.h>
 #include <stdio.h>
 
-uint16_t* eismultiplexer_list_available_devices(size_t* count)
+static void usleep(uint64_t microseconds)
 {
-	struct usbshm shm = {};
+	struct timespec ts;
-	*count = 0;
+	ts.tv_sec = microseconds / 1000000;
-	unsigned char** serials;
+	ts.tv_nsec = (microseconds % 1000000) * 1000;
-	int ret = usbshm_find(&shm, 0xfe17, 0x07dc, &serials, count);
+	nanosleep(&ts, NULL);
-	usbshm_close(&shm);
-	if(ret < 0 || *count == 0)
-		return NULL;
-	uint16_t* numeric_serials = malloc(sizeof(*numeric_serials)*(*count));
-	for(size_t i = 0; i < *count; ++i) {
-		numeric_serials[i] = atoi((char*)serials[i]);
-	}
-	return numeric_serials;
 }
 
 int eismultiplexer_connect(struct eismultiplexer* muliplexer, uint16_t serial)
@@ -57,6 +49,10 @@ int eismultiplexer_connect(struct eismultiplexer* muliplexer, uint16_t serial)
 	if(!muliplexer->priv)
 		return -1;
 	
+	ret = usbshm_init(muliplexer->priv, NULL, muliplexer);
+	if(ret)
+		return -2;
+
 	unsigned char serialStr[5];
 	snprintf((char*)serialStr, sizeof(serialStr), "%04hu", serial);
 
@@ -73,7 +69,10 @@ int eismultiplexer_connect_channel_exclusive(struct eismultiplexer* muliplexer,
 	uint8_t* wValChar = (uint8_t*)&wValue;
 	wValChar[0] = channel;
 	wValChar[1] = 0;
-	return usbshm_write_control_transfer(muliplexer->priv, 2, NULL, 0, wValue, 0);
+	int ret;
+	while((ret = usbshm_writeControlTransfer(muliplexer->priv, 2, NULL, 0, wValue, 0)) == USBSHM_ERROR_AGAIN)
+		usleep(1000000);
+	return ret;
 }
 
 int eismultiplexer_connect_channel(struct eismultiplexer* muliplexer, channel_t channel)
@@ -97,42 +96,36 @@ int eismultiplexer_disconnect_channel(struct eismultiplexer* muliplexer, channel
 channel_t eismultiplexer_get_connected(struct eismultiplexer* muliplexer)
 {
 	uint8_t buffer[2] = {};
-	usbshm_read_control_transfer(muliplexer->priv, 3, 0, 0, buffer, 1);
+	usbshm_readControlTransferSync(muliplexer->priv, 3, 0, 0, buffer, 1);
 	return buffer[0];
 }
 
-int eismultiplexer_get_channel_count(struct eismultiplexer* muliplexer, uint16_t *count)
-{
-	uint8_t buffer[2] = {};
-	int ret = usbshm_read_control_transfer(muliplexer->priv, 7, 0, 0, buffer, 1);
-	*count = buffer[0];
-	return ret;
-}
-
 int eismultiplexer_set_led(struct eismultiplexer* muliplexer, bool on)
 {
 	int ret;
-	ret = usbshm_write_control_transfer(muliplexer->priv, on, NULL, 0, 0, 0);
+	while((ret = usbshm_writeControlTransfer(muliplexer->priv, on, NULL, 0, 0, 0)) == USBSHM_ERROR_AGAIN)
+		usleep(1000000);
 	return ret;
 }
 
 int eismultiplexer_write_eeprom(struct eismultiplexer* muliplexer, uint16_t addr, uint16_t value)
 {
 	int ret;
-	ret = usbshm_write_control_transfer(muliplexer->priv, 5, NULL, 0, value, addr);
+	while((ret = usbshm_writeControlTransfer(muliplexer->priv, 5, NULL, 0, value, addr)) == USBSHM_ERROR_AGAIN)
+		usleep(1000000);
 	return ret;
 }
 
 uint16_t eismultiplexer_read_eeprom(struct eismultiplexer* muliplexer, uint16_t addr)
 {
 	uint8_t buffer[2] = {};
-	usbshm_read_control_transfer(muliplexer->priv, 4, 0, addr, buffer, 2);
+	usbshm_readControlTransferSync(muliplexer->priv, 4, 0, addr, buffer, 2);
 	return *((uint16_t*)buffer);
 }
 
 void eismultiplexer_disconnect(struct eismultiplexer* muliplexer)
 {
-	usbshm_close(muliplexer->priv);
+	usbshm_distroy(muliplexer->priv);
 	free(muliplexer->priv);
 	muliplexer->priv = NULL;
 }

eismultiplexer.h

@@ -50,7 +50,6 @@ typedef enum {
 	CHANNEL_E = (1 << 4),
 	CHANNEL_F = (1 << 5),
 	CHANNEL_G = (1 << 6),
-	CHANNEL_H = (1 << 7),
 	CHANNEL_NONE = 0,
 } channel_t;
 
@@ -58,13 +57,6 @@ struct eismultiplexer {
 	struct usbshm* priv;
 };
 
-/**
- * @brief Lists the available eismultiplexer devices
- * @param count The number of available eismultiplexer devices
- * @return An newly allocated array of length count with the serial numbers of the available devices to be freed by the user with free()
- */
-uint16_t* eismultiplexer_list_available_devices(size_t* count);
-
 /**
  * @brief Attempts to connect to a EISmultiplexer device and initializes a eismultiplexer struct
  * @param multiplexer pointer to a eismultiplexer struct to initialize
@@ -113,14 +105,6 @@ channel_t eismultiplexer_get_connected(struct eismultiplexer* muliplexer);
  */
 int eismultiplexer_set_led(struct eismultiplexer* muliplexer, bool on);
 
-/**
- * @brief Gets the number of channels on the device
- * @param multiplexer pointer to an eismultiplexer struct
- * @param count a pointer where the nummber of channels will be stored.
- * @return 0 on success and < 0 on failure
- */
-int eismultiplexer_get_channel_count(struct eismultiplexer* muliplexer, uint16_t *count);
-
 /**
  * @brief Disconnects from the eismultiplexer
  */

main.c

@@ -80,8 +80,6 @@ void print_commands(void)
 	puts("get\t\t\t | get the state of all channels");
 	puts("read [ADDRESS] [LENGTH]\t | read from the device eeprom at address");
 	puts("write [ADDRESS] [LENGTH] | write to the device eeprom at address");
-	puts("list | list the serial nummbers of the connected devices");
-	puts("channels | get the channel of the device");
 }
 
 static int process_commands(char** commands, size_t command_count, struct eismultiplexer* multiplexer, char* name)
@@ -161,32 +159,6 @@ static int process_commands(char** commands, size_t command_count, struct eismul
 			printf("Channel %c: %s\n", (char)('A'+i), connected ? "on" : "off");
 		}
 	}
-	else if(strcmp(commands[0], "channels") == 0)
-	{
-		uint16_t channels;
-		if(eismultiplexer_get_channel_count(multiplexer, &channels) < 0)
-		{
-			printf("could not get the number of channels\n");
-			return 3;
-		}
-		printf("The connected device has %u channels\n", channels);
-	}
-	else if(strcmp(commands[0], "list") == 0)
-	{
-		size_t count;
-		uint16_t* serials = eismultiplexer_list_available_devices(&count);
-		if(count == 0)
-		{
-			printf("No devices connected\n");
-			return 3;
-		}
-
-		printf("Connected devices:\n");
-		for(size_t i = 0; i < count; ++i)
-			printf("%04u\n", serials[i]);
-
-		free(serials);
-	}
 	else
 	{
 		if(command_count != 2)

options.h

@@ -35,14 +35,14 @@
 
 const char *argp_program_version = "eismulitplexer_cli";
 const char *argp_program_bug_address = "<carl@uvos.xyz>";
-static char doc[] = "Application to control eismultiplexer devices";
+static char doc[] = "Applicaion to control eismultiplexer devices";
 static char args_doc[] = "COMMAND";
 
 static struct argp_option options[] =
 {
   {"interactive",	'i', 0,				0,	"run in interactive mode" },
   {"pipe",			'p', 0,				0,	"run in pipe mode" },
-  {"serial",		's', "[NUMBER]",	0,	"serial number of device to connect to"},
+  {"serial",		's', "[NUMMBER]",	0,	"serial number of device to connect to"},
   {"list",			'l', 0,				0,	"list commands"},
   {0}
 };

usbshm.c

@@ -25,138 +25,103 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifdef __STDC_ALLOC_LIB__
-#define __STDC_WANT_LIB_EXT2__ 1
-#else
-#define _POSIX_C_SOURCE 200809L
-#endif
-
 #include "usbshm.h"
 
 #include <stdint.h>
 #include <stdio.h>
+#include <stdatomic.h>
 #include <stdbool.h>
 #include <string.h>
 #include <stdlib.h>
 #include <libusb-1.0/libusb.h>
+#include <errno.h>
 #include <unistd.h>
 
-static int object_counter = 0;
+struct usbshm_priv
-static struct libusb_context* context = NULL;
-
-static int usbshm_init(struct usbshm* instance)
 {
-	int ret = 0;
+	libusb_device_handle* handle;
-	if(object_counter == 0)
+	struct libusb_transfer* transfer;
-		ret = libusb_init(&context) < 0 ? USBSHM_ERROR_ERR : 0;
+	unsigned char* buffer;
-	if(ret >= 0)
+};
+
+static unsigned objectCounter = 0;
+static struct timeval timeout = {1, 0};
+static pthread_mutex_t *libusbDataMutex;
+static pthread_t libusbThread;
+static atomic_bool threadStop;
+
+static void usbshm_transferCallBack(struct libusb_transfer *transfer);
+
+void usbshm_distroy(struct usbshm* instance)
+{
+	while(!usbshm_ready(instance))
+		sleep(1);
+	free(instance->priv->transfer);
+	libusb_close(instance->priv->handle);
+	free(instance->priv->buffer);
+	free(instance->priv);
+	if(instance->serial)
+		free(instance->serial);
+	if(--objectCounter == 0)
 	{
-		++object_counter;
+		threadStop = true;
-		instance->handle = NULL;
+		pthread_join(libusbThread, NULL);
+		libusb_exit(NULL);
+		pthread_mutex_destroy(libusbDataMutex);
+	}
+}
+
+static void* usbshm_libusbPoll(void* arg)
+{
+	while(!threadStop)
+	{
+		libusb_handle_events_timeout_completed(NULL, &timeout, NULL);
+	}
+	return NULL;
+}
+
+bool usbshm_isOpen(struct usbshm* instance)
+{
+	return instance->priv->handle != NULL;
+}
+
+int usbshm_init(struct usbshm* instance, void (*dataCallback)(uint8_t request, unsigned char* data, size_t length, void* user_data), void* user_data)
+{
+	int ret=0;
+	instance->priv = malloc(sizeof(*instance->priv));
+	instance->priv->handle = NULL;
+	instance->priv->transfer = NULL;
+	instance->priv->buffer = NULL;
 	instance->vendorID = 0;
 	instance->productID = 0;
 	instance->serial = NULL;
-		instance->mutex =  malloc(sizeof(*(instance->mutex)));
+	instance->dataCallback = dataCallback;
-		pthread_mutex_init(instance->mutex, NULL);
+	instance->user_data = user_data;
+	if(objectCounter == 0)
+	{
+		ret = libusb_init(NULL) < 0 ? USBSHM_ERROR_ERR : 0;
+		libusbDataMutex = malloc(sizeof(*libusbDataMutex));
+		pthread_mutex_init(libusbDataMutex, NULL);
+		pthread_create(&libusbThread, NULL, &usbshm_libusbPoll, NULL);
 	}
-
+	if(ret == 0)
+		objectCounter++;
 	return ret < 0 ? USBSHM_ERROR_ERR : 0;
 }
 
-
+bool usbshm_ready(struct usbshm* instance)
-static void usbshm_exit(void)
 {
-	if(--object_counter == 0)
+	return instance->priv->transfer == NULL;
-	{
-		libusb_exit(context);
-		context = NULL;
-	}
 }
 
-__attribute__ ((visibility ("hidden")))
-void usbshm_close(struct usbshm* instance)
-{
-	if(!instance->handle)
-		return;
-	pthread_mutex_lock(instance->mutex);
-	libusb_close(instance->handle);
-	if(instance->serial)
-		free(instance->serial);
-	instance->handle = NULL;
-	usbshm_exit();
-	pthread_mutex_unlock(instance->mutex);
-	pthread_mutex_destroy(instance->mutex);
-}
-
-__attribute__ ((visibility ("hidden")))
-bool usbshm_is_open(struct usbshm* instance)
-{
-	return instance->handle != NULL;
-}
-
-__attribute__ ((visibility ("hidden")))
-int usbshm_find(struct usbshm* instance, int vendorID, int productID, unsigned char*** serials, size_t* count)
-{
-	int ret = usbshm_init(instance);
-	if(ret < 0)
-		return ret;
-
-	pthread_mutex_lock(instance->mutex);
-
-	libusb_device** list;
-	libusb_device_handle* handle;
-	int lusbcount = libusb_get_device_list(context, &list);
-	int errorCode = 0;
-
-	*count = 0;
-	*serials = malloc(sizeof(*serials)*lusbcount);
-
-	if(lusbcount > 0)
-	{
-		struct libusb_device_descriptor desc = {0};
-		for(int i = 0; i < lusbcount; ++i)
-		{
-			libusb_get_device_descriptor(list[i], &desc);
-			if(desc.idVendor == vendorID && desc.idProduct == productID)
-			{
-				errorCode = libusb_open(list[i], &handle) < 0 ? USBSHM_ERROR_ERR : 0;
-				if(errorCode != USBSHM_ERROR_ERR && handle)
-				{
-					(*serials)[*count] = calloc(16, 1);
-					libusb_get_string_descriptor_ascii(handle, desc.iSerialNumber, (*serials)[*count], 16);
-					++(*count);
-				}
-				else
-				{
-					handle = NULL;
-				}
-			}
-		}
-	}
-	else
-	{
-		printf("Can not list devices\n");
-		pthread_mutex_unlock(instance->mutex);
-		return USBSHM_ERROR_ERR;
-	}
-
-	pthread_mutex_unlock(instance->mutex);
-
-	return 0;
-}
-
-__attribute__ ((visibility ("hidden")))
 int usbshm_open(struct usbshm* instance, int vendorID, int productID, const unsigned char* serial)
 {
-	int ret = usbshm_init(instance);
+	instance->priv->handle = NULL;
-	if(ret < 0)
+	pthread_mutex_lock(libusbDataMutex);
-		return ret;
-
-	pthread_mutex_lock(instance->mutex);
 	libusb_device** list;
-	int count = libusb_get_device_list(context, &list);
+	int count = libusb_get_device_list(NULL, &list);
 	int errorCode = 0;
-	if(count > 0)
+	if( count > 0)
 	{
 		struct libusb_device_descriptor desc = {0};
 		for(int i = 0; i < count; ++i) 
@@ -164,43 +129,34 @@ int usbshm_open(struct usbshm* instance, int vendorID, int productID, const unsi
 			libusb_get_device_descriptor(list[i], &desc);
 			if(desc.idVendor == vendorID && desc.idProduct == productID)
 			{
-				errorCode = libusb_open(list[i], &instance->handle) < 0 ? USBSHM_ERROR_ERR : 0;
+				errorCode = libusb_open(list[i], &instance->priv->handle) < 0 ? USBSHM_ERROR_ERR : 0;
-				if(errorCode != USBSHM_ERROR_ERR && instance->handle)
-				{
 				if(serial)
 				{
 					size_t len = strlen((const char*)serial)+1;
 					unsigned char* buffer = malloc(len);
 					buffer[0] = '\0';
-						libusb_get_string_descriptor_ascii(instance->handle, desc.iSerialNumber, buffer, len);
+					libusb_get_string_descriptor_ascii(instance->priv->handle, desc.iSerialNumber, buffer, len);
 					int cmp = strcmp((const char*)serial, (const char*)buffer);
 					free(buffer);
 					if(cmp != 0)
 					{
-							libusb_close(instance->handle);
+						libusb_close(instance->priv->handle);
-							instance->handle = NULL;
+						instance->priv->handle = NULL;
 						continue;
 					}
 				}
 				break;
 			}
-				else
-				{
-					instance->handle = NULL;
-				}
-			}
 		}
 	}
 	else 
 	{
 		printf("Can not list devices\n");
-		pthread_mutex_unlock(instance->mutex);
+		pthread_mutex_unlock(libusbDataMutex);
 		return USBSHM_ERROR_ERR;
 	}
 
-	pthread_mutex_unlock(instance->mutex);
+	if(usbshm_isOpen(instance))
-
-	if(usbshm_is_open(instance))
 	{
 		instance->vendorID = vendorID;
 		instance->productID = productID;
@@ -209,7 +165,7 @@ int usbshm_open(struct usbshm* instance, int vendorID, int productID, const unsi
 			instance->serial = calloc(strlen((char*)serial), 1);
 			memcpy(instance->serial, serial, strlen((char*)serial));
 		}
-		libusb_set_auto_detach_kernel_driver(instance->handle, true);
+		libusb_set_auto_detach_kernel_driver(instance->priv->handle, true);
 	}
 	else
 	{
@@ -218,76 +174,120 @@ int usbshm_open(struct usbshm* instance, int vendorID, int productID, const unsi
 	}
 
 	libusb_free_device_list(list, count);
+	pthread_mutex_unlock(libusbDataMutex);
 	return errorCode;
 }
 
-__attribute__ ((visibility ("hidden")))
+bool usbshm_usbshm_isOpen(struct usbshm* instance)
-bool usbshm_usbshm_is_open(struct usbshm* instance)
 {
-	pthread_mutex_lock(instance->mutex);
+	pthread_mutex_lock(libusbDataMutex);
-	bool ret = instance->handle != NULL;
+	bool ret = instance->priv->handle != NULL;
-	pthread_mutex_unlock(instance->mutex);
+	pthread_mutex_unlock(libusbDataMutex);
 	return ret;
 }
 
-__attribute__ ((visibility ("hidden")))
 void usbshm_reset(struct usbshm* instance)
 {
-	if(!instance->handle)
+	pthread_mutex_lock(libusbDataMutex);
-		return;
+	libusb_reset_device(instance->priv->handle);
-	pthread_mutex_lock(instance->mutex);
+	pthread_mutex_unlock(libusbDataMutex);
-	libusb_reset_device(instance->handle);
-	pthread_mutex_unlock(instance->mutex);
 }
 
-__attribute__ ((visibility ("hidden")))
 void usbshm_reopen(struct usbshm* instance)
 {
 	usbshm_reset(instance);
-	libusb_close(instance->handle);
+	libusb_close(instance->priv->handle);
-	char* serial = strdup((char*)instance->serial);
+	usbshm_open(instance, instance->vendorID, instance->productID, instance->serial);
-	free(instance->serial);
-	usbshm_open(instance, instance->vendorID, instance->productID, (unsigned char*)serial);
 }
 
-__attribute__ ((visibility ("hidden")))
+int usbshm_writeControlTransfer(struct usbshm* instance, const uint8_t request,
-int usbshm_write_control_transfer(struct usbshm* instance, const uint8_t request,
+								char* buffer, const uint8_t length,
-								uint8_t* buffer, const uint8_t length,
 								const uint16_t wValue, const uint16_t wIndex)
 {
-	if(!instance->handle)
+	if(!usbshm_isOpen(instance))
-		return USBSHM_ERROR_NOT_CONNECTED;
-	if(!usbshm_is_open(instance))
 		return USBSHM_ERROR_NOT_CONNECTED;
 	if(length > 8)
 		return USBSHM_ERROR_PARAM;
-	pthread_mutex_lock(instance->mutex);
+	if(instance->priv->transfer == NULL)
-	int ret = libusb_control_transfer(instance->handle, LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_OUT,
+	{
-									  request, wValue, wIndex, buffer, length, 2000);
+		pthread_mutex_lock(libusbDataMutex);
-	pthread_mutex_unlock(instance->mutex);
+		instance->priv->buffer = malloc(length+8);
-
+		libusb_fill_control_setup(instance->priv->buffer, 
-	if(ret == LIBUSB_ERROR_TIMEOUT)
+								  LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_OUT, 
-		ret = USBSHM_ERROR_TIMEOUT;
+								  request, wValue, wIndex, length );
-	else if(ret < 0 )
+		for(uint8_t i = 0; i < length; ++i) 
-		ret = USBSHM_ERROR_ERR;
+			instance->priv->buffer[i+8] = buffer[i];
-
+		instance->priv->transfer = libusb_alloc_transfer(0);
-	return ret;
+		libusb_fill_control_transfer(instance->priv->transfer, instance->priv->handle, instance->priv->buffer, 
+									 &usbshm_transferCallBack, instance, 100);
+		int ret = libusb_submit_transfer(instance->priv->transfer);
+		if(ret < 0)
+		{
+			free(buffer);
+			libusb_free_transfer(instance->priv->transfer);
+			instance->priv->transfer = NULL;
+			if(ret == LIBUSB_ERROR_NO_DEVICE) 
+				usbshm_reopen(instance);
+			pthread_mutex_unlock(libusbDataMutex);
+		}
+		return ret < 0 ? USBSHM_ERROR_ERR : 0;
+	}
+	else return USBSHM_ERROR_AGAIN;
 }
 
-__attribute__ ((visibility ("hidden")))
+int usbshm_readControlTransfer(struct usbshm* instance, const uint8_t request, const uint16_t wValue, const uint16_t wIndex, const uint16_t length)
-int usbshm_read_control_transfer(struct usbshm* instance, const uint8_t request, const uint16_t wValue, const uint16_t wIndex, uint8_t* buffer, const uint16_t length)
 {
-	if(!instance->handle)
+	if(!usbshm_isOpen(instance))
 		return USBSHM_ERROR_NOT_CONNECTED;
-	pthread_mutex_lock(instance->mutex);
+	if(length > 8) 
-	int ret = libusb_control_transfer(instance->handle, LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_IN,
+		return USBSHM_ERROR_PARAM;
-									 request, wValue, wIndex, buffer, length, 2000);
+	if(instance->priv->transfer == NULL)
-	pthread_mutex_unlock(instance->mutex);
+	{
-
+		pthread_mutex_lock(libusbDataMutex);
-	if(ret == LIBUSB_ERROR_TIMEOUT)
+		instance->priv->buffer = malloc(length+8);
-		ret = USBSHM_ERROR_TIMEOUT;
+		libusb_fill_control_setup(instance->priv->buffer, LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_IN,
-	else if(ret < 0 )
+			request, wValue, wIndex, length);
-		ret = USBSHM_ERROR_ERR;
+		instance->priv->transfer = libusb_alloc_transfer(0);
-
+		libusb_fill_control_transfer(instance->priv->transfer, instance->priv->handle, instance->priv->buffer,
-	return ret;
+			&usbshm_transferCallBack, instance, 100);
+		int ret = libusb_submit_transfer(instance->priv->transfer);
+		if(ret < 0)
+		{
+			free(instance->priv->buffer);
+			libusb_free_transfer(instance->priv->transfer);
+			instance->priv->transfer = NULL;
+			if(ret == LIBUSB_ERROR_NO_DEVICE) 
+				usbshm_reopen(instance);
+			pthread_mutex_unlock(libusbDataMutex);
+		}
+		return ret < 0 ? USBSHM_ERROR_ERR : 0;
+	}
+	else return USBSHM_ERROR_AGAIN;
+}
+
+static void usbshm_transferCallBack(struct libusb_transfer *transfer)
+{
+	struct usbshm* context = (struct usbshm*)transfer->user_data;
+	if(transfer->status != LIBUSB_TRANSFER_COMPLETED)
+	{
+		printf("Usb transfer failed with %d\n", transfer->status);
+	}
+	else if(transfer->type == LIBUSB_TRANSFER_TYPE_CONTROL) 
+	{
+		if(context->dataCallback && transfer->length-8 >= transfer->actual_length) 
+			context->dataCallback(transfer->buffer[1], transfer->buffer+8, transfer->actual_length, context->user_data);
+	}
+	free(context->priv->buffer);
+	libusb_free_transfer(context->priv->transfer);
+	context->priv->transfer = NULL;
+	pthread_mutex_unlock(libusbDataMutex);
+}
+
+int usbshm_readControlTransferSync(struct usbshm* instance, const uint8_t request, const uint16_t wValue, const uint16_t wIndex, uint8_t* buffer, const uint16_t length)
+{
+	pthread_mutex_lock(libusbDataMutex);
+	int ret = libusb_control_transfer(instance->priv->handle, LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_IN,
+									 request, wValue, wIndex, buffer, length, 2000);
+	pthread_mutex_unlock(libusbDataMutex);
+	return ret < 0 ? USBSHM_ERROR_ERR : 0;
 }

usbshm.h

@@ -27,42 +27,48 @@
 
 #include <libusb-1.0/libusb.h>
 #include <pthread.h>
+#include <stdatomic.h>
 #include <stdint.h>
+#include <time.h>
 #include <stdbool.h>
 
 struct usbshm_priv;
 
 enum {
+	USBSHM_ERROR_AGAIN = -1,
 	USBSHM_ERROR_PARAM = -2,
 	USBSHM_ERROR_ERR = -3,
 	USBSHM_ERROR_NOT_CONNECTED = -4,
-	USBSHM_ERROR_ALLREADY_CONNECTED = -5,
-	USBSHM_ERROR_TIMEOUT = -6
 };
 
 struct usbshm {
+	struct usbshm_priv* priv;
 	int vendorID;
 	int productID;
 	unsigned char* serial;
-	libusb_device_handle* handle;
+	void* user_data;
-	pthread_mutex_t* mutex;
+	void (*dataCallback)(uint8_t request, unsigned char* data, size_t length, void* user_data);
 };
 
-int usbshm_find(struct usbshm* instance, int vendorID, int productID, unsigned char*** serials, size_t* count);
+void usbshm_distroy(struct usbshm* instance);
+
+int usbshm_init(struct usbshm* instance, void (*dataCallback)(uint8_t request, unsigned char* data, size_t length, void* user_data), void* user_data);
+
+bool usbshm_ready(struct usbshm* instance);
 
 int usbshm_open(struct usbshm* instance, int vendorID, int productID, const unsigned char* serial);
 
-void usbshm_close(struct usbshm* instance);
+bool usbshm_isOpen(struct usbshm* instance);
-
-bool usbshm_is_open(struct usbshm* instance);
 
 void usbshm_reset(struct usbshm* instance);
 
 void usbshm_reopen(struct usbshm* instance);
 
-int usbshm_write_control_transfer(struct usbshm* instance, const uint8_t request,
+int usbshm_writeControlTransfer(struct usbshm* instance, const uint8_t request, 
-								uint8_t* buffer, const uint8_t length,
+								char* buffer, const uint8_t length, 
 								const uint16_t wValue, const uint16_t wIndex);
 
-int usbshm_read_control_transfer(struct usbshm* instance, const uint8_t request, const uint16_t wValue, const uint16_t wIndex, uint8_t* buffer, const uint16_t length);
+int usbshm_readControlTransfer(struct usbshm* instance, const uint8_t request, const uint16_t wValue, const uint16_t wIndex, const uint16_t length);
+
+int usbshm_readControlTransferSync(struct usbshm* instance, const uint8_t request, const uint16_t wValue, const uint16_t wIndex, uint8_t* buffer, const uint16_t length);