Finds all ftdi devices with given VID:PID on the usb bus. Creates a new
ftdi_device_list which needs to be deallocated by ftdi_list_free() after
use. With VID:PID 0:0, search for the default devices
- (0x403:0x6001, 0x403:0x6010, 0x403:0x6011, 0x403:0x6014)
+ (0x403:0x6001, 0x403:0x6010, 0x403:0x6011, 0x403:0x6014, 0x403:0x6015)
\param ftdi pointer to ftdi_context
\param devlist Pointer where to store list of found devices
desc.idVendor == vendor && desc.idProduct == product) ||
(!(vendor || product) &&
(desc.idVendor == 0x403) && (desc.idProduct == 0x6001 || desc.idProduct == 0x6010
- || desc.idProduct == 0x6011 || desc.idProduct == 0x6014)))
+ || desc.idProduct == 0x6011 || desc.idProduct == 0x6014
+ || desc.idProduct == 0x6015)))
{
*curdev = (struct ftdi_device_list*)malloc(sizeof(struct ftdi_device_list));
if (!*curdev)
\retval -9: get serial number failed
\retval -11: libusb_get_device_descriptor() failed
*/
-int ftdi_usb_get_strings(struct ftdi_context * ftdi, struct libusb_device * dev,
- char * manufacturer, int mnf_len, char * description, int desc_len, char * serial, int serial_len)
+int ftdi_usb_get_strings(struct ftdi_context *ftdi,
+ struct libusb_device *dev,
+ char *manufacturer, int mnf_len,
+ char *description, int desc_len,
+ char *serial, int serial_len)
{
- struct libusb_device_descriptor desc;
+ int ret;
if ((ftdi==NULL) || (dev==NULL))
return -1;
if (ftdi->usb_dev == NULL && libusb_open(dev, &ftdi->usb_dev) < 0)
- ftdi_error_return(-4, "libusb_open() failed");
+ ftdi_error_return(-4, "libusb_open() failed");
+
+ // ftdi->usb_dev will not be NULL when entering ftdi_usb_get_strings2(), so
+ // it won't be closed either. This allows us to close it whether we actually
+ // called libusb_open() up above or not. This matches the expected behavior
+ // (and note) for ftdi_usb_get_strings().
+ ret = ftdi_usb_get_strings2(ftdi, dev,
+ manufacturer, mnf_len,
+ description, desc_len,
+ serial, serial_len);
+
+ // only close it if it was successful, as all other return codes close
+ // before returning already.
+ if (ret == 0)
+ ftdi_usb_close_internal(ftdi);
+
+ return ret;
+}
+
+/**
+ Return device ID strings from the usb device.
+
+ The parameters manufacturer, description and serial may be NULL
+ or pointer to buffers to store the fetched strings.
+
+ \note The old function ftdi_usb_get_strings() always closes the device.
+ This version only closes the device if it was opened by it.
+
+ \param ftdi pointer to ftdi_context
+ \param dev libusb usb_dev to use
+ \param manufacturer Store manufacturer string here if not NULL
+ \param mnf_len Buffer size of manufacturer string
+ \param description Store product description string here if not NULL
+ \param desc_len Buffer size of product description string
+ \param serial Store serial string here if not NULL
+ \param serial_len Buffer size of serial string
+
+ \retval 0: all fine
+ \retval -1: wrong arguments
+ \retval -4: unable to open device
+ \retval -7: get product manufacturer failed
+ \retval -8: get product description failed
+ \retval -9: get serial number failed
+ \retval -11: libusb_get_device_descriptor() failed
+*/
+int ftdi_usb_get_strings2(struct ftdi_context *ftdi, struct libusb_device *dev,
+ char *manufacturer, int mnf_len,
+ char *description, int desc_len,
+ char *serial, int serial_len)
+{
+ struct libusb_device_descriptor desc;
+ char need_open;
+
+ if ((ftdi==NULL) || (dev==NULL))
+ return -1;
+
+ need_open = (ftdi->usb_dev == NULL);
+ if (need_open && libusb_open(dev, &ftdi->usb_dev) < 0)
+ ftdi_error_return(-4, "libusb_open() failed");
if (libusb_get_device_descriptor(dev, &desc) < 0)
ftdi_error_return(-11, "libusb_get_device_descriptor() failed");
}
}
- ftdi_usb_close_internal (ftdi);
+ if (need_open)
+ ftdi_usb_close_internal (ftdi);
return 0;
}
else
best_baud = ftdi_to_clkbits(baudrate, C_CLK, 16, &encoded_divisor);
}
- else if ((ftdi->type == TYPE_BM) || (ftdi->type == TYPE_2232C) || (ftdi->type == TYPE_R ))
+ else if ((ftdi->type == TYPE_BM) || (ftdi->type == TYPE_2232C) || (ftdi->type == TYPE_R) || (ftdi->type == TYPE_230X))
{
best_baud = ftdi_to_clkbits(baudrate, C_CLK, 16, &encoded_divisor);
}
}
}
}
- ret = libusb_submit_transfer (transfer);
- if (ret < 0)
- tc->completed = 1;
+
+ if (transfer->status == LIBUSB_TRANSFER_CANCELLED)
+ tc->completed = LIBUSB_TRANSFER_CANCELLED;
+ else
+ {
+ ret = libusb_submit_transfer (transfer);
+ if (ret < 0)
+ tc->completed = 1;
+ }
}
transfer->length = write_size;
transfer->buffer = tc->buf + tc->offset;
- ret = libusb_submit_transfer (transfer);
- if (ret < 0)
- tc->completed = 1;
+
+ if (transfer->status == LIBUSB_TRANSFER_CANCELLED)
+ tc->completed = LIBUSB_TRANSFER_CANCELLED;
+ else
+ {
+ ret = libusb_submit_transfer (transfer);
+ if (ret < 0)
+ tc->completed = 1;
+ }
}
}
int ftdi_transfer_data_done(struct ftdi_transfer_control *tc)
{
int ret;
-
+ struct timeval to = { 0, 0 };
while (!tc->completed)
{
- ret = libusb_handle_events(tc->ftdi->usb_ctx);
+ ret = libusb_handle_events_timeout_completed(tc->ftdi->usb_ctx,
+ &to, &tc->completed);
if (ret < 0)
{
if (ret == LIBUSB_ERROR_INTERRUPTED)
continue;
libusb_cancel_transfer(tc->transfer);
while (!tc->completed)
- if (libusb_handle_events(tc->ftdi->usb_ctx) < 0)
+ if (libusb_handle_events_timeout_completed(tc->ftdi->usb_ctx,
+ &to, &tc->completed) < 0)
break;
libusb_free_transfer(tc->transfer);
free (tc);
}
/**
+ Cancel transfer and wait for completion.
+
+ Use libusb 1.0 asynchronous API.
+
+ \param tc pointer to ftdi_transfer_control
+ \param to pointer to timeout value or NULL for infinite
+*/
+
+void ftdi_transfer_data_cancel(struct ftdi_transfer_control *tc,
+ struct timeval * to)
+{
+ struct timeval tv = { 0, 0 };
+
+ if (!tc->completed && tc->transfer != NULL)
+ {
+ if (to == NULL)
+ to = &tv;
+
+ libusb_cancel_transfer(tc->transfer);
+ while (!tc->completed)
+ {
+ if (libusb_handle_events_timeout_completed(tc->ftdi->usb_ctx, to, &tc->completed) < 0)
+ break;
+ }
+ }
+
+ if (tc->transfer)
+ libusb_free_transfer(tc->transfer);
+
+ free (tc);
+}
+
+/**
Configure write buffer chunk size.
Default is 4096.
eeprom->manufacturer = NULL;
if (manufacturer)
{
- eeprom->manufacturer = malloc(strlen(manufacturer)+1);
+ eeprom->manufacturer = (char *)malloc(strlen(manufacturer)+1);
if (eeprom->manufacturer)
strcpy(eeprom->manufacturer, manufacturer);
}
eeprom->product = NULL;
if(product)
{
- eeprom->product = malloc(strlen(product)+1);
+ eeprom->product = (char *)malloc(strlen(product)+1);
if (eeprom->product)
strcpy(eeprom->product, product);
}
default:
ftdi_error_return(-3, "Unknown chip type");
}
- eeprom->product = malloc(strlen(default_product) +1);
+ eeprom->product = (char *)malloc(strlen(default_product) +1);
if (eeprom->product)
strcpy(eeprom->product, default_product);
}
eeprom->serial = NULL;
if (serial)
{
- eeprom->serial = malloc(strlen(serial)+1);
+ eeprom->serial = (char *)malloc(strlen(serial)+1);
if (eeprom->serial)
strcpy(eeprom->serial, serial);
}
{
eeprom->max_power = 90;
eeprom->size = 0x100;
- eeprom->cbus_function[0] = CBUSH_TXDEN;
- eeprom->cbus_function[1] = CBUSH_RXLED;
- eeprom->cbus_function[2] = CBUSH_TXLED;
- eeprom->cbus_function[3] = CBUSH_SLEEP;
+ eeprom->cbus_function[0] = CBUSX_TXDEN;
+ eeprom->cbus_function[1] = CBUSX_RXLED;
+ eeprom->cbus_function[2] = CBUSX_TXLED;
+ eeprom->cbus_function[3] = CBUSX_SLEEP;
}
else
{
{
if (eeprom->manufacturer)
free (eeprom->manufacturer);
- eeprom->manufacturer = malloc(strlen(manufacturer)+1);
+ eeprom->manufacturer = (char *)malloc(strlen(manufacturer)+1);
if (eeprom->manufacturer)
strcpy(eeprom->manufacturer, manufacturer);
}
{
if (eeprom->product)
free (eeprom->product);
- eeprom->product = malloc(strlen(product)+1);
+ eeprom->product = (char *)malloc(strlen(product)+1);
if (eeprom->product)
strcpy(eeprom->product, product);
}
{
if (eeprom->serial)
free (eeprom->serial);
- eeprom->serial = malloc(strlen(serial)+1);
+ eeprom->serial = (char *)malloc(strlen(serial)+1);
if (eeprom->serial)
{
strcpy(eeprom->serial, serial);
}
-/*FTD2XX doesn't check for values not fitting in the ACBUS Signal oprtions*/
+/*FTD2XX doesn't check for values not fitting in the ACBUS Signal options*/
void set_ft232h_cbus(struct ftdi_eeprom *eeprom, unsigned char * output)
{
int i;
default: return 0;
}
}
+ case TYPE_R:
+ {
+ switch (type)
+ {
+ case CHANNEL_IS_UART : return 0;
+ case CHANNEL_IS_FIFO : return 0x01;
+ default: return 0;
+ }
+ }
case TYPE_230X: /* FT230X is only UART */
default: return 0;
}
unsigned char i, j, eeprom_size_mask;
unsigned short checksum, value;
unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
- int user_area_size;
+ int user_area_size, free_start, free_end;
struct ftdi_eeprom *eeprom;
unsigned char * output;
{
case TYPE_AM:
case TYPE_BM:
+ case TYPE_R:
user_area_size = 96; // base size for strings (total of 48 characters)
break;
case TYPE_2232C:
user_area_size = 90; // two extra config bytes and 4 bytes PnP stuff
break;
- case TYPE_R:
case TYPE_230X:
user_area_size = 88; // four extra config bytes + 4 bytes PnP stuff
break;
}
/* Wrap around 0x80 for 128 byte EEPROMS (Internale and 93x46) */
eeprom_size_mask = eeprom->size -1;
+ free_end = i & eeprom_size_mask;
// Addr 0E: Offset of the manufacturer string + 0x80, calculated later
// Addr 0F: Length of manufacturer string
case TYPE_BM:
output[0x0C] = eeprom->usb_version & 0xff;
output[0x0D] = (eeprom->usb_version>>8) & 0xff;
- if (eeprom->use_usb_version == USE_USB_VERSION_BIT)
+ if (eeprom->use_usb_version)
output[0x0A] |= USE_USB_VERSION_BIT;
else
output[0x0A] &= ~USE_USB_VERSION_BIT;
output[0x0A] |= 0x4;
else
output[0x0A] &= ~0x4;
- if (eeprom->use_usb_version == USE_USB_VERSION_BIT)
+ if (eeprom->use_usb_version)
output[0x0A] |= USE_USB_VERSION_BIT;
else
output[0x0A] &= ~USE_USB_VERSION_BIT;
output[0x14] = eeprom->chip;
break;
case TYPE_R:
+ output[0x00] = type2bit(eeprom->channel_a_type, TYPE_R);
if (eeprom->high_current == HIGH_CURRENT_DRIVE_R)
output[0x00] |= HIGH_CURRENT_DRIVE_R;
+ if (eeprom->external_oscillator)
+ output[0x00] |= 0x02;
output[0x01] = 0x40; /* Hard coded Endpoint Size*/
if (eeprom->suspend_pull_downs)
output[0x0C] = eeprom->usb_version & 0xff;
output[0x0D] = (eeprom->usb_version>>8) & 0xff;
- if (eeprom->cbus_function[0] > CBUS_BB)
+ if (eeprom->cbus_function[0] > CBUS_BB_RD)
output[0x14] = CBUS_TXLED;
else
output[0x14] = eeprom->cbus_function[0];
- if (eeprom->cbus_function[1] > CBUS_BB)
+ if (eeprom->cbus_function[1] > CBUS_BB_RD)
output[0x14] |= CBUS_RXLED<<4;
else
output[0x14] |= eeprom->cbus_function[1]<<4;
- if (eeprom->cbus_function[2] > CBUS_BB)
+ if (eeprom->cbus_function[2] > CBUS_BB_RD)
output[0x15] = CBUS_TXDEN;
else
output[0x15] = eeprom->cbus_function[2];
- if (eeprom->cbus_function[3] > CBUS_BB)
+ if (eeprom->cbus_function[3] > CBUS_BB_RD)
output[0x15] |= CBUS_PWREN<<4;
else
output[0x15] |= eeprom->cbus_function[3]<<4;
break;
}
+ /* First address without use */
+ free_start = 0;
+ switch (ftdi->type)
+ {
+ case TYPE_230X:
+ free_start += 2;
+ case TYPE_232H:
+ free_start += 6;
+ case TYPE_2232H:
+ case TYPE_4232H:
+ free_start += 2;
+ case TYPE_R:
+ free_start += 2;
+ case TYPE_2232C:
+ free_start++;
+ case TYPE_AM:
+ case TYPE_BM:
+ free_start += 0x14;
+ }
+
+ /* Arbitrary user data */
+ if (eeprom->user_data && eeprom->user_data_size >= 0)
+ {
+ if (eeprom->user_data_addr < free_start)
+ fprintf(stderr,"Warning, user data starts inside the generated data!\n");
+ if (eeprom->user_data_addr + eeprom->user_data_size >= free_end)
+ fprintf(stderr,"Warning, user data overlaps the strings area!\n");
+ if (eeprom->user_data_addr + eeprom->user_data_size > eeprom->size)
+ ftdi_error_return(-1,"eeprom size exceeded");
+ memcpy(output + eeprom->user_data_addr, eeprom->user_data, eeprom->user_data_size);
+ }
+
// calculate checksum
checksum = 0xAAAA;
}
return 0;
}
+/* Decode 230X / 232R type chips invert bits
+ * Prints directly to stdout.
+*/
+static void print_inverted_bits(int invert)
+{
+ const char *r_bits[] = {"TXD","RXD","RTS","CTS","DTR","DSR","DCD","RI"};
+ int i;
+
+ fprintf(stdout,"Inverted bits:");
+ for (i=0; i<8; i++)
+ if ((invert & (1<<i)) == (1<<i))
+ fprintf(stdout," %s",r_bits[i]);
+
+ fprintf(stdout,"\n");
+}
/**
Decode binary EEPROM image into an ftdi_eeprom structure.
eeprom->in_is_isochronous = buf[0x0A]&0x01;
eeprom->out_is_isochronous = buf[0x0A]&0x02;
eeprom->suspend_pull_downs = buf[0x0A]&0x04;
- eeprom->use_serial = (buf[0x0A] & USE_SERIAL_NUM)?1:0;
- eeprom->use_usb_version = buf[0x0A] & USE_USB_VERSION_BIT;
+ eeprom->use_serial = !!(buf[0x0A] & USE_SERIAL_NUM);
+ eeprom->use_usb_version = !!(buf[0x0A] & USE_USB_VERSION_BIT);
// Addr 0C: USB version low byte when 0x0A
// Addr 0D: USB version high byte when 0x0A
free(eeprom->manufacturer);
if (manufacturer_size > 0)
{
- eeprom->manufacturer = malloc(manufacturer_size);
+ eeprom->manufacturer = (char *)malloc(manufacturer_size);
if (eeprom->manufacturer)
{
// Decode manufacturer
product_size = buf[0x11]/2;
if (product_size > 0)
{
- eeprom->product = malloc(product_size);
+ eeprom->product = (char *)malloc(product_size);
if (eeprom->product)
{
// Decode product name
serial_size = buf[0x13]/2;
if (serial_size > 0)
{
- eeprom->serial = malloc(serial_size);
+ eeprom->serial = (char *)malloc(serial_size);
if (eeprom->serial)
{
// Decode serial
/* TYPE_R flags D2XX, not VCP as all others*/
eeprom->channel_a_driver = ~buf[0x00] & DRIVER_VCP;
eeprom->high_current = buf[0x00] & HIGH_CURRENT_DRIVE_R;
+ eeprom->external_oscillator = buf[0x00] & 0x02;
if ( (buf[0x01]&0x40) != 0x40)
fprintf(stderr,
"TYPE_R EEPROM byte[0x01] Bit 6 unexpected Endpoint size."
if (verbose)
{
- char *channel_mode[] = {"UART", "FIFO", "CPU", "OPTO", "FT1284"};
+ const char *channel_mode[] = {"UART", "FIFO", "CPU", "OPTO", "FT1284"};
fprintf(stdout, "VID: 0x%04x\n",eeprom->vendor_id);
fprintf(stdout, "PID: 0x%04x\n",eeprom->product_id);
fprintf(stdout, "Release: 0x%04x\n",eeprom->release_number);
if (eeprom->serial)
fprintf(stdout, "Serial: %s\n",eeprom->serial);
fprintf(stdout, "Checksum : %04x\n", checksum);
- if (ftdi->type == TYPE_R)
+ if (ftdi->type == TYPE_R) {
fprintf(stdout, "Internal EEPROM\n");
+ fprintf(stdout,"Oscillator: %s\n", eeprom->external_oscillator?"External":"Internal");
+ }
else if (eeprom->chip >= 0x46)
fprintf(stdout, "Attached EEPROM: 93x%02x\n", eeprom->chip);
if (eeprom->suspend_dbus7)
(eeprom->channel_b_driver)?" VCP":"",
(eeprom->high_current_b)?" High Current IO":"");
if (((ftdi->type == TYPE_BM) || (ftdi->type == TYPE_2232C)) &&
- eeprom->use_usb_version == USE_USB_VERSION_BIT)
+ eeprom->use_usb_version)
fprintf(stdout,"Use explicit USB Version %04x\n",eeprom->usb_version);
if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H))
}
else if (ftdi->type == TYPE_232H)
{
- char *cbush_mux[] = {"TRISTATE","RXLED","TXLED", "TXRXLED","PWREN",
+ const char *cbush_mux[] = {"TRISTATE","TXLED","RXLED", "TXRXLED","PWREN",
"SLEEP","DRIVE_0","DRIVE_1","IOMODE","TXDEN",
"CLK30","CLK15","CLK7_5"
};
}
else if (ftdi->type == TYPE_230X)
{
- char *cbush_mux[] = {"TRISTATE","RXLED","TXLED", "TXRXLED","PWREN",
+ const char *cbusx_mux[] = {"TRISTATE","TXLED","RXLED", "TXRXLED","PWREN",
"SLEEP","DRIVE_0","DRIVE_1","IOMODE","TXDEN",
"CLK24","CLK12","CLK6","BAT_DETECT","BAT_DETECT#",
"I2C_TXE#", "I2C_RXF#", "VBUS_SENSE", "BB_WR#",
(eeprom->group1_slew)?" Slow Slew":"");
for (i=0; i<4; i++)
{
- if (eeprom->cbus_function[i]<= CBUSH_AWAKE)
- fprintf(stdout,"CBUS%d Function: %s\n", i, cbush_mux[eeprom->cbus_function[i]]);
+ if (eeprom->cbus_function[i]<= CBUSX_AWAKE)
+ fprintf(stdout,"CBUS%d Function: %s\n", i, cbusx_mux[eeprom->cbus_function[i]]);
}
- if(eeprom->invert )
- print_inverted_bits(eeprom->invert);
+
+ if (eeprom->invert)
+ print_inverted_bits(eeprom->invert);
}
if (ftdi->type == TYPE_R)
{
- char *cbus_mux[] = {"TXDEN","PWREN","RXLED", "TXLED","TX+RXLED",
+ const char *cbus_mux[] = {"TXDEN","PWREN","RXLED", "TXLED","TX+RXLED",
"SLEEP","CLK48","CLK24","CLK12","CLK6",
"IOMODE","BB_WR","BB_RD"
};
- char *cbus_BB[] = {"RXF","TXE","RD", "WR"};
+ const char *cbus_BB[] = {"RXF","TXE","RD", "WR"};
if (eeprom->invert)
- print_inverted_bits(eeprom->invert);
+ print_inverted_bits(eeprom->invert);
for (i=0; i<5; i++)
{
- if (eeprom->cbus_function[i]<CBUS_BB)
+ if (eeprom->cbus_function[i]<=CBUS_BB_RD)
fprintf(stdout,"C%d Function: %s\n", i,
cbus_mux[eeprom->cbus_function[i]]);
else
*value = ftdi->eeprom->cbus_function[8];
break;
case CBUS_FUNCTION_9:
- *value = ftdi->eeprom->cbus_function[8];
+ *value = ftdi->eeprom->cbus_function[9];
break;
case HIGH_CURRENT:
*value = ftdi->eeprom->high_current;
case CHIP_SIZE:
*value = ftdi->eeprom->size;
break;
+ case EXTERNAL_OSCILLATOR:
+ *value = ftdi->eeprom->external_oscillator;
+ break;
default:
ftdi_error_return(-1, "Request for unknown EEPROM value");
}
case CHIP_SIZE:
ftdi_error_return(-2, "EEPROM Value can't be changed");
break;
+ case EXTERNAL_OSCILLATOR:
+ ftdi->eeprom->external_oscillator = value;
+ break;
+ case USER_DATA_ADDR:
+ ftdi->eeprom->user_data_addr = value;
+ break;
default :
ftdi_error_return(-1, "Request to unknown EEPROM value");
\param size Size of buffer
\retval 0: All fine
- \retval -1: struct ftdi_contxt or ftdi_eeprom of buf missing
+ \retval -1: struct ftdi_context or ftdi_eeprom or buf missing
*/
int ftdi_set_eeprom_buf(struct ftdi_context *ftdi, const unsigned char * buf, int size)
{
return 0;
}
+/** Set the EEPROM user data content from the user-supplied prefilled buffer
+
+ \param ftdi pointer to ftdi_context
+ \param buf buffer to read EEPROM user data content
+ \param size Size of buffer
+
+ \retval 0: All fine
+ \retval -1: struct ftdi_context or ftdi_eeprom or buf missing
+*/
+int ftdi_set_eeprom_user_data(struct ftdi_context *ftdi, const char * buf, int size)
+{
+ if (!ftdi || !(ftdi->eeprom) || !buf)
+ ftdi_error_return(-1, "No appropriate structure");
+
+ ftdi->eeprom->user_data_size = size;
+ ftdi->eeprom->user_data = buf;
+ return 0;
+}
+
/**
Read eeprom location
*/
int ftdi_read_eeprom_location (struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val)
{
+ unsigned char buf[2];
+
if (ftdi == NULL || ftdi->usb_dev == NULL)
ftdi_error_return(-2, "USB device unavailable");
- if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, eeprom_addr, (unsigned char *)eeprom_val, 2, ftdi->usb_read_timeout) != 2)
+ if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, eeprom_addr, buf, 2, ftdi->usb_read_timeout) != 2)
ftdi_error_return(-1, "reading eeprom failed");
+ *eeprom_val = (0xff & buf[0]) | (buf[1] << 8);
+
return 0;
}
\retval Pointer to error string
*/
-char *ftdi_get_error_string (struct ftdi_context *ftdi)
+const char *ftdi_get_error_string (struct ftdi_context *ftdi)
{
if (ftdi == NULL)
return "";
return ftdi->error_str;
}
-void print_inverted_bits(int invert)
-{
- int i;
- char *r_bits[] = {"TXD","RXD","RTS","CTS","DTR","DSR","DCD","RI"};
- fprintf(stdout,"Inverted bits:");
- for (i=0; i<8; i++)
- if ((invert & (1<<i)) == (1<<i))
- fprintf(stdout," %s",r_bits[i]);
- fprintf(stdout,"\n");
-}
-
/* @} end of doxygen libftdi group */
git://developer.intra2net.com / libftdi / blobdiff