void interrupt_read_temperature(usb_dev_handle *dev, float *tempC) {
int r,i, temperature[2];
unsigned char answer[reqIntLen];
bzero(answer, reqIntLen);
r = usb_interrupt_read(dev, 0x82, answer, reqIntLen, timeout);
// If reading failed, retry once more...
if( r != reqIntLen )
{
r = usb_interrupt_read(dev, 0x82, answer, reqIntLen, timeout);
}
if( r != reqIntLen )
{
perror("USB interrupt read"); bad("USB read failed");
}
if(debug) {
for (i=0;i<reqIntLen; i++) printf("%02x ",answer[i] & 0xFF);
printf("\n");
}
temperature[0] = (answer[3] & 0xFF) + ((signed char)answer[2] << 8);
temperature[0] += calibration;
tempC[0] = temperature[0] * (125.0 / 32000.0);
temperature[1] = (answer[5] & 0xFF) + ((signed char)answer[4] << 8);
temperature[1] += calibration;
tempC[1] = temperature[1] * (125.0 / 32000.0);
}
static int interrupt_read_temperatura(usb_dev_handle *dev, float *tempC) {
int r,i, temperature;
char answer[reqIntLen];
bzero(answer, reqIntLen);
r = usb_interrupt_read(dev, 0x82, answer, reqIntLen, timeout);
if( r != reqIntLen )
{
if(debug){
printf("USB interrupt read");
}
return -1;
}
if(debug) {
for (i=0;i<reqIntLen; i++) printf("%02x ",answer[i] & 0xFF);
printf("\n");
}
temperature = (answer[3] & 0xFF) + (answer[2] << 8);
*tempC = temperature * (125.0 / 32000.0);
return 0;
}
/*
void test_control_transfer(usb_dev_handle *dev)
{
// usb_set_altinterface(dev, 0);
usb_release_interface(dev, 0);
}
*/
void test_interrupt_transfer(usb_dev_handle *dev)
{
int r,i;
char answer[reqIntLen];
char question[reqIntLen];
for (i=0;i<reqIntLen; i++) question[i]=i;
r = usb_interrupt_write(dev, endpoint_Int_out, question, reqIntLen, timeout);
if( r < 0 )
{
perror("USB interrupt write"); bad("USB write failed");
}
r = usb_interrupt_read(dev, endpoint_Int_in, answer, reqIntLen, timeout);
if( r != reqIntLen )
{
perror("USB interrupt read"); bad("USB read failed");
}
// for (i=0;i<reqIntLen; i++) printf("%i, %i, \n",question[i],answer[i]);
for(i = 0;i < reqIntLen; i++) {
if(i%8 == 0)
printf("\n");
printf("%02x, %02x; ",question[i],answer[i]);
}
printf("\n");
// usb_set_altinterface(dev, 0);
usb_release_interface(dev, 0);
}
void RF24ComVUsb::initialize(void)
{
const unsigned char rawVid[2] = {USB_CFG_VENDOR_ID}, rawPid[2] = {USB_CFG_DEVICE_ID};
char vendor[] = {USB_CFG_VENDOR_NAME, 0}, product[] = {USB_CFG_DEVICE_NAME, 0};
int vid, pid;
int ret;
uint8_t buffer[128];
usb_init();
vid = rawVid[1] * 256 + rawVid[0];
pid = rawPid[1] * 256 + rawPid[0];
if(usbOpenDevice(&handle, vid, vendor, pid, product, NULL, NULL, NULL) != 0)
fatal(-1, "Could not find USB device \"%s\" with vid=0x%x pid=0x%x\n", product, vid, pid);
// exmptiy thei interrupt queue
DPRINT("Emptying usb interrupt queue...");
ret = usb_interrupt_read(handle, USB_ENDPOINT_IN | 1, (char *)buffer, sizeof(buffer), 100);
DPRINT("done, returned %d.\n", ret);
DPRINT("Verifying protocol version\n");
buffer[0] = 4;
buffer[1] = 1;
buffer[2] = RF24_getProtocolVersion;
buffer[3] = 0;
sendRequest(buffer);
getResponse(buffer);
if (buffer[4] != RF24REMOTE_PROTOCOL_VERSION)
fatal(-1, "usb client returned wrong protocol version. Expected:%d, received:%d\n", RF24REMOTE_PROTOCOL_VERSION, buffer[4]);
}
int usbReadCode_USBDIO96H(HIDInterface* hid, __u32 address, __u8 count, __u8 data[])
{
struct t_readCode {
__u8 reportID;
__u8 address[3];
__u8 count;
} readCode;
struct t_readCodeI {
__u8 reportID;
__u8 data[62];
} readCodeI;
int bRead; // bytes read
if ( count > 62 ) count = 62;
readCode.reportID = READ_CODE;
memcpy(readCode.address, &address, 3); // 24 bit address
readCode.count = count;
PMD_SendOutputReport(hid, READ_CODE, (__u8 *) &readCode, sizeof(readCode), FS_DELAY);
do {
readCode.reportID = 0x0;
bRead = usb_interrupt_read(hid->dev_handle, USB_ENDPOINT_IN | 1,
(char *) &readCodeI, count+1, FS_DELAY);
} while (readCodeI.reportID != READ_CODE && (bRead != count+1));
memcpy(data, readCodeI.data, count);
return bRead;
}
void sendBuffer(char* buffer, size_t size) {
OpenIBootCmd cmd;
cmd.command = OPENIBOOTCMD_SENDCOMMAND;
cmd.dataLen = size;
usb_interrupt_write(device, 4, (char*) (&cmd), sizeof(OpenIBootCmd), 1000);
while(1) {
usb_interrupt_read(device, 3, (char*) (&cmd), sizeof(OpenIBootCmd), 1000);
if(cmd.command == OPENIBOOTCMD_SENDCOMMAND_GOAHEAD)
break;
}
int toSend = 0;
while(size > 0) {
if(size <= MAX_TO_SEND)
toSend = size;
else
toSend = MAX_TO_SEND;
usb_bulk_write(device, 2, buffer, toSend, 1000);
buffer += toSend;
size -= toSend;
}
}
int write_cmd(usb_dev_handle *udev, unsigned char *cmd, int read)
{
int ret=0, i=0;
unsigned char receive_data[1024];
unsigned char interrupt_data;
for (i=0; i<1024; i++)
receive_data[i] = 0x00;
printf("write_cmd\n");
ret = usb_bulk_write(udev, 0x02, cmd, sizeof(cmd), 10000);
if (ret != sizeof(cmd))
printf("Error!\n");
//if (read)
{
ret = usb_bulk_read(udev, 0x81, receive_data, sizeof(receive_data), 10000);
mcrw_debug(receive_data, ret);
}
//else
{
ret = usb_interrupt_read(udev, 0x83, &interrupt_data, 1, 10000);
mcrw_debug(&interrupt_data, ret);
}
return 0;
}
int gotemp_update(struct usense_device *dev, void *priv)
{
/* From the GoIO_SDK */
const double conversion = 0.0078125;
struct gotemp *gotemp = priv;
double kelvin;
char buff[64];
int len;
assert(sizeof(gotemp->packet) == 8);
do {
len = usb_interrupt_read(gotemp->usb, 0x81, (void *)&gotemp->packet, sizeof(gotemp->packet), 1000);
if (len < 0 || len != sizeof(gotemp->packet)) {
if (len == -EAGAIN) {
continue;
}
return -EINVAL;
}
} while (0);
kelvin = C_TO_K(((double) gotemp->packet.measurement0) * conversion);
snprintf(buff, sizeof(buff), "%g", kelvin);
return usense_prop_set(dev, "reading", buff);
}
void interrupt_read_temperatura(usb_dev_handle *dev, float *tempInC, float *tempOutC) {
int r,i, temperature;
unsigned char answer[reqIntLen];
bzero(answer, reqIntLen);
r = usb_interrupt_read(dev, 0x82, answer, reqIntLen, timeout);
if( r != reqIntLen )
{
perror("USB interrupt read"); bad("USB read failed");
}
if(debug) {
for (i=0;i<reqIntLen; i++) printf("%02x ",answer[i] & 0xFF);
printf("\n");
}
temperature = (answer[3] & 0xFF) + ((signed char)answer[2] << 8);
temperature += calibration;
*tempInC = temperature * (125.0 / 32000.0);
temperature = (answer[5] & 0xFF) + ((signed char)answer[4] << 8);
temperature += calibration;
*tempOutC = temperature * (125.0 / 32000.0);
}
int HID_API_EXPORT hid_read(hid_device *dev, unsigned char *data, size_t length)
{
int bytes_read = -1;
bytes_read = usb_interrupt_read(dev->device_handle, 0x81, data, length, -1);
return bytes_read;
}
int interrupt_read(struct usb_dev_handle *handle, int ep, char *data, int datalength)
{
int r;
r = usb_return(usb_interrupt_read(handle, ep, data, datalength, READ_TIMEOUT),
"usb_interrupt_read");
return r;
}
int INDI::USBDevice::ReadInterrupt(char *buf,int c,int timeout)
{
int rc;
rc=usb_interrupt_read(usb_handle,InputEndpoint,buf,c,timeout);
//rc=usb_bulk_read(usb_handle,InputEndpoint,buf,c,timeout);
return rc;
}
static int
gusb_libusb_get(garmin_usb_packet *ibuf, size_t sz)
{
unsigned char *buf = &ibuf->dbuf[0];
int r = -1;
r = usb_interrupt_read(udev, gusb_intr_in_ep, (char *) buf, sz, TMOUT_I);
return r;
}
/* This function assumes we have locked the receiveBuffer mutex! */
unsigned int
USBDevice_internalFillReceiveBuffer(LPSKYETEK_DEVICE device, unsigned int timeout)
{
unsigned char receiveBuffer[64];
LPUSB_DEVICE usbDevice;
int result;
unsigned char retried;
#ifdef LINUX
unsigned char flushBuffer[3];
#endif
if((device == NULL) || (device->user == NULL))
return 0;
usbDevice = (LPUSB_DEVICE)device->user;
/* We emptied the buffer so reset all of our pointers */
usbDevice->receiveBufferReadPtr = usbDevice->receiveBufferWritePtr = usbDevice->receiveBuffer;
#ifdef LINUX
retried = 0;
again:
#endif
if((result = usb_interrupt_read(usbDevice->usbDevHandle, 1, receiveBuffer, 64, (timeout == 0) ? 100 : timeout)) < 0)
{
/*printf("usb_interrupt_read failed: %d\r\n", result);*/
#ifdef LINUX
if(!retried)
{
flushBuffer[0] = 0x00;
flushBuffer[1] = 0x00;
flushBuffer[2] = 0x00;
USBDevice_Write(device, flushBuffer, 3, 100);
USBDevice_Flush();
retried = 1;
}
#endif
return 0;
}
#ifdef LINUX
usbDevice->packetParity++;
#endif
/*printf("Reading - %d \r\n", receiveBuffer[0]);
for(size_t ix = 0; ix < receiveBuffer[0]; ix++)
printf("%02x", receiveBuffer[ix]);
printf("\r\n");*/
memcpy(usbDevice->receiveBuffer, (receiveBuffer + 1), receiveBuffer[0]);
usbDevice->receiveBufferWritePtr = usbDevice->receiveBuffer + receiveBuffer[0];
return 1;
}
/**
* Send a command with data to usb4all controller and reads the answer.
* Even if some inputs should be read a command to do this has to send before.
* \param p pointer to private data structure
* \param data_out pointer to data send to controller
* \param data_in pointer to buffer where read in data is stored
* \return number of bytes read in
*/
int
usb4all_data_io(PrivateData *p, tx_buffer * data_out, tx_buffer * data_in)
{
int res;
if (p->usbMode == MODE_BULK) {
res = usb_bulk_write(p->usbHandle,
p->usbEpOut,
(char *)data_out->buffer,
data_out->use_count,
TIMEOUT_WRITE);
}
else {
res = usb_interrupt_write(p->usbHandle,
p->usbEpOut,
(char *)data_out->buffer,
data_out->use_count,
TIMEOUT_WRITE);
}
if (res < 0) {
p->hd44780_functions->drv_report(RPT_WARNING,
"usb4all_data_io: unable to send, result = %d ...", res);
return -1;
}
/* if a reset command is send the usb4all controller doesn't answer */
if (data_out->buffer[0] == USB4ALL_RESET) {
return 0;
}
if (res != data_out->use_count) {
p->hd44780_functions->drv_report(RPT_WARNING,
"usb4all_data_io: Want to send %d bytes but currently only %d bytes was send!?",
data_out->use_count, res);
return -1;
}
if (p->usbMode == MODE_BULK) {
res = usb_bulk_read(p->usbHandle,
p->usbEpIn,
(char *)data_in->buffer,
USB4ALL_RX_MAX,
TIMEOUT_READ);
}
else {
res = usb_interrupt_read(p->usbHandle,
p->usbEpIn,
(char *)data_in->buffer,
USB4ALL_RX_MAX,
TIMEOUT_READ);
}
return res;
}
int hidReadPoll(char *buf,int Length, int id)
{
int rc;
buf[0] = id;
rc = usb_interrupt_read(usb_dev, EP_IN , buf+1 , Length, 5000);
// rc = HidD_GetFeature(hHID, buf, Length);
#if DEBUG_PKTDUMP
memdump("RD", buf, Length);
#endif
return rc;
}
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;
}
/*
* Class: ch_ntb_usb_LibusbJava
* Method: usb_interrupt_read
* Signature: (JI[BII)I
*/
JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbJava_usb_1interrupt_1read
(JNIEnv *env, jclass obj, jlong dev_handle, jint ep, jbyteArray jbytes, jint size, jint timeout)
{
clearLibusbJavaError();
char *bytes = (char *) malloc(size * sizeof(char));
int num_bytes = usb_interrupt_read((usb_dev_handle *) dev_handle, ep, bytes, size, timeout);
if (!bytes) { return num_bytes; }
(*env)->SetByteArrayRegion(env, jbytes, 0, size, (jbyte *) bytes);
free(bytes);
return num_bytes;
}
/*
* HIDデバイスから HID Report を取得する.
* 受け取ったバッファは先頭の1バイトに必ずReportIDが入っている.
*
* id と Length の組はデバイス側で定義されたものでなければならない.
*
* 戻り値はHidD_GetFeatureの戻り値( 0 = 失敗 )
*
*/
static int hidRead(char *buf, int Length, int id)
{
int rc;
buf[0] = id;
rc = usb_interrupt_read(usb_dev, EP_IN , buf+1 , Length-1, 5000);
// rc = HidD_GetFeature(h, buf, Length);
#if DEBUG_PKTDUMP
memdump("RD", buf, Length);
printf("id=%d Length=%d rc=%d\n",id,Length,rc);
#endif
return rc;
}
// rawhid_recv - receive a packet
// Inputs:
// num = device to receive from (zero based)
// buf = buffer to receive packet
// len = buffer's size
// timeout = time to wait, in milliseconds
// Output:
// number of bytes received, or -1 on error
//
int rawhid_recv(int num, void *buf, int len, int timeout)
{
hid_t *hid;
int r;
hid = get_hid(num);
if (!hid || !hid->open) return -1;
r = usb_interrupt_read(hid->usb, hid->ep_in, buf, len, timeout);
if (r >= 0) return r;
if (r == -110) return 0; // timeout
return -1;
}
static int
write_command (usb_dev_handle *handle,
char cmd,
const char *in,
int in_size,
char *out,
int out_size)
{
char buffer[64];
int rc;
int ret = -1;
/* setup write packet */
memset (buffer, 0x00, sizeof (buffer));
buffer[0] = cmd;
if (in != NULL)
memcpy (buffer + 1, in, in_size);
/* write to device */
rc = usb_interrupt_write (handle, 0x01, buffer, 64, 5000);
if (rc < 0) {
printf ("Failed to write, got %s\n", usb_strerror ());
goto out;
}
if (rc < 64) {
printf ("Failed to write stream, only wrote %i\n", rc);
goto out;
}
/* read status */
rc = usb_interrupt_read (handle, 0x81, buffer, 64, 5000);
if (rc != 2 + out_size && rc != 64) {
printf ("Failed to read, got %i bytes\n", rc);
goto out;
}
if (buffer[0] != 0x00) {
printf ("Failed to get valid command status %i\n", buffer[0]);
goto out;
}
if (buffer[1] != cmd) {
printf ("Failed to get valid command value %i\n", buffer[1]);
goto out;
}
/* copy data out of buffer */
if (out != NULL)
memcpy (out, buffer + 2, out_size);
/* success */
ret = 0;
out:
return ret;
}
struct kbrep *usb_hidkb_getChars() {
struct usb_device *dev = (struct usb_device*) hidkb.data;
struct kbrep *ret = (struct kbrep*) malloc(sizeof(struct kbrep));
memset(ret, 0, 8);
s8 epnum = dev->conf->intf->endp->bEndpointAddress & 0xf;
(void) usb_interrupt_read(dev, epnum, (u8*) ret, 8, 0);
#if 0
printf("============\nusb_interrupt_read:\n");
hexdump((void*)ret, 8);
#endif
return ret;
}
void*
Xbox360UsbThread::thread_loop()
{
thread_quit = false;
while (!thread_quit)
{
uint8_t data[20];
int ret = usb_interrupt_read(handle, 1 /*EndPoint*/, (char*)data, sizeof(data), 0 /*Timeout*/);
if (ret < 0)
{ // Error
std::ostringstream str;
str << "USBError: " << ret << "\n" << usb_strerror() << std::endl;
str << "Shutting down" << std::endl;
throw std::runtime_error(str.str());
}
else if (ret == 0) // ignore
{
// happen with the Xbox360 every now and then, just
// ignore, seems harmless
}
else if (ret == 3) // ignore
{
// This data gets send when the controller is accessed the
// first time after being connected to the USB bus, no idea
// what it means, it seems to be identical for different
// controllers, we just ignore it
//
// len: 3 Data: 0x01 0x03 0x0e
// len: 3 Data: 0x02 0x03 0x00
// len: 3 Data: 0x03 0x03 0x03
// len: 3 Data: 0x08 0x03 0x00
// len: 3 Data: 0x01 0x03 0x00
}
else if (ret == 20 && data[0] == 0x00 && data[1] == 0x14)
{
//LOG("Data in Mailbox");
Xbox360Msg& msg = (Xbox360Msg&)data;
// mutex this
mailbox.push(msg);
}
else
{
std::cout << "Unknown data: bytes: " << ret << " Data: ";
for(int j = 0; j < ret; ++j)
std::cout << boost::format("0x%02x ") % int(data[j]);
std::cout << std::endl;
}
}
return NULL;
}
/* reads digital port */
void usbDIn_USBTEMP(HIDInterface* hid, __u8* value)
{
__u8 reportID = DIN;
struct t_read_port {
__u8 reportID;
__u8 value;
} read_port;
PMD_SendOutputReport(hid, 0, &reportID, 1, FS_DELAY);
usb_interrupt_read(hid->dev_handle, USB_ENDPOINT_IN | 1,
(char *) &read_port, sizeof(read_port), FS_DELAY);
*value = read_port.value;
return;
}
void usbGetAll_USBDIO96H(HIDInterface* hid, __u8 data[])
{
__u8 reportID = GET_ALL;
struct t_get_all {
__u8 reportID;
__u8 values[19];
} get_all;
PMD_SendOutputReport(hid, GET_ALL, &reportID, sizeof(reportID), FS_DELAY);
usb_interrupt_read(hid->dev_handle, USB_ENDPOINT_IN | 1,
(char *) &get_all, sizeof(get_all), FS_DELAY);
memcpy(data, get_all.values, 19);
return;
}
int PMD_GetInputReport(HIDInterface* hid, __u8 reportID, __u8 *vals, int nbytes, int delay)
{
char data[33];
int ret;
if ( reportID == 0 ) { // it's an LS device, use endpoint 1
ret = usb_interrupt_read(hid->dev_handle, USB_ENDPOINT_IN | 1, data, nbytes, delay);
if ( ret < 0 ) {
perror("PMD_GetInputReport");
}
memcpy(vals, data, nbytes);
return ret;
}
return -1;
}
static int ippon_command(const char *cmd, char *buf, size_t buflen)
{
char tmp[64];
int ret, len;
size_t i;
snprintf(tmp, sizeof(tmp), "%s", cmd);
for (i = 0; i < strlen(tmp); i += ret) {
/* Write data in 8-byte chunks */
ret = usb_control_msg(udev, USB_ENDPOINT_OUT + USB_TYPE_CLASS + USB_RECIP_INTERFACE,
0x09, 0x2, 0, &tmp[i], 8, 1000);
if (ret <= 0) {
upsdebugx(3, "send: %s", (ret != -ETIMEDOUT) ? usb_strerror() : "Connection timed out");
return ret;
}
}
upsdebugx(3, "send: %.*s", (int)strcspn(tmp, "\r"), tmp);
/* Read all 64 bytes of the reply in one large chunk */
ret = usb_interrupt_read(udev, 0x81, tmp, sizeof(tmp), 1000);
/*
* Any errors here mean that we are unable to read a reply (which
* will happen after successfully writing a command to the UPS)
*/
if (ret <= 0) {
upsdebugx(3, "read: %s", (ret != -ETIMEDOUT) ? usb_strerror() : "Connection timed out");
return ret;
}
/*
* As Ippon will always return 64 bytes in response, we have to
* calculate and return length of actual response data here.
* Empty response will look like 0x00 0x0D, otherwise it will be
* data string terminated by 0x0D.
*/
len = (int)strcspn(tmp, "\r");
upsdebugx(3, "read: %.*s", len, tmp);
if (len > 0) {
len ++;
}
snprintf(buf, buflen, "%.*s", len, tmp);
return len;
}
/* reads digital bit */
void usbDInBit_USBTEMP(HIDInterface* hid, __u8 bit_num, __u8* value)
{
struct t_read_bit {
__u8 reportID;
__u8 value;
} read_bit;
read_bit.reportID = DBIT_IN;
read_bit.value = bit_num;
PMD_SendOutputReport(hid, 0, (__u8*) &read_bit, 2, FS_DELAY);
usb_interrupt_read(hid->dev_handle, USB_ENDPOINT_IN | 1,
(char *) &read_bit, sizeof(read_bit), FS_DELAY);
*value = read_bit.value;
return;
}
/* reads digital port */
__u8 usbDIn_USBPDISO8(HIDInterface* hid, __u8 port)
{
struct t_read_port {
__u8 reportID;
__u8 value;
} read_port;
read_port.reportID = DIN;
read_port.value = port;
PMD_SendOutputReport(hid, DIN, (__u8*) &read_port, sizeof(read_port), FS_DELAY);
usb_interrupt_read(hid->dev_handle, USB_ENDPOINT_IN | 1,
(char *) &read_port, sizeof(read_port), FS_DELAY);
return read_port.value;
}
static int pickit2_get_firmware_version(void)
{
int ret;
uint8_t command[CMD_LENGTH] = {CMD_GET_VERSION, CMD_END_OF_BUFFER};
ret = usb_interrupt_write(pickit2_handle, ENDPOINT_OUT, (char *)command, CMD_LENGTH, DFLT_TIMEOUT);
ret = usb_interrupt_read(pickit2_handle, ENDPOINT_IN, (char *)command, CMD_LENGTH, DFLT_TIMEOUT);
msg_pdbg("PICkit2 Firmware Version: %d.%d\n", (int)command[0], (int)command[1]);
if (ret != CMD_LENGTH) {
msg_perr("Command Get Firmware Version failed (%s)!\n", usb_strerror());
return 1;
}
return 0;
}
