ssize_t
usbReadEndpoint (
UsbDevice *device,
unsigned char endpointNumber,
void *buffer,
size_t length,
int timeout
) {
UsbEndpoint *endpoint;
if ((endpoint = usbGetInputEndpoint(device, endpointNumber))) {
UsbEndpointExtension *eptx = endpoint->extension;
ssize_t count;
doRead:
if ((count = read(eptx->data, buffer, length)) == -1) {
if (errno == EINTR) goto doRead;
logSystemError("USB endpoint read");
} else if (!usbApplyInputFilters(endpoint, buffer, length, &count)) {
errno = EIO;
} else if (!count) {
errno = EAGAIN;
} else {
return count;
}
}
return -1;
}
ssize_t
usbReadEndpoint (
UsbDevice *device,
unsigned char endpointNumber,
void *buffer,
size_t length,
int timeout
) {
UsbDeviceExtension *devx = device->extension;
const UsbEndpoint *endpoint;
if ((endpoint = usbGetInputEndpoint(device, endpointNumber))) {
const UsbEndpointDescriptor *descriptor = endpoint->descriptor;
UsbEndpointTransfer transfer = USB_ENDPOINT_TRANSFER(descriptor);
ssize_t result = -1;
switch (transfer) {
case UsbEndpointTransfer_Bulk:
result = usb_bulk_read(devx->handle, descriptor->bEndpointAddress,
buffer, length, timeout);
break;
case UsbEndpointTransfer_Interrupt:
result = usb_interrupt_read(devx->handle, descriptor->bEndpointAddress,
buffer, length, timeout);
break;
default:
logMessage(LOG_ERR, "USB endpoint input transfer not supported: 0X%02X", transfer);
result = -ENOSYS;
break;
}
if (result >= 0) {
if (!usbApplyInputFilters(device, buffer, length, &result)) {
result = -EIO;
}
}
if (result >= 0) return result;
errno = -result;
}
#if defined(__MINGW32__) && !defined(ETIMEDOUT)
# define ETIMEDOUT 116
#endif /* __MINGW32__ && !ETIMEDOUT */
#ifdef ETIMEDOUT
if (errno == ETIMEDOUT) errno = EAGAIN;
#endif /* ETIMEDOUT */
if (errno != EAGAIN) logSystemError("USB endpoint read");
return -1;
}
ssize_t
usbReadEndpoint (
UsbDevice *device,
unsigned char endpointNumber,
void *buffer,
size_t length,
int timeout
) {
UsbDeviceExtension *devx = device->extension;
if (usbGetHandle(devx)) {
const UsbEndpoint *endpoint;
if ((endpoint = usbGetInputEndpoint(device, endpointNumber))) {
const UsbEndpointDescriptor *descriptor = endpoint->descriptor;
UsbEndpointTransfer transfer = USB_ENDPOINT_TRANSFER(descriptor);
int actual_length;
int result;
switch (transfer) {
case UsbEndpointTransfer_Bulk:
result = libusb_bulk_transfer(devx->handle, descriptor->bEndpointAddress,
buffer, length, &actual_length, timeout);
break;
case UsbEndpointTransfer_Interrupt:
result = libusb_interrupt_transfer(devx->handle, descriptor->bEndpointAddress,
buffer, length, &actual_length, timeout);
break;
default:
logMessage(LOG_ERR, "USB endpoint input transfer not supported: 0X%02X", transfer);
result = LIBUSB_ERROR_NOT_SUPPORTED;
break;
}
if (result == LIBUSB_SUCCESS) {
ssize_t count = result;
if (usbApplyInputFilters(device, buffer, length, &count)) return count;
result = LIBUSB_ERROR_IO;
}
usbSetErrno(result, NULL);
}
}
if (errno != EAGAIN) logSystemError("USB endpoint read");
return -1;
}
ssize_t
usbReadEndpoint (
UsbDevice *device,
unsigned char endpointNumber,
void *buffer,
size_t length,
int timeout
) {
ssize_t count = -1;
UsbEndpoint *endpoint;
if ((endpoint = usbGetInputEndpoint(device, endpointNumber))) {
UsbEndpointTransfer transfer = USB_ENDPOINT_TRANSFER(endpoint->descriptor);
switch (transfer) {
case UsbEndpointTransfer_Bulk:
count = usbBulkTransfer(endpoint, buffer, length, timeout);
break;
case UsbEndpointTransfer_Interrupt: {
struct usbdevfs_urb *urb = usbInterruptTransfer(endpoint, NULL, length, timeout);
if (urb) {
count = urb->actual_length;
if (count > length) count = length;
memcpy(buffer, urb->buffer, count);
free(urb);
}
break;
}
default:
logMessage(LOG_ERR, "USB input transfer not supported: %d", transfer);
errno = ENOSYS;
break;
}
if (count != -1) {
if (!usbApplyInputFilters(device, buffer, length, &count)) {
errno = EIO;
count = -1;
}
}
}
return count;
}
int
usbMonitorInputPipe (
UsbDevice *device, unsigned char endpointNumber,
AsyncMonitorCallback *callback, void *data
) {
UsbEndpoint *endpoint = usbGetInputEndpoint(device, endpointNumber);
if (endpoint) {
if (usbHaveInputPipe(endpoint)) {
usbCancelInputMonitor(endpoint);
if (!callback) return 1;
if (asyncMonitorFileInput(&endpoint->direction.input.pipe.monitor,
endpoint->direction.input.pipe.output,
callback, data)) {
return 1;
}
}
}
return 0;
}