X-Git-Url: https://git.zerfleddert.de/cgi-bin/gitweb.cgi/hmcfgusb/blobdiff_plain/9db2e455127fa181c68cf093d23fe0c1ee142925..7ba4ea19644711d8f86c2df3a244da797e23cc96:/hmcfgusb.c diff --git a/hmcfgusb.c b/hmcfgusb.c index 0e45cbc..bcb85a4 100644 --- a/hmcfgusb.c +++ b/hmcfgusb.c @@ -1,6 +1,6 @@ /* HM-CFG-USB libusb-driver * - * Copyright (c) 2013 Michael Gernoth + * Copyright (c) 2013-16 Michael Gernoth * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to @@ -29,15 +29,23 @@ #include #include #include +#include #include +/* Workaround for old libusb-1.0 */ +#ifndef LIBUSB_CALL +#define LIBUSB_CALL +#define libusb_handle_events_timeout_completed(ctx, tv, x) libusb_handle_events_timeout(ctx, tv) +#endif + #include "hexdump.h" #include "hmcfgusb.h" -#define USB_TIMEOUT 10000 +#define USB_TIMEOUT 10000 #define ID_VENDOR 0x1b1f #define ID_PRODUCT 0xc00f +#define ID_PRODUCT_BL 0xc010 /* TODO: dynamic */ #define ASYNC_SIZE 0x0040 @@ -46,7 +54,11 @@ #define EP_OUT 0x02 #define EP_IN 0x83 +#define INTERFACE 0 + static int quit = 0; +static int debug = 0; +static int libusb_initialized = 0; /* Not in all libusb-1.0 versions, so we have to roll our own :-( */ static char * usb_strerror(int e) @@ -87,7 +99,7 @@ static char * usb_strerror(int e) return unknerr; } -static libusb_device_handle *hmcfgusb_find() { +static libusb_device_handle *hmcfgusb_find(int vid, int pid, char *serial) { libusb_device_handle *devh = NULL; libusb_device **list; ssize_t cnt; @@ -107,69 +119,123 @@ static libusb_device_handle *hmcfgusb_find() { if (err) continue; - if ((desc.idVendor == ID_VENDOR) && (desc.idProduct == ID_PRODUCT)) { + if ((desc.idVendor == vid) && (desc.idProduct == pid)) { libusb_device *dev = list[i]; err = libusb_open(dev, &devh); if (err) { fprintf(stderr, "Can't open device: %s\n", usb_strerror(err)); + libusb_free_device_list(list, 1); return NULL; } - err = libusb_detach_kernel_driver(devh, 0); + if (serial) { + if (desc.iSerialNumber > 0) { + uint8_t devSerial[256]; + err = libusb_get_string_descriptor_ascii(devh, desc.iSerialNumber, devSerial, sizeof(devSerial)); + if (err < 0) { + fprintf(stderr, "Can't read serial-number: %s\n", usb_strerror(err)); + libusb_close(devh); + libusb_free_device_list(list, 1); + return NULL; + } + if (strcmp((char*)devSerial, (char*)serial)) { + libusb_close(devh); + continue; + } + } else { + libusb_close(devh); + continue; + } + } + + err = libusb_detach_kernel_driver(devh, INTERFACE); if ((err != 0) && (err != LIBUSB_ERROR_NOT_FOUND)) { fprintf(stderr, "Can't detach kernel driver: %s\n", usb_strerror(err)); + libusb_close(devh); + libusb_free_device_list(list, 1); return NULL; } - err = libusb_claim_interface(devh, 0); + err = libusb_claim_interface(devh, INTERFACE); if ((err != 0)) { fprintf(stderr, "Can't claim interface: %s\n", usb_strerror(err)); + libusb_close(devh); + libusb_free_device_list(list, 1); return NULL; } + libusb_free_device_list(list, 0); return devh; } } + libusb_free_device_list(list, 1); return NULL; } +int hmcfgusb_send_null_frame(struct hmcfgusb_dev *usbdev, int silent) +{ + int err; + int cnt; + unsigned char out[0x40]; + + memset(out, 0, sizeof(out)); + + err = libusb_interrupt_transfer(usbdev->usb_devh, EP_OUT, out, 0, &cnt, USB_TIMEOUT); + if (err && (!silent)) { + fprintf(stderr, "Can't send null frame: %s\n", usb_strerror(err)); + return 0; + } + + return 1; +} + int hmcfgusb_send(struct hmcfgusb_dev *usbdev, unsigned char* send_data, int len, int done) { int err; int cnt; - int ret; + struct timeval tv_start, tv_end; + int msec; + + if (debug) { + hexdump(send_data, len, "USB < "); + } + + gettimeofday(&tv_start, NULL); err = libusb_interrupt_transfer(usbdev->usb_devh, EP_OUT, send_data, len, &cnt, USB_TIMEOUT); if (err) { fprintf(stderr, "Can't send data: %s\n", usb_strerror(err)); - if (err == LIBUSB_ERROR_NO_DEVICE) - exit(EXIT_FAILURE); return 0; } if (done) { - err = libusb_interrupt_transfer(usbdev->usb_devh, EP_OUT, send_data, 0, &cnt, USB_TIMEOUT); - if (err) { - fprintf(stderr, "Can't send data: %s\n", usb_strerror(err)); - if (err == LIBUSB_ERROR_NO_DEVICE) - exit(EXIT_FAILURE); + if (!hmcfgusb_send_null_frame(usbdev, 0)) { return 0; } } - return ret; + gettimeofday(&tv_end, NULL); + msec = ((tv_end.tv_sec-tv_start.tv_sec)*1000)+((tv_end.tv_usec-tv_start.tv_usec)/1000); + + if (msec > 100) { + fprintf(stderr, "usb-transfer took more than 100ms (%dms), this may lead to timing problems!\n", msec); + } else if (debug) { + fprintf(stderr, "usb-transfer took %dms!\n", msec); + } + + return 1; } -static struct libusb_transfer *hmcfgusb_prepare_int(libusb_device_handle *devh, libusb_transfer_cb_fn cb, void *data) +static struct libusb_transfer *hmcfgusb_prepare_int(libusb_device_handle *devh, libusb_transfer_cb_fn cb, void *data, int in_size) { unsigned char *data_buf; struct libusb_transfer *transfer; int err; - data_buf = malloc(ASYNC_SIZE); + data_buf = malloc(in_size); if (!data_buf) { fprintf(stderr, "Can't allocate memory for data-buffer!\n"); return NULL; @@ -183,15 +249,14 @@ static struct libusb_transfer *hmcfgusb_prepare_int(libusb_device_handle *devh, } libusb_fill_interrupt_transfer(transfer, devh, EP_IN, - data_buf, ASYNC_SIZE, cb, data, USB_TIMEOUT); + data_buf, in_size, cb, data, USB_TIMEOUT); - transfer->flags = LIBUSB_TRANSFER_SHORT_NOT_OK; + transfer->flags = LIBUSB_TRANSFER_FREE_BUFFER; err = libusb_submit_transfer(transfer); if (err != 0) { fprintf(stderr, "Can't submit transfer: %s\n", usb_strerror(err)); libusb_free_transfer(transfer); - free(data_buf); return NULL; } @@ -199,6 +264,7 @@ static struct libusb_transfer *hmcfgusb_prepare_int(libusb_device_handle *devh, } struct hmcfgusb_cb_data { + struct hmcfgusb_dev *dev; hmcfgusb_cb_fn cb; void *data; }; @@ -208,88 +274,140 @@ static void LIBUSB_CALL hmcfgusb_interrupt(struct libusb_transfer *transfer) int err; struct hmcfgusb_cb_data *cb_data; + cb_data = transfer->user_data; + if (transfer->status != LIBUSB_TRANSFER_COMPLETED) { if (transfer->status != LIBUSB_TRANSFER_TIMED_OUT) { - fprintf(stderr, "Interrupt transfer not completed: %d!\n", transfer->status); + if (transfer->status != LIBUSB_TRANSFER_CANCELLED) + fprintf(stderr, "Interrupt transfer not completed: %s!\n", usb_strerror(transfer->status)); + quit = EIO; - return; + goto out; } + } else { + if (cb_data && cb_data->cb) { + if (debug) + hexdump(transfer->buffer, transfer->actual_length, "USB > "); - err = libusb_submit_transfer(transfer); - if (err != 0) { - fprintf(stderr, "Can't re-submit transfer: %s\n", usb_strerror(err)); - free(transfer->buffer); - libusb_free_transfer(transfer); + if (!cb_data->cb(transfer->buffer, transfer->actual_length, cb_data->data)) { + quit = EIO; + goto out; + } + } else { + hexdump(transfer->buffer, transfer->actual_length, "> "); } - return; - } - - cb_data = transfer->user_data; - if (cb_data && cb_data->cb) { - cb_data->cb(transfer->buffer, transfer->actual_length, cb_data->data); - } else { - hexdump(transfer->buffer, transfer->actual_length, "RECV> "); } err = libusb_submit_transfer(transfer); if (err != 0) { fprintf(stderr, "Can't re-submit transfer: %s\n", usb_strerror(err)); - free(transfer->buffer); - libusb_free_transfer(transfer); + goto out; + } + + return; + +out: + libusb_free_transfer(transfer); + if (cb_data) { + if (cb_data->dev && cb_data->dev->transfer) { + cb_data->dev->transfer = NULL; + } + free(cb_data); } } -struct hmcfgusb_dev *hmcfgusb_init(hmcfgusb_cb_fn cb, void *data) +struct hmcfgusb_dev *hmcfgusb_init(hmcfgusb_cb_fn cb, void *data, char *serial) { libusb_device_handle *devh = NULL; const struct libusb_pollfd **usb_pfd = NULL; struct hmcfgusb_dev *dev = NULL; struct hmcfgusb_cb_data *cb_data = NULL; + int bootloader = 0; int err; int i; - err = libusb_init(NULL); - if (err != 0) { - fprintf(stderr, "Can't initialize libusb: %s\n", usb_strerror(err)); - return NULL; + if (!libusb_initialized) { + err = libusb_init(NULL); + if (err != 0) { + fprintf(stderr, "Can't initialize libusb: %s\n", usb_strerror(err)); + return NULL; + } } + libusb_initialized = 1; - devh = hmcfgusb_find(); + devh = hmcfgusb_find(ID_VENDOR, ID_PRODUCT, serial); if (!devh) { - fprintf(stderr, "Can't find/open hmcfgusb!\n"); - return NULL; + devh = hmcfgusb_find(ID_VENDOR, ID_PRODUCT_BL, serial); + if (!devh) { + if (serial) { + fprintf(stderr, "Can't find/open HM-CFG-USB with serial %s!\n", serial); + } else { + fprintf(stderr, "Can't find/open HM-CFG-USB!\n"); + } +#ifdef NEED_LIBUSB_EXIT + hmcfgusb_exit(); +#endif + return NULL; + } + bootloader = 1; } dev = malloc(sizeof(struct hmcfgusb_dev)); if (!dev) { perror("Can't allocate memory for hmcfgusb_dev"); + libusb_close(devh); +#ifdef NEED_LIBUSB_EXIT + hmcfgusb_exit(); +#endif return NULL; } memset(dev, 0, sizeof(struct hmcfgusb_dev)); dev->usb_devh = devh; + dev->bootloader = bootloader; + dev->opened_at = time(NULL); cb_data = malloc(sizeof(struct hmcfgusb_cb_data)); if (!cb_data) { perror("Can't allocate memory for hmcfgusb_cb_data"); + free(dev); + libusb_close(devh); +#ifdef NEED_LIBUSB_EXIT + hmcfgusb_exit(); +#endif return NULL; } memset(cb_data, 0, sizeof(struct hmcfgusb_cb_data)); + cb_data->dev = dev; cb_data->cb = cb; cb_data->data = data; - dev->transfer = hmcfgusb_prepare_int(devh, hmcfgusb_interrupt, cb_data); + dev->transfer = hmcfgusb_prepare_int(devh, hmcfgusb_interrupt, cb_data, ASYNC_SIZE); + if (!dev->transfer) { fprintf(stderr, "Can't prepare async device io!\n"); + free(dev); + free(cb_data); + libusb_close(devh); +#ifdef NEED_LIBUSB_EXIT + hmcfgusb_exit(); +#endif return NULL; } usb_pfd = libusb_get_pollfds(NULL); if (!usb_pfd) { fprintf(stderr, "Can't get FDset from libusb!\n"); + libusb_cancel_transfer(dev->transfer); + libusb_handle_events(NULL); free(dev); + free(cb_data); + libusb_close(devh); +#ifdef NEED_LIBUSB_EXIT + hmcfgusb_exit(); +#endif return NULL; } @@ -300,6 +418,14 @@ struct hmcfgusb_dev *hmcfgusb_init(hmcfgusb_cb_fn cb, void *data) dev->pfd = malloc(dev->n_usb_pfd * sizeof(struct pollfd)); if (!dev->pfd) { perror("Can't allocate memory for poll-fds"); + libusb_cancel_transfer(dev->transfer); + libusb_handle_events(NULL); + free(dev); + free(cb_data); + libusb_close(devh); +#ifdef NEED_LIBUSB_EXIT + hmcfgusb_exit(); +#endif return NULL; } @@ -315,6 +441,8 @@ struct hmcfgusb_dev *hmcfgusb_init(hmcfgusb_cb_fn cb, void *data) dev->n_pfd = dev->n_usb_pfd; + quit = 0; + return dev; } @@ -338,6 +466,7 @@ int hmcfgusb_poll(struct hmcfgusb_dev *dev, int timeout) { struct timeval tv; int usb_event = 0; + int timed_out = 0; int i; int n; int fd_n; @@ -353,10 +482,11 @@ int hmcfgusb_poll(struct hmcfgusb_dev *dev, int timeout) return -1; } else if (err == 0) { /* No pending timeout or a sane platform */ - tv.tv_sec = timeout; } else { if ((tv.tv_sec == 0) && (tv.tv_usec == 0)) { usb_event = 1; + } else if ((tv.tv_sec * 1000) < timeout) { + timeout = tv.tv_sec * 1000; } } @@ -365,12 +495,14 @@ int hmcfgusb_poll(struct hmcfgusb_dev *dev, int timeout) dev->pfd[i].revents = 0; } - n = poll(dev->pfd, dev->n_pfd, tv.tv_sec * 1000); + n = poll(dev->pfd, dev->n_pfd, timeout); if (n < 0) { perror("poll"); + errno = 0; return -1; } else if (n == 0) { usb_event = 1; + timed_out = 1; } else { for (fd_n = 0; fd_n < dev->n_pfd; fd_n++) { if (dev->pfd[fd_n].revents) { @@ -378,6 +510,7 @@ int hmcfgusb_poll(struct hmcfgusb_dev *dev, int timeout) usb_event = 1; break; } else { + errno = 0; return dev->pfd[fd_n].fd; } } @@ -389,14 +522,87 @@ int hmcfgusb_poll(struct hmcfgusb_dev *dev, int timeout) memset(&tv, 0, sizeof(tv)); err = libusb_handle_events_timeout_completed(NULL, &tv, NULL); if (err < 0) { - fprintf(stderr, "libusb_handle_events_completed: %s\n", usb_strerror(err)); + fprintf(stderr, "libusb_handle_events_timeout_completed: %s\n", usb_strerror(err)); errno = EIO; return -1; } } - if (quit) + errno = 0; + if (quit) { + fprintf(stderr, "closing device-connection due to error %d\n", quit); errno = quit; + } + + if (timed_out) + errno = ETIMEDOUT; return -1; } + +void hmcfgusb_enter_bootloader(struct hmcfgusb_dev *dev) +{ + uint8_t out[ASYNC_SIZE]; + + if (dev->bootloader) { + fprintf(stderr, "request for bootloader mode, but device already in bootloader!\n"); + return; + } + + memset(out, 0, sizeof(out)); + out[0] = 'B'; + hmcfgusb_send(dev, out, sizeof(out), 1); + + return; +} + +void hmcfgusb_leave_bootloader(struct hmcfgusb_dev *dev) +{ + uint8_t out[ASYNC_SIZE]; + + if (!dev->bootloader) { + fprintf(stderr, "request for leaving bootloader mode, but device already in normal mode!\n"); + return; + } + + memset(out, 0, sizeof(out)); + out[0] = 'K'; + hmcfgusb_send(dev, out, sizeof(out), 1); + + return; +} + +void hmcfgusb_close(struct hmcfgusb_dev *dev) +{ + int err; + + if (dev->transfer) { + libusb_cancel_transfer(dev->transfer); + libusb_handle_events(NULL); + } + + err = libusb_release_interface(dev->usb_devh, INTERFACE); + if ((err != 0)) { + fprintf(stderr, "Can't release interface: %s\n", usb_strerror(err)); + } + + libusb_close(dev->usb_devh); +#ifdef NEED_LIBUSB_EXIT + hmcfgusb_exit(); +#endif + free(dev->pfd); + free(dev); +} + +void hmcfgusb_exit(void) +{ + if (libusb_initialized) { + libusb_exit(NULL); + libusb_initialized = 0; + } +} + +void hmcfgusb_set_debug(int d) +{ + debug = d; +}