From c55b600d9e4c0f911a35f03e4c5d1a8bebc57da1 Mon Sep 17 00:00:00 2001 From: Carl Philipp Klemm Date: Tue, 7 May 2024 11:28:15 +0200 Subject: [PATCH] slim down usb_shm to only the things used in libeismulitplexer --- CMakeLists.txt | 3 + eismultiplexer.c | 25 ++--- usbshm.c | 246 +++++++++++++++-------------------------------- usbshm.h | 24 ++--- 4 files changed, 97 insertions(+), 201 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index fd588ff..2b5ed1d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,6 +6,9 @@ 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}) diff --git a/eismultiplexer.c b/eismultiplexer.c index 1a0eec7..5248c97 100644 --- a/eismultiplexer.c +++ b/eismultiplexer.c @@ -34,14 +34,6 @@ #include #include -static void usleep(uint64_t microseconds) -{ - struct timespec ts; - ts.tv_sec = microseconds / 1000000; - ts.tv_nsec = (microseconds % 1000000) * 1000; - nanosleep(&ts, NULL); -} - int eismultiplexer_connect(struct eismultiplexer* muliplexer, uint16_t serial) { int ret; @@ -49,7 +41,7 @@ int eismultiplexer_connect(struct eismultiplexer* muliplexer, uint16_t serial) if(!muliplexer->priv) return -1; - ret = usbshm_init(muliplexer->priv, NULL, muliplexer); + ret = usbshm_init(muliplexer->priv); if(ret) return -2; @@ -69,10 +61,7 @@ int eismultiplexer_connect_channel_exclusive(struct eismultiplexer* muliplexer, uint8_t* wValChar = (uint8_t*)&wValue; wValChar[0] = channel; wValChar[1] = 0; - int ret; - while((ret = usbshm_writeControlTransfer(muliplexer->priv, 2, NULL, 0, wValue, 0)) == USBSHM_ERROR_AGAIN) - usleep(1000000); - return ret; + return usbshm_write_control_transfer(muliplexer->priv, 2, NULL, 0, wValue, 0); } int eismultiplexer_connect_channel(struct eismultiplexer* muliplexer, channel_t channel) @@ -96,30 +85,28 @@ int eismultiplexer_disconnect_channel(struct eismultiplexer* muliplexer, channel channel_t eismultiplexer_get_connected(struct eismultiplexer* muliplexer) { uint8_t buffer[2] = {}; - usbshm_readControlTransferSync(muliplexer->priv, 3, 0, 0, buffer, 1); + usbshm_read_control_transfer(muliplexer->priv, 3, 0, 0, buffer, 1); return buffer[0]; } int eismultiplexer_set_led(struct eismultiplexer* muliplexer, bool on) { int ret; - while((ret = usbshm_writeControlTransfer(muliplexer->priv, on, NULL, 0, 0, 0)) == USBSHM_ERROR_AGAIN) - usleep(1000000); + ret = usbshm_write_control_transfer(muliplexer->priv, on, NULL, 0, 0, 0); return ret; } int eismultiplexer_write_eeprom(struct eismultiplexer* muliplexer, uint16_t addr, uint16_t value) { int ret; - while((ret = usbshm_writeControlTransfer(muliplexer->priv, 5, NULL, 0, value, addr)) == USBSHM_ERROR_AGAIN) - usleep(1000000); + ret = usbshm_write_control_transfer(muliplexer->priv, 5, NULL, 0, value, addr); return ret; } uint16_t eismultiplexer_read_eeprom(struct eismultiplexer* muliplexer, uint16_t addr) { uint8_t buffer[2] = {}; - usbshm_readControlTransferSync(muliplexer->priv, 4, 0, addr, buffer, 2); + usbshm_read_control_transfer(muliplexer->priv, 4, 0, addr, buffer, 2); return *((uint16_t*)buffer); } diff --git a/usbshm.c b/usbshm.c index 38c5074..d953225 100644 --- a/usbshm.c +++ b/usbshm.c @@ -25,101 +25,66 @@ * 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 #include -#include #include #include #include #include -#include #include -struct usbshm_priv -{ - libusb_device_handle* handle; - struct libusb_transfer* transfer; - unsigned char* buffer; -}; - -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); +static int object_counter = 0; +static struct libusb_context* context = NULL; 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); + pthread_mutex_lock(instance->mutex); + libusb_close(instance->handle); if(instance->serial) free(instance->serial); - if(--objectCounter == 0) - { - threadStop = true; - pthread_join(libusbThread, NULL); - libusb_exit(NULL); - pthread_mutex_destroy(libusbDataMutex); - } } -static void* usbshm_libusbPoll(void* arg) +bool usbshm_is_open(struct usbshm* instance) { - while(!threadStop) - { - libusb_handle_events_timeout_completed(NULL, &timeout, NULL); - } - return NULL; + return instance->handle != NULL; } -bool usbshm_isOpen(struct usbshm* instance) +int usbshm_init(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->dataCallback = dataCallback; - 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); - } + int ret = 0; + if(object_counter == 0) + ret = libusb_init(&context) < 0 ? USBSHM_ERROR_ERR : 0; if(ret == 0) - objectCounter++; - return ret < 0 ? USBSHM_ERROR_ERR : 0; -} + { + ++object_counter; + instance->handle = NULL; + instance->vendorID = 0; + instance->productID = 0; + instance->serial = NULL; + instance->mutex = malloc(sizeof(*(instance->mutex))); + pthread_mutex_init(instance->mutex, NULL); + } -bool usbshm_ready(struct usbshm* instance) -{ - return instance->priv->transfer == NULL; + return ret < 0 ? USBSHM_ERROR_ERR : 0; } int usbshm_open(struct usbshm* instance, int vendorID, int productID, const unsigned char* serial) { - instance->priv->handle = NULL; - pthread_mutex_lock(libusbDataMutex); + if(instance->handle) + return USBSHM_ERROR_ALLREADY_CONNECTED; + if(!context) + return USBSHM_ERROR_NOT_CONNECTED; + pthread_mutex_lock(instance->mutex); libusb_device** list; - int count = libusb_get_device_list(NULL, &list); + int count = libusb_get_device_list(context, &list); int errorCode = 0; if( count > 0) { @@ -129,21 +94,21 @@ 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->priv->handle) < 0 ? USBSHM_ERROR_ERR : 0; - if(errorCode != USBSHM_ERROR_ERR && instance->priv->handle) + errorCode = libusb_open(list[i], &instance->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->priv->handle, desc.iSerialNumber, buffer, len); + libusb_get_string_descriptor_ascii(instance->handle, desc.iSerialNumber, buffer, len); int cmp = strcmp((const char*)serial, (const char*)buffer); free(buffer); if(cmp != 0) { - libusb_close(instance->priv->handle); - instance->priv->handle = NULL; + libusb_close(instance->handle); + instance->handle = NULL; continue; } } @@ -151,7 +116,7 @@ int usbshm_open(struct usbshm* instance, int vendorID, int productID, const unsi } else { - instance->priv->handle = NULL; + instance->handle = NULL; } } } @@ -159,11 +124,13 @@ int usbshm_open(struct usbshm* instance, int vendorID, int productID, const unsi else { printf("Can not list devices\n"); - pthread_mutex_unlock(libusbDataMutex); + pthread_mutex_unlock(instance->mutex); return USBSHM_ERROR_ERR; } - if(usbshm_isOpen(instance)) + pthread_mutex_unlock(instance->mutex); + + if(usbshm_is_open(instance)) { instance->vendorID = vendorID; instance->productID = productID; @@ -172,7 +139,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->priv->handle, true); + libusb_set_auto_detach_kernel_driver(instance->handle, true); } else { @@ -181,120 +148,65 @@ int usbshm_open(struct usbshm* instance, int vendorID, int productID, const unsi } libusb_free_device_list(list, count); - pthread_mutex_unlock(libusbDataMutex); return errorCode; } -bool usbshm_usbshm_isOpen(struct usbshm* instance) +bool usbshm_usbshm_is_open(struct usbshm* instance) { - pthread_mutex_lock(libusbDataMutex); - bool ret = instance->priv->handle != NULL; - pthread_mutex_unlock(libusbDataMutex); + pthread_mutex_lock(instance->mutex); + bool ret = instance->handle != NULL; + pthread_mutex_unlock(instance->mutex); return ret; } void usbshm_reset(struct usbshm* instance) { - pthread_mutex_lock(libusbDataMutex); - libusb_reset_device(instance->priv->handle); - pthread_mutex_unlock(libusbDataMutex); + pthread_mutex_lock(instance->mutex); + libusb_reset_device(instance->handle); + pthread_mutex_unlock(instance->mutex); } void usbshm_reopen(struct usbshm* instance) { usbshm_reset(instance); - libusb_close(instance->priv->handle); - usbshm_open(instance, instance->vendorID, instance->productID, instance->serial); + libusb_close(instance->handle); + char* serial = strdup((char*)instance->serial); + free(instance->serial); + usbshm_open(instance, instance->vendorID, instance->productID, (unsigned char*)serial); } -int usbshm_writeControlTransfer(struct usbshm* instance, const uint8_t request, - char* buffer, const uint8_t length, +int usbshm_write_control_transfer(struct usbshm* instance, const uint8_t request, + uint8_t* buffer, const uint8_t length, const uint16_t wValue, const uint16_t wIndex) { - if(!usbshm_isOpen(instance)) + if(!usbshm_is_open(instance)) return USBSHM_ERROR_NOT_CONNECTED; if(length > 8) return USBSHM_ERROR_PARAM; - if(instance->priv->transfer == NULL) - { - pthread_mutex_lock(libusbDataMutex); - instance->priv->buffer = malloc(length+8); - libusb_fill_control_setup(instance->priv->buffer, - LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_OUT, - request, wValue, wIndex, length ); - for(uint8_t i = 0; i < length; ++i) - instance->priv->buffer[i+8] = buffer[i]; - instance->priv->transfer = libusb_alloc_transfer(0); - 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; + pthread_mutex_lock(instance->mutex); + 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_unlock(instance->mutex); + + if(ret == LIBUSB_ERROR_TIMEOUT) + ret = USBSHM_ERROR_TIMEOUT; + else if(ret < 0 ) + ret = USBSHM_ERROR_ERR; + + return ret; } -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(!usbshm_isOpen(instance)) - return USBSHM_ERROR_NOT_CONNECTED; - if(length > 8) - return USBSHM_ERROR_PARAM; - if(instance->priv->transfer == NULL) - { - pthread_mutex_lock(libusbDataMutex); - instance->priv->buffer = malloc(length+8); - libusb_fill_control_setup(instance->priv->buffer, LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_IN, - request, wValue, wIndex, length); - instance->priv->transfer = libusb_alloc_transfer(0); - 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(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, + pthread_mutex_lock(instance->mutex); + int ret = libusb_control_transfer(instance->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; + pthread_mutex_unlock(instance->mutex); + + if(ret == LIBUSB_ERROR_TIMEOUT) + ret = USBSHM_ERROR_TIMEOUT; + else if(ret < 0 ) + ret = USBSHM_ERROR_ERR; + + return ret; } diff --git a/usbshm.h b/usbshm.h index 0f44eb2..1b0bca2 100644 --- a/usbshm.h +++ b/usbshm.h @@ -27,48 +27,42 @@ #include #include -#include #include -#include #include 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; - void* user_data; - void (*dataCallback)(uint8_t request, unsigned char* data, size_t length, void* user_data); + libusb_device_handle* handle; + pthread_mutex_t* mutex; }; 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_init(struct usbshm* instance); int usbshm_open(struct usbshm* instance, int vendorID, int productID, const unsigned char* serial); -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_writeControlTransfer(struct usbshm* instance, const uint8_t request, - char* buffer, const uint8_t length, +int usbshm_write_control_transfer(struct usbshm* instance, const uint8_t request, + uint8_t* buffer, const uint8_t length, const uint16_t wValue, const uint16_t wIndex); -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); +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);