ftdi.c - description
-------------------
begin : Fri Apr 4 2003
- copyright : (C) 2003-2010 by Intra2net AG
+ copyright : (C) 2003-2011 by Intra2net AG and the libftdi developers
email : opensource@intra2net.com
***************************************************************************/
{
if (ftdi && ftdi->usb_dev)
{
- libusb_close (ftdi->usb_dev);
- ftdi->usb_dev = NULL;
+ libusb_close (ftdi->usb_dev);
+ ftdi->usb_dev = NULL;
}
}
\retval 0: all fine
\retval -1: couldn't allocate read buffer
\retval -2: couldn't allocate struct buffer
+ \retval -3: libusb_init() failed
\remark This should be called before all functions
*/
ftdi->readbuffer_remaining = 0;
ftdi->writebuffer_chunksize = 4096;
ftdi->max_packet_size = 0;
+ ftdi->error_str = NULL;
+ ftdi->module_detach_mode = AUTO_DETACH_SIO_MODULE;
- ftdi->interface = 0;
- ftdi->index = 0;
- ftdi->in_ep = 0x02;
- ftdi->out_ep = 0x81;
- ftdi->bitbang_mode = 1; /* when bitbang is enabled this holds the number of the mode */
+ if (libusb_init(&ftdi->usb_ctx) < 0)
+ ftdi_error_return(-3, "libusb_init() failed");
- ftdi->error_str = NULL;
+ ftdi_set_interface(ftdi, INTERFACE_ANY);
+ ftdi->bitbang_mode = 1; /* when bitbang is enabled this holds the number of the mode */
if (eeprom == 0)
ftdi_error_return(-2, "Can't malloc struct ftdi_eeprom");
{
case INTERFACE_ANY:
case INTERFACE_A:
- /* ftdi_usb_open_desc cares to set the right index, depending on the found chip */
+ ftdi->interface = 0;
+ ftdi->index = INTERFACE_A;
+ ftdi->in_ep = 0x02;
+ ftdi->out_ep = 0x81;
break;
case INTERFACE_B:
ftdi->interface = 1;
free(ftdi->eeprom);
ftdi->eeprom = NULL;
}
- libusb_exit(ftdi->usb_ctx);
+
+ if (ftdi->usb_ctx)
+ {
+ libusb_exit(ftdi->usb_ctx);
+ ftdi->usb_ctx = NULL;
+ }
}
/**
\retval >0: number of devices found
\retval -3: out of memory
- \retval -4: libusb_init() failed
\retval -5: libusb_get_device_list() failed
\retval -6: libusb_get_device_descriptor() failed
*/
int count = 0;
int i = 0;
- if (libusb_init(&ftdi->usb_ctx) < 0)
- ftdi_error_return(-4, "libusb_init() failed");
-
if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
ftdi_error_return(-5, "libusb_get_device_list() failed");
struct libusb_device_descriptor desc;
if (libusb_get_device_descriptor(dev, &desc) < 0)
- ftdi_error_return(-6, "libusb_get_device_descriptor() failed");
+ ftdi_error_return_free_device_list(-6, "libusb_get_device_descriptor() failed", devs);
if (desc.idVendor == vendor && desc.idProduct == product)
{
*curdev = (struct ftdi_device_list*)malloc(sizeof(struct ftdi_device_list));
if (!*curdev)
- ftdi_error_return(-3, "out of memory");
-
+ ftdi_error_return_free_device_list(-3, "out of memory", devs);
+
(*curdev)->next = NULL;
(*curdev)->dev = dev;
count++;
}
}
-
+ libusb_free_device_list(devs,1);
return count;
}
// Determine maximum packet size. Init with default value.
// New hi-speed devices from FTDI use a packet size of 512 bytes
// but could be connected to a normal speed USB hub -> 64 bytes packet size.
- if (ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H)
+ if (ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H || ftdi->type == TYPE_232H )
packet_size = 512;
else
packet_size = 64;
\retval -8: ftdi context invalid
\retval -9: libusb_get_device_descriptor() failed
\retval -10: libusb_get_config_descriptor() failed
- \retval -11: libusb_etach_kernel_driver() failed
+ \retval -11: libusb_detach_kernel_driver() failed
\retval -12: libusb_get_configuration() failed
*/
int ftdi_usb_open_dev(struct ftdi_context *ftdi, libusb_device *dev)
// if usb_set_configuration() or usb_claim_interface() fails as the
// detach operation might be denied and everything still works fine.
// Likely scenario is a static ftdi_sio kernel module.
- if (libusb_detach_kernel_driver(ftdi->usb_dev, ftdi->interface) !=0)
- detach_errno = errno;
+ if (ftdi->module_detach_mode == AUTO_DETACH_SIO_MODULE)
+ {
+ if (libusb_detach_kernel_driver(ftdi->usb_dev, ftdi->interface) !=0)
+ detach_errno = errno;
+ }
if (libusb_get_configuration (ftdi->usb_dev, &cfg) < 0)
ftdi_error_return(-12, "libusb_get_configuration () failed");
if (libusb_set_configuration(ftdi->usb_dev, cfg0) < 0)
{
ftdi_usb_close_internal (ftdi);
- if(detach_errno == EPERM)
+ if (detach_errno == EPERM)
{
ftdi_error_return(-8, "inappropriate permissions on device!");
}
if (libusb_claim_interface(ftdi->usb_dev, ftdi->interface) < 0)
{
ftdi_usb_close_internal (ftdi);
- if(detach_errno == EPERM)
+ if (detach_errno == EPERM)
{
ftdi_error_return(-8, "inappropriate permissions on device!");
}
// Try to guess chip type
// Bug in the BM type chips: bcdDevice is 0x200 for serial == 0
if (desc.bcdDevice == 0x400 || (desc.bcdDevice == 0x200
- && desc.iSerialNumber == 0))
+ && desc.iSerialNumber == 0))
ftdi->type = TYPE_BM;
else if (desc.bcdDevice == 0x200)
ftdi->type = TYPE_AM;
ftdi->type = TYPE_2232H;
else if (desc.bcdDevice == 0x800)
ftdi->type = TYPE_4232H;
-
- // Set default interface on dual/quad type chips
- switch(ftdi->type)
- {
- case TYPE_2232C:
- case TYPE_2232H:
- case TYPE_4232H:
- if (!ftdi->index)
- ftdi->index = INTERFACE_A;
- break;
- default:
- break;
- }
+ else if (desc.bcdDevice == 0x900)
+ ftdi->type = TYPE_232H;
// Determine maximum packet size
ftdi->max_packet_size = _ftdi_determine_max_packet_size(ftdi, dev);
\retval -11: ftdi context invalid
*/
int ftdi_usb_open_desc_index(struct ftdi_context *ftdi, int vendor, int product,
- const char* description, const char* serial, unsigned int index)
+ const char* description, const char* serial, unsigned int index)
{
libusb_device *dev;
libusb_device **devs;
char string[256];
int i = 0;
- if (libusb_init(&ftdi->usb_ctx) < 0)
- ftdi_error_return(-11, "libusb_init() failed");
-
if (ftdi == NULL)
ftdi_error_return(-11, "ftdi context invalid");
+ if (libusb_init(&ftdi->usb_ctx) < 0)
+ ftdi_error_return(-11, "libusb_init() failed");
+
if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
ftdi_error_return(-12, "libusb_get_device_list() failed");
{
if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iProduct, (unsigned char *)string, sizeof(string)) < 0)
{
- libusb_close (ftdi->usb_dev);
+ ftdi_usb_close_internal (ftdi);
ftdi_error_return_free_device_list(-8, "unable to fetch product description", devs);
}
if (strncmp(string, description, sizeof(string)) != 0)
{
- libusb_close (ftdi->usb_dev);
+ ftdi_usb_close_internal (ftdi);
continue;
}
}
ftdi_usb_close_internal (ftdi);
- if (index > 0)
- {
- index--;
- continue;
- }
+ if (index > 0)
+ {
+ index--;
+ continue;
+ }
res = ftdi_usb_open_dev(ftdi, dev);
libusb_free_device_list(devs,1);
{
libusb_device *dev;
libusb_device **devs;
- unsigned int bus_number, device_address;
- int i = 0;
+ unsigned int bus_number, device_address;
+ int i = 0;
if (libusb_init (&ftdi->usb_ctx) < 0)
- ftdi_error_return(-1, "libusb_init() failed");
+ ftdi_error_return(-1, "libusb_init() failed");
- if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
- ftdi_error_return(-2, "libusb_get_device_list() failed");
+ if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
+ ftdi_error_return(-2, "libusb_get_device_list() failed");
/* XXX: This doesn't handle symlinks/odd paths/etc... */
if (sscanf (description + 2, "%u/%u", &bus_number, &device_address) != 2)
- ftdi_error_return_free_device_list(-11, "illegal description format", devs);
+ ftdi_error_return_free_device_list(-11, "illegal description format", devs);
- while ((dev = devs[i++]) != NULL)
+ while ((dev = devs[i++]) != NULL)
{
int ret;
- if (bus_number == libusb_get_bus_number (dev)
- && device_address == libusb_get_device_address (dev))
+ if (bus_number == libusb_get_bus_number (dev)
+ && device_address == libusb_get_device_address (dev))
{
ret = ftdi_usb_open_dev(ftdi, dev);
libusb_free_device_list(devs,1);
if (actual_length > packet_size - 2)
{
for (i = 1; i < num_of_chunks; i++)
- memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
- ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
- packet_size - 2);
+ memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
+ ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
+ packet_size - 2);
if (chunk_remains > 2)
{
memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
actual_length -= 2*num_of_chunks;
}
else
- actual_length -= 2*(num_of_chunks-1)+chunk_remains;
+ actual_length -= 2*(num_of_chunks-1)+chunk_remains;
}
if (actual_length > 0)
{
struct ftdi_transfer_control *tc = (struct ftdi_transfer_control *) transfer->user_data;
struct ftdi_context *ftdi = tc->ftdi;
-
+
tc->offset += transfer->actual_length;
-
+
if (tc->offset == tc->size)
{
tc->completed = 1;
struct ftdi_transfer_control *ftdi_write_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
{
struct ftdi_transfer_control *tc;
- struct libusb_transfer *transfer = libusb_alloc_transfer(0);
+ struct libusb_transfer *transfer;
int write_size, ret;
if (ftdi == NULL || ftdi->usb_dev == NULL)
- {
- libusb_free_transfer(transfer);
return NULL;
- }
tc = (struct ftdi_transfer_control *) malloc (sizeof (*tc));
+ if (!tc)
+ return NULL;
- if (!tc || !transfer)
+ transfer = libusb_alloc_transfer(0);
+ if (!transfer)
+ {
+ free(tc);
return NULL;
+ }
tc->ftdi = ftdi;
tc->completed = 0;
tc->offset = 0;
if (size < ftdi->writebuffer_chunksize)
- write_size = size;
+ write_size = size;
else
- write_size = ftdi->writebuffer_chunksize;
+ write_size = ftdi->writebuffer_chunksize;
libusb_fill_bulk_transfer(transfer, ftdi->usb_dev, ftdi->in_ep, buf,
write_size, ftdi_write_data_cb, tc,
if (ret < 0)
{
libusb_free_transfer(transfer);
- tc->completed = 1;
- tc->transfer = NULL;
+ free(tc);
return NULL;
}
tc->transfer = transfer;
if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_POLL_MODEM_STATUS_REQUEST, 0, ftdi->index, (unsigned char *)usb_val, 2, ftdi->usb_read_timeout) != 2)
ftdi_error_return(-1, "getting modem status failed");
- *status = (usb_val[1] << 8) | usb_val[0];
+ *status = (usb_val[1] << 8) | (usb_val[0] & 0xFF);
return 0;
}
\retval -2: No struct ftdi_eeprom
*/
int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char * manufacturer,
- char * product, char * serial)
+ char * product, char * serial)
{
struct ftdi_eeprom *eeprom;
ftdi_error_return(-1, "No struct ftdi_context");
if (ftdi->eeprom == NULL)
- ftdi_error_return(-2,"No struct ftdi_eeprom");
+ ftdi_error_return(-2,"No struct ftdi_eeprom");
eeprom = ftdi->eeprom;
memset(eeprom, 0, sizeof(struct ftdi_eeprom));
eeprom->vendor_id = 0x0403;
eeprom->use_serial = USE_SERIAL_NUM;
- if((ftdi->type == TYPE_AM) || (ftdi->type == TYPE_BM) ||
- (ftdi->type == TYPE_R))
+ if ((ftdi->type == TYPE_AM) || (ftdi->type == TYPE_BM) ||
+ (ftdi->type == TYPE_R))
eeprom->product_id = 0x6001;
+ else if (ftdi->type == TYPE_4232H)
+ eeprom->product_id = 0x6011;
+ else if (ftdi->type == TYPE_232H)
+ eeprom->product_id = 0x6014;
else
eeprom->product_id = 0x6010;
if (ftdi->type == TYPE_AM)
if (eeprom->product)
free (eeprom->product);
eeprom->product = NULL;
+ if(product)
{
eeprom->product = malloc(strlen(product)+1);
if (eeprom->product)
}
- if(ftdi->type == TYPE_R)
+ if (ftdi->type == TYPE_R)
{
eeprom->max_power = 90;
eeprom->size = 0x80;
eeprom->cbus_function[4] = CBUS_SLEEP;
}
else
+ {
+ if(ftdi->type == TYPE_232H)
+ {
+ int i;
+ for (i=0; i<10; i++)
+ eeprom->cbus_function[i] = CBUSH_TRISTATE;
+ }
eeprom->size = -1;
+ }
return 0;
}
+/*FTD2XX doesn't check for values not fitting in the ACBUS Signal oprtions*/
+void set_ft232h_cbus(struct ftdi_eeprom *eeprom, unsigned char * output)
+{
+ int i;
+ for(i=0; i<5;i++)
+ {
+ int mode_low, mode_high;
+ if (eeprom->cbus_function[2*i]> CBUSH_CLK7_5)
+ mode_low = CBUSH_TRISTATE;
+ else
+ mode_low = eeprom->cbus_function[2*i];
+ if (eeprom->cbus_function[2*i+1]> CBUSH_CLK7_5)
+ mode_high = CBUSH_TRISTATE;
+ else
+ mode_high = eeprom->cbus_function[2*i];
+ output[0x18+i] = mode_high <<4 | mode_low;
+ }
+}
/**
Build binary buffer from ftdi_eeprom structure.
Output is suitable for ftdi_write_eeprom().
\retval >=0: size of eeprom user area in bytes
\retval -1: eeprom size (128 bytes) exceeded by custom strings
- \retval -2: Invalid eeprom pointer
- \retval -3: Invalid cbus function setting
- \retval -4: Chip doesn't support invert
- \retval -5: Chip doesn't support high current drive
+ \retval -2: Invalid eeprom or ftdi pointer
+ \retval -3: Invalid cbus function setting (FIXME: Not in the code?)
+ \retval -4: Chip doesn't support invert (FIXME: Not in the code?)
+ \retval -5: Chip doesn't support high current drive (FIXME: Not in the code?)
\retval -6: No connected EEPROM or EEPROM Type unknown
*/
int ftdi_eeprom_build(struct ftdi_context *ftdi)
eeprom= ftdi->eeprom;
output = eeprom->buf;
- if(eeprom->chip == -1)
- ftdi_error_return(-5,"No connected EEPROM or EEPROM type unknown");
+ if (eeprom->chip == -1)
+ ftdi_error_return(-6,"No connected EEPROM or EEPROM type unknown");
if ((eeprom->chip == 0x56) || (eeprom->chip == 0x66))
eeprom->size = 0x100;
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;
+ user_area_size = 90; // two extra config bytes and 4 bytes PnP stuff
+ break;
case TYPE_R:
- user_area_size = 88; // four extra config bytes + 4 bytes PnP stuff
- break;
+ user_area_size = 88; // four extra config bytes + 4 bytes PnP stuff
+ break;
case TYPE_2232H: // six extra config bytes + 4 bytes PnP stuff
case TYPE_4232H:
- user_area_size = 86;
- break;
+ user_area_size = 86;
+ break;
+ default:
+ user_area_size = 0;
+ break;
}
user_area_size -= (manufacturer_size + product_size + serial_size) * 2;
case TYPE_R:
output[0x07] = 0x06;
break;
- case TYPE_2232H:
+ case TYPE_2232H:
output[0x07] = 0x07;
break;
- case TYPE_4232H:
+ case TYPE_4232H:
output[0x07] = 0x08;
break;
+ case TYPE_232H:
+ output[0x07] = 0x09;
+ break;
default:
output[0x07] = 0x00;
}
// Addr 09: Max power consumption: max power = value * 2 mA
output[0x09] = eeprom->max_power>>1;
- if(ftdi->type != TYPE_AM)
+ if (ftdi->type != TYPE_AM)
{
// Addr 0A: Chip configuration
// Bit 7: 0 - reserved
// Bit 6: 0 - reserved
// Bit 5: 0 - reserved
- // Bit 4: 1 - Change USB version
+ // Bit 4: 1 - Change USB version
// Bit 3: 1 - Use the serial number string
// Bit 2: 1 - Enable suspend pull downs for lower power
// Bit 1: 1 - Out EndPoint is Isochronous
// Dynamic content
// Strings start at 0x94 (TYPE_AM, TYPE_BM)
// 0x96 (TYPE_2232C), 0x98 (TYPE_R) and 0x9a (TYPE_x232H)
+ // 0xa0 (TYPE_232H)
i = 0;
- switch(ftdi->type)
- {
- case TYPE_2232H:
- case TYPE_4232H:
- i += 2;
- case TYPE_R:
- i += 2;
- case TYPE_2232C:
- i += 2;
- case TYPE_AM:
- case TYPE_BM:
- i += 0x94;
+ switch (ftdi->type)
+ {
+ case TYPE_232H:
+ i += 2;
+ case TYPE_2232H:
+ case TYPE_4232H:
+ i += 2;
+ case TYPE_R:
+ i += 2;
+ case TYPE_2232C:
+ i += 2;
+ case TYPE_AM:
+ case TYPE_BM:
+ i += 0x94;
}
/* Wrap around 0x80 for 128 byte EEPROMS (Internale and 93x46) */
eeprom_size_mask = eeprom->size -1;
output[0x13] = serial_size*2 + 2;
- if(ftdi->type > TYPE_AM) /* use_serial not used in AM devices */
+ if (ftdi->type > TYPE_AM) /* use_serial not used in AM devices */
{
if (eeprom->use_serial == USE_SERIAL_NUM )
output[0x0A] |= USE_SERIAL_NUM;
/* Bytes and Bits specific to (some) types
Write linear, as this allows easier fixing*/
- switch(ftdi->type)
- {
- case TYPE_AM:
- break;
- 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)
- output[0x0A] |= USE_USB_VERSION_BIT;
- else
- output[0x0A] &= ~USE_USB_VERSION_BIT;
+ switch (ftdi->type)
+ {
+ case TYPE_AM:
+ break;
+ 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)
+ output[0x0A] |= USE_USB_VERSION_BIT;
+ else
+ output[0x0A] &= ~USE_USB_VERSION_BIT;
- break;
- case TYPE_2232C:
+ break;
+ case TYPE_2232C:
- output[0x00] = (eeprom->channel_a_type);
- if ( eeprom->channel_a_driver == DRIVER_VCP)
- output[0x00] |= DRIVER_VCP;
- else
- output[0x00] &= ~DRIVER_VCP;
+ output[0x00] = (1<<(eeprom->channel_a_type)) & 0x7;
+ if ( eeprom->channel_a_driver == DRIVER_VCP)
+ output[0x00] |= DRIVER_VCP;
+ else
+ output[0x00] &= ~DRIVER_VCP;
- if ( eeprom->high_current_a == HIGH_CURRENT_DRIVE)
- output[0x00] |= HIGH_CURRENT_DRIVE;
- else
- output[0x00] &= ~HIGH_CURRENT_DRIVE;
+ if ( eeprom->high_current_a == HIGH_CURRENT_DRIVE)
+ output[0x00] |= HIGH_CURRENT_DRIVE;
+ else
+ output[0x00] &= ~HIGH_CURRENT_DRIVE;
- output[0x01] = (eeprom->channel_b_type);
- if ( eeprom->channel_b_driver == DRIVER_VCP)
- output[0x01] |= DRIVER_VCP;
- else
- output[0x01] &= ~DRIVER_VCP;
+ output[0x01] = (1<<(eeprom->channel_b_type)) & 0x7;
+ if ( eeprom->channel_b_driver == DRIVER_VCP)
+ output[0x01] |= DRIVER_VCP;
+ else
+ output[0x01] &= ~DRIVER_VCP;
- if ( eeprom->high_current_b == HIGH_CURRENT_DRIVE)
- output[0x01] |= HIGH_CURRENT_DRIVE;
- else
- output[0x01] &= ~HIGH_CURRENT_DRIVE;
+ if ( eeprom->high_current_b == HIGH_CURRENT_DRIVE)
+ output[0x01] |= HIGH_CURRENT_DRIVE;
+ else
+ output[0x01] &= ~HIGH_CURRENT_DRIVE;
- if (eeprom->in_is_isochronous == 1)
- output[0x0A] |= 0x1;
- else
- output[0x0A] &= ~0x1;
- if (eeprom->out_is_isochronous == 1)
- output[0x0A] |= 0x2;
- else
- output[0x0A] &= ~0x2;
- if (eeprom->suspend_pull_downs == 1)
- output[0x0A] |= 0x4;
- else
- output[0x0A] &= ~0x4;
- if (eeprom->use_usb_version == USE_USB_VERSION_BIT)
- output[0x0A] |= USE_USB_VERSION_BIT;
- else
- output[0x0A] &= ~USE_USB_VERSION_BIT;
-
- output[0x0C] = eeprom->usb_version & 0xff;
- output[0x0D] = (eeprom->usb_version>>8) & 0xff;
- output[0x14] = eeprom->chip;
- break;
- case TYPE_R:
- if(eeprom->high_current == HIGH_CURRENT_DRIVE_R)
- output[0x00] |= HIGH_CURRENT_DRIVE_R;
- output[0x01] = 0x40; /* Hard coded Endpoint Size*/
-
- if (eeprom->suspend_pull_downs == 1)
- output[0x0A] |= 0x4;
- else
- output[0x0A] &= ~0x4;
- output[0x0B] = eeprom->invert;
- output[0x0C] = eeprom->usb_version & 0xff;
- output[0x0D] = (eeprom->usb_version>>8) & 0xff;
+ if (eeprom->in_is_isochronous == 1)
+ output[0x0A] |= 0x1;
+ else
+ output[0x0A] &= ~0x1;
+ if (eeprom->out_is_isochronous == 1)
+ output[0x0A] |= 0x2;
+ else
+ output[0x0A] &= ~0x2;
+ if (eeprom->suspend_pull_downs == 1)
+ output[0x0A] |= 0x4;
+ else
+ output[0x0A] &= ~0x4;
+ if (eeprom->use_usb_version == USE_USB_VERSION_BIT)
+ output[0x0A] |= USE_USB_VERSION_BIT;
+ else
+ output[0x0A] &= ~USE_USB_VERSION_BIT;
- if(eeprom->cbus_function[0] > CBUS_BB)
- output[0x14] = CBUS_TXLED;
- else
- output[0x14] = eeprom->cbus_function[0];
+ output[0x0C] = eeprom->usb_version & 0xff;
+ output[0x0D] = (eeprom->usb_version>>8) & 0xff;
+ output[0x14] = eeprom->chip;
+ break;
+ case TYPE_R:
+ if (eeprom->high_current == HIGH_CURRENT_DRIVE_R)
+ output[0x00] |= HIGH_CURRENT_DRIVE_R;
+ output[0x01] = 0x40; /* Hard coded Endpoint Size*/
- if(eeprom->cbus_function[1] > CBUS_BB)
- output[0x14] |= CBUS_RXLED<<4;
- else
- output[0x14] |= eeprom->cbus_function[1]<<4;
+ if (eeprom->suspend_pull_downs == 1)
+ output[0x0A] |= 0x4;
+ else
+ output[0x0A] &= ~0x4;
+ output[0x0B] = eeprom->invert;
+ output[0x0C] = eeprom->usb_version & 0xff;
+ output[0x0D] = (eeprom->usb_version>>8) & 0xff;
- if(eeprom->cbus_function[2] > CBUS_BB)
- output[0x15] = CBUS_TXDEN;
- else
- output[0x15] = eeprom->cbus_function[2];
+ if (eeprom->cbus_function[0] > CBUS_BB)
+ output[0x14] = CBUS_TXLED;
+ else
+ output[0x14] = eeprom->cbus_function[0];
- if(eeprom->cbus_function[3] > CBUS_BB)
- output[0x15] |= CBUS_PWREN<<4;
- else
- output[0x15] |= eeprom->cbus_function[3]<<4;
+ if (eeprom->cbus_function[1] > CBUS_BB)
+ output[0x14] |= CBUS_RXLED<<4;
+ else
+ output[0x14] |= eeprom->cbus_function[1]<<4;
- if(eeprom->cbus_function[4] > CBUS_CLK6)
- output[0x16] = CBUS_SLEEP;
- else
- output[0x16] = eeprom->cbus_function[4];
- break;
- case TYPE_2232H:
- output[0x00] = (eeprom->channel_a_type);
- if ( eeprom->channel_a_driver == DRIVER_VCP)
- output[0x00] |= DRIVER_VCP;
- else
- output[0x00] &= ~DRIVER_VCP;
+ if (eeprom->cbus_function[2] > CBUS_BB)
+ output[0x15] = CBUS_TXDEN;
+ else
+ output[0x15] = eeprom->cbus_function[2];
- output[0x01] = (eeprom->channel_b_type);
- if ( eeprom->channel_b_driver == DRIVER_VCP)
- output[0x01] |= DRIVER_VCP;
- else
- output[0x01] &= ~DRIVER_VCP;
- if(eeprom->suspend_dbus7 == SUSPEND_DBUS7_BIT)
- output[0x01] |= SUSPEND_DBUS7_BIT;
- else
- output[0x01] &= ~SUSPEND_DBUS7_BIT;
+ if (eeprom->cbus_function[3] > CBUS_BB)
+ output[0x15] |= CBUS_PWREN<<4;
+ else
+ output[0x15] |= eeprom->cbus_function[3]<<4;
- if (eeprom->suspend_pull_downs == 1)
- output[0x0A] |= 0x4;
- else
- output[0x0A] &= ~0x4;
+ if (eeprom->cbus_function[4] > CBUS_CLK6)
+ output[0x16] = CBUS_SLEEP;
+ else
+ output[0x16] = eeprom->cbus_function[4];
+ break;
+ case TYPE_2232H:
+ output[0x00] = (1<<(eeprom->channel_a_type)) & 0x7;
+ if ( eeprom->channel_a_driver == DRIVER_VCP)
+ output[0x00] |= DRIVER_VCP;
+ else
+ output[0x00] &= ~DRIVER_VCP;
- if(eeprom->group0_drive > DRIVE_16MA)
- output[0x0c] |= DRIVE_16MA;
- else
- output[0x0c] |= eeprom->group0_drive;
- if (eeprom->group0_schmitt == IS_SCHMITT)
- output[0x0c] |= IS_SCHMITT;
- if (eeprom->group0_slew == SLOW_SLEW)
- output[0x0c] |= SLOW_SLEW;
-
- if(eeprom->group1_drive > DRIVE_16MA)
- output[0x0c] |= DRIVE_16MA<<4;
- else
- output[0x0c] |= eeprom->group1_drive<<4;
- if (eeprom->group1_schmitt == IS_SCHMITT)
- output[0x0c] |= IS_SCHMITT<<4;
- if (eeprom->group1_slew == SLOW_SLEW)
- output[0x0c] |= SLOW_SLEW<<4;
-
- if(eeprom->group2_drive > DRIVE_16MA)
- output[0x0d] |= DRIVE_16MA;
- else
- output[0x0d] |= eeprom->group2_drive;
- if (eeprom->group2_schmitt == IS_SCHMITT)
- output[0x0d] |= IS_SCHMITT;
- if (eeprom->group2_slew == SLOW_SLEW)
- output[0x0d] |= SLOW_SLEW;
-
- if(eeprom->group3_drive > DRIVE_16MA)
- output[0x0d] |= DRIVE_16MA<<4;
- else
- output[0x0d] |= eeprom->group3_drive<<4;
- if (eeprom->group3_schmitt == IS_SCHMITT)
- output[0x0d] |= IS_SCHMITT<<4;
- if (eeprom->group3_slew == SLOW_SLEW)
- output[0x0d] |= SLOW_SLEW<<4;
+ output[0x01] = (1<<(eeprom->channel_b_type)) & 0x7;
+ if ( eeprom->channel_b_driver == DRIVER_VCP)
+ output[0x01] |= DRIVER_VCP;
+ else
+ output[0x01] &= ~DRIVER_VCP;
+ if (eeprom->suspend_dbus7 == SUSPEND_DBUS7_BIT)
+ output[0x01] |= SUSPEND_DBUS7_BIT;
+ else
+ output[0x01] &= ~SUSPEND_DBUS7_BIT;
+
+ if (eeprom->suspend_pull_downs == 1)
+ output[0x0A] |= 0x4;
+ else
+ output[0x0A] &= ~0x4;
+
+ if (eeprom->group0_drive > DRIVE_16MA)
+ output[0x0c] |= DRIVE_16MA;
+ else
+ output[0x0c] |= eeprom->group0_drive;
+ if (eeprom->group0_schmitt == IS_SCHMITT)
+ output[0x0c] |= IS_SCHMITT;
+ if (eeprom->group0_slew == SLOW_SLEW)
+ output[0x0c] |= SLOW_SLEW;
+
+ if (eeprom->group1_drive > DRIVE_16MA)
+ output[0x0c] |= DRIVE_16MA<<4;
+ else
+ output[0x0c] |= eeprom->group1_drive<<4;
+ if (eeprom->group1_schmitt == IS_SCHMITT)
+ output[0x0c] |= IS_SCHMITT<<4;
+ if (eeprom->group1_slew == SLOW_SLEW)
+ output[0x0c] |= SLOW_SLEW<<4;
+
+ if (eeprom->group2_drive > DRIVE_16MA)
+ output[0x0d] |= DRIVE_16MA;
+ else
+ output[0x0d] |= eeprom->group2_drive;
+ if (eeprom->group2_schmitt == IS_SCHMITT)
+ output[0x0d] |= IS_SCHMITT;
+ if (eeprom->group2_slew == SLOW_SLEW)
+ output[0x0d] |= SLOW_SLEW;
+
+ if (eeprom->group3_drive > DRIVE_16MA)
+ output[0x0d] |= DRIVE_16MA<<4;
+ else
+ output[0x0d] |= eeprom->group3_drive<<4;
+ if (eeprom->group3_schmitt == IS_SCHMITT)
+ output[0x0d] |= IS_SCHMITT<<4;
+ if (eeprom->group3_slew == SLOW_SLEW)
+ output[0x0d] |= SLOW_SLEW<<4;
- output[0x18] = eeprom->chip;
+ output[0x18] = eeprom->chip;
- break;
- case TYPE_4232H:
- fprintf(stderr,"FIXME: Build FT4232H specific EEPROM settings\n");
+ break;
+ case TYPE_4232H:
+ output[0x18] = eeprom->chip;
+ fprintf(stderr,"FIXME: Build FT4232H specific EEPROM settings\n");
+ break;
+ case TYPE_232H:
+ output[0x00] = (1<<(eeprom->channel_a_type)) & 0xf;
+ if ( eeprom->channel_a_driver == DRIVER_VCP)
+ output[0x00] |= DRIVER_VCPH;
+ else
+ output[0x00] &= ~DRIVER_VCPH;
+ if (eeprom->powersave)
+ output[0x01] |= POWER_SAVE_DISABLE_H;
+ else
+ output[0x01] &= ~POWER_SAVE_DISABLE_H;
+ if (eeprom->clock_polarity)
+ output[0x01] |= FT1284_CLK_IDLE_STATE;
+ else
+ output[0x01] &= ~FT1284_CLK_IDLE_STATE;
+ if (eeprom->data_order)
+ output[0x01] |= FT1284_DATA_LSB;
+ else
+ output[0x01] &= ~FT1284_DATA_LSB;
+ if (eeprom->flow_control)
+ output[0x01] |= FT1284_FLOW_CONTROL;
+ else
+ output[0x01] &= ~FT1284_FLOW_CONTROL;
+ if (eeprom->group0_drive > DRIVE_16MA)
+ output[0x0c] |= DRIVE_16MA;
+ else
+ output[0x0c] |= eeprom->group0_drive;
+ if (eeprom->group0_schmitt == IS_SCHMITT)
+ output[0x0c] |= IS_SCHMITT;
+ if (eeprom->group0_slew == SLOW_SLEW)
+ output[0x0c] |= SLOW_SLEW;
+
+ if (eeprom->group1_drive > DRIVE_16MA)
+ output[0x0d] |= DRIVE_16MA;
+ else
+ output[0x0d] |= eeprom->group1_drive;
+ if (eeprom->group1_schmitt == IS_SCHMITT)
+ output[0x0d] |= IS_SCHMITT;
+ if (eeprom->group1_slew == SLOW_SLEW)
+ output[0x0d] |= SLOW_SLEW;
+
+ set_ft232h_cbus(eeprom, output);
+
+ output[0x1e] = eeprom->chip;
+ fprintf(stderr,"FIXME: Build FT232H specific EEPROM settings\n");
+ break;
+
}
// calculate checksum
return user_area_size;
}
+/* FTD2XX doesn't allow to set multiple bits in the interface mode bitfield*/
+unsigned char bit2type(unsigned char bits)
+{
+ switch (bits)
+ {
+ case 0: return 0;
+ case 1: return 1;
+ case 2: return 2;
+ case 4: return 3;
+ case 8: return 4;
+ default:
+ fprintf(stderr," Unexpected value %d for Hardware Interface type\n",
+ bits);
+ }
+ return 0;
+}
/**
Decode binary EEPROM image into an ftdi_eeprom structure.
\param ftdi pointer to ftdi_context
\param verbose Decode EEPROM on stdout
-
+
\retval 0: all fine
\retval -1: something went wrong
ftdi_error_return(-1,"No context");
if (ftdi->eeprom == NULL)
ftdi_error_return(-1,"No eeprom structure");
-
+
eeprom = ftdi->eeprom;
eeprom_size = eeprom->size;
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
+ // Addr 0D: USB version high byte when 0x0A
eeprom->usb_version = buf[0x0C] + (buf[0x0D] << 8);
// Addr 0E: Offset of the manufacturer string + 0x80, calculated later
// Addr 0F: Length of manufacturer string
manufacturer_size = buf[0x0F]/2;
- if(eeprom->manufacturer)
+ if (eeprom->manufacturer)
free(eeprom->manufacturer);
- if (manufacturer_size > 0)
+ if (manufacturer_size > 0)
{
eeprom->manufacturer = malloc(manufacturer_size);
if (eeprom->manufacturer)
// Addr 10: Offset of the product string + 0x80, calculated later
// Addr 11: Length of product string
- if(eeprom->product)
+ if (eeprom->product)
free(eeprom->product);
product_size = buf[0x11]/2;
if (product_size > 0)
{
eeprom->product = malloc(product_size);
- if(eeprom->product)
+ if (eeprom->product)
{
// Decode product name
i = buf[0x10] & (eeprom_size -1); // offset
// Addr 12: Offset of the serial string + 0x80, calculated later
// Addr 13: Length of serial string
- if(eeprom->serial)
+ if (eeprom->serial)
free(eeprom->serial);
serial_size = buf[0x13]/2;
if (serial_size > 0)
{
eeprom->serial = malloc(serial_size);
- if(eeprom->serial)
+ if (eeprom->serial)
{
// Decode serial
i = buf[0x12] & (eeprom_size -1); // offset
{
eeprom->chip = -1;
}
- else if(ftdi->type == TYPE_2232C)
+ else if (ftdi->type == TYPE_2232C)
{
- eeprom->channel_a_type = buf[0x00] & 0x7;
+ eeprom->channel_a_type = bit2type(buf[0x00] & 0x7);
eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP;
eeprom->high_current_a = buf[0x00] & HIGH_CURRENT_DRIVE;
eeprom->channel_b_type = buf[0x01] & 0x7;
eeprom->high_current_b = buf[0x01] & HIGH_CURRENT_DRIVE;
eeprom->chip = buf[0x14];
}
- else if(ftdi->type == TYPE_R)
+ else if (ftdi->type == TYPE_R)
{
/* 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;
- if( (buf[0x01]&0x40) != 0x40)
- fprintf(stderr,
- "TYPE_R EEPROM byte[0x01] Bit 6 unexpected Endpoint size."
- " If this happened with the\n"
- " EEPROM programmed by FTDI tools, please report "
- "to libftdi@developer.intra2net.com\n");
+ if ( (buf[0x01]&0x40) != 0x40)
+ fprintf(stderr,
+ "TYPE_R EEPROM byte[0x01] Bit 6 unexpected Endpoint size."
+ " If this happened with the\n"
+ " EEPROM programmed by FTDI tools, please report "
+ "to libftdi@developer.intra2net.com\n");
eeprom->chip = buf[0x16];
// Addr 0B: Invert data lines
eeprom->cbus_function[3] = (buf[0x15] >> 4) & 0x0f;
eeprom->cbus_function[4] = buf[0x16] & 0x0f;
}
- else if ((ftdi->type == TYPE_2232H) ||(ftdi->type == TYPE_4232H))
+ else if ((ftdi->type == TYPE_2232H) ||(ftdi->type == TYPE_4232H))
{
- eeprom->channel_a_type = buf[0x00] & 0x7;
+ eeprom->channel_a_type = bit2type(buf[0x00] & 0x7);
eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP;
eeprom->channel_b_type = buf[0x01] & 0x7;
eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP;
- if(ftdi->type == TYPE_2232H)
+ if (ftdi->type == TYPE_2232H)
eeprom->suspend_dbus7 = buf[0x01] & SUSPEND_DBUS7_BIT;
eeprom->chip = buf[0x18];
eeprom->group3_schmitt = (buf[0x0d] >> 4) & IS_SCHMITT;
eeprom->group3_slew = (buf[0x0d] >> 4) & SLOW_SLEW;
}
-
- if(verbose)
+ else if (ftdi->type == TYPE_232H)
+ {
+ int i;
+
+ eeprom->channel_a_type = buf[0x00] & 0xf;
+ eeprom->channel_a_driver = (buf[0x00] & DRIVER_VCPH)?DRIVER_VCP:0;
+ eeprom->clock_polarity = buf[0x01] & FT1284_CLK_IDLE_STATE;
+ eeprom->data_order = buf[0x01] & FT1284_DATA_LSB;
+ eeprom->flow_control = buf[0x01] & FT1284_FLOW_CONTROL;
+ eeprom->powersave = buf[0x01] & POWER_SAVE_DISABLE_H;
+ eeprom->group0_drive = buf[0x0c] & DRIVE_16MA;
+ eeprom->group0_schmitt = buf[0x0c] & IS_SCHMITT;
+ eeprom->group0_slew = buf[0x0c] & SLOW_SLEW;
+ eeprom->group1_drive = buf[0x0d] & DRIVE_16MA;
+ eeprom->group1_schmitt = buf[0x0d] & IS_SCHMITT;
+ eeprom->group1_slew = buf[0x0d] & SLOW_SLEW;
+
+ for(i=0; i<5; i++)
+ {
+ eeprom->cbus_function[2*i ] = buf[0x18+i] & 0x0f;
+ eeprom->cbus_function[2*i+1] = (buf[0x18+i] >> 4) & 0x0f;
+ }
+ eeprom->chip = buf[0x1e];
+ /*FIXME: Decipher more values*/
+ }
+
+ if (verbose)
{
- char *channel_mode[] = {"UART","245","CPU", "unknown", "OPTO"};
+ char *channel_mode[] = {"UART","245","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",release);
- if(eeprom->self_powered)
+ if (eeprom->self_powered)
fprintf(stdout, "Self-Powered%s", (eeprom->remote_wakeup)?", USB Remote Wake Up\n":"\n");
else
fprintf(stdout, "Bus Powered: %3d mA%s", eeprom->max_power * 2,
(eeprom->remote_wakeup)?" USB Remote Wake Up\n":"\n");
- if(eeprom->manufacturer)
+ if (eeprom->manufacturer)
fprintf(stdout, "Manufacturer: %s\n",eeprom->manufacturer);
- if(eeprom->product)
+ if (eeprom->product)
fprintf(stdout, "Product: %s\n",eeprom->product);
- if(eeprom->serial)
+ if (eeprom->serial)
fprintf(stdout, "Serial: %s\n",eeprom->serial);
fprintf(stdout, "Checksum : %04x\n", checksum);
if (ftdi->type == TYPE_R)
fprintf(stdout, "Internal EEPROM\n");
else if (eeprom->chip >= 0x46)
fprintf(stdout, "Attached EEPROM: 93x%02x\n", eeprom->chip);
- if(eeprom->suspend_dbus7)
- fprintf(stdout, "Suspend on DBUS7\n");
- if(eeprom->suspend_pull_downs)
+ if (eeprom->suspend_dbus7)
+ fprintf(stdout, "Suspend on DBUS7\n");
+ if (eeprom->suspend_pull_downs)
fprintf(stdout, "Pull IO pins low during suspend\n");
- if(eeprom->remote_wakeup)
+ if(eeprom->powersave)
+ {
+ if(ftdi->type >= TYPE_232H)
+ fprintf(stdout,"Enter low power state on ACBUS7\n");
+ }
+ if (eeprom->remote_wakeup)
fprintf(stdout, "Enable Remote Wake Up\n");
fprintf(stdout, "PNP: %d\n",(eeprom->is_not_pnp)?0:1);
if (ftdi->type >= TYPE_2232C)
- fprintf(stdout,"Channel A has Mode %s%s%s\n",
+ fprintf(stdout,"Channel A has Mode %s%s%s\n",
channel_mode[eeprom->channel_a_type],
(eeprom->channel_a_driver)?" VCP":"",
(eeprom->high_current_a)?" High Current IO":"");
- if ((ftdi->type >= TYPE_2232C) && (ftdi->type != TYPE_R))
- fprintf(stdout,"Channel B has Mode %s%s%s\n",
+ if (ftdi->type >= TYPE_232H)
+ {
+ fprintf(stdout,"FT1284 Mode Clock is idle %s, %s first, %sFlow Control\n",
+ (eeprom->clock_polarity)?"HIGH":"LOW",
+ (eeprom->data_order)?"LSB":"MSB",
+ (eeprom->flow_control)?"":"No ");
+ }
+ if ((ftdi->type >= TYPE_2232C) && (ftdi->type != TYPE_R) && (ftdi->type != TYPE_232H))
+ fprintf(stdout,"Channel B has Mode %s%s%s\n",
channel_mode[eeprom->channel_b_type],
(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 == USE_USB_VERSION_BIT)
fprintf(stdout,"Use explicit USB Version %04x\n",eeprom->usb_version);
- if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H))
+ if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H))
{
fprintf(stdout,"%s has %d mA drive%s%s\n",
(ftdi->type == TYPE_2232H)?"AL":"A",
(eeprom->group3_schmitt)?" Schmitt Input":"",
(eeprom->group3_slew)?" Slow Slew":"");
}
+ else if (ftdi->type == TYPE_232H)
+ {
+ int i;
+ char *cbush_mux[] = {"TRISTATE","RXLED","TXLED", "TXRXLED","PWREN",
+ "SLEEP","DRIVE_0","DRIVE_1","IOMODE","TXDEN",
+ "CLK30","CLK15","CLK7_5"
+ };
+ fprintf(stdout,"ACBUS has %d mA drive%s%s\n",
+ (eeprom->group0_drive+1) *4,
+ (eeprom->group0_schmitt)?" Schmitt Input":"",
+ (eeprom->group0_slew)?" Slow Slew":"");
+ fprintf(stdout,"ADBUS has %d mA drive%s%s\n",
+ (eeprom->group1_drive+1) *4,
+ (eeprom->group1_schmitt)?" Schmitt Input":"",
+ (eeprom->group1_slew)?" Slow Slew":"");
+ for (i=0; i<10; i++)
+ {
+ if (eeprom->cbus_function[i]<= CBUSH_CLK7_5 )
+ fprintf(stdout,"C%d Function: %s\n", i,
+ cbush_mux[eeprom->cbus_function[i]]);
+ }
+
+ }
+
if (ftdi->type == TYPE_R)
{
char *cbus_mux[] = {"TXDEN","PWREN","RXLED", "TXLED","TX+RXLED",
"SLEEP","CLK48","CLK24","CLK12","CLK6",
- "IOMODE","BB_WR","BB_RD"};
+ "IOMODE","BB_WR","BB_RD"
+ };
char *cbus_BB[] = {"RXF","TXE","RD", "WR"};
- int i;
-
- if(eeprom->invert)
- {
+
+ if (eeprom->invert)
+ {
char *r_bits[] = {"TXD","RXD","RTS", "CTS","DTR","DSR","DCD","RI"};
fprintf(stdout,"Inverted bits:");
for (i=0; i<8; i++)
- if((eeprom->invert & (1<<i)) == (1<<i))
+ if ((eeprom->invert & (1<<i)) == (1<<i))
fprintf(stdout," %s",r_bits[i]);
fprintf(stdout,"\n");
}
- for(i=0; i<5; i++)
+ for (i=0; i<5; i++)
{
- if(eeprom->cbus_function[i]<CBUS_BB)
+ if (eeprom->cbus_function[i]<CBUS_BB)
fprintf(stdout,"C%d Function: %s\n", i,
cbus_mux[eeprom->cbus_function[i]]);
else
- fprintf(stdout,"C%d BB Function: %s\n", i,
- cbus_BB[i]);
+ {
+ if (i < 4)
+ /* Running MPROG show that C0..3 have fixed function Synchronous
+ Bit Bang mode */
+ fprintf(stdout,"C%d BB Function: %s\n", i,
+ cbus_BB[i]);
+ else
+ fprintf(stdout, "Unknown CBUS mode. Might be special mode?\n");
+ }
}
}
}
}
/**
+ Get a value from the decoded EEPROM structure
+
+ \param ftdi pointer to ftdi_context
+ \param value_name Enum of the value to query
+ \param value Pointer to store read value
+
+ \retval 0: all fine
+ \retval -1: Value doesn't exist
+*/
+int ftdi_get_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int* value)
+{
+ switch (value_name)
+ {
+ case VENDOR_ID:
+ *value = ftdi->eeprom->vendor_id;
+ break;
+ case PRODUCT_ID:
+ *value = ftdi->eeprom->product_id;
+ break;
+ case SELF_POWERED:
+ *value = ftdi->eeprom->self_powered;
+ break;
+ case REMOTE_WAKEUP:
+ *value = ftdi->eeprom->remote_wakeup;
+ break;
+ case IS_NOT_PNP:
+ *value = ftdi->eeprom->is_not_pnp;
+ break;
+ case SUSPEND_DBUS7:
+ *value = ftdi->eeprom->suspend_dbus7;
+ break;
+ case IN_IS_ISOCHRONOUS:
+ *value = ftdi->eeprom->in_is_isochronous;
+ break;
+ case SUSPEND_PULL_DOWNS:
+ *value = ftdi->eeprom->suspend_pull_downs;
+ break;
+ case USE_SERIAL:
+ *value = ftdi->eeprom->use_serial;
+ break;
+ case USB_VERSION:
+ *value = ftdi->eeprom->usb_version;
+ break;
+ case MAX_POWER:
+ *value = ftdi->eeprom->max_power;
+ break;
+ case CHANNEL_A_TYPE:
+ *value = ftdi->eeprom->channel_a_type;
+ break;
+ case CHANNEL_B_TYPE:
+ *value = ftdi->eeprom->channel_b_type;
+ break;
+ case CHANNEL_A_DRIVER:
+ *value = ftdi->eeprom->channel_a_driver;
+ break;
+ case CHANNEL_B_DRIVER:
+ *value = ftdi->eeprom->channel_b_driver;
+ break;
+ case CBUS_FUNCTION_0:
+ *value = ftdi->eeprom->cbus_function[0];
+ break;
+ case CBUS_FUNCTION_1:
+ *value = ftdi->eeprom->cbus_function[1];
+ break;
+ case CBUS_FUNCTION_2:
+ *value = ftdi->eeprom->cbus_function[2];
+ break;
+ case CBUS_FUNCTION_3:
+ *value = ftdi->eeprom->cbus_function[3];
+ break;
+ case CBUS_FUNCTION_4:
+ *value = ftdi->eeprom->cbus_function[4];
+ break;
+ case CBUS_FUNCTION_5:
+ *value = ftdi->eeprom->cbus_function[5];
+ break;
+ case CBUS_FUNCTION_6:
+ *value = ftdi->eeprom->cbus_function[6];
+ break;
+ case CBUS_FUNCTION_7:
+ *value = ftdi->eeprom->cbus_function[7];
+ break;
+ case CBUS_FUNCTION_8:
+ *value = ftdi->eeprom->cbus_function[8];
+ break;
+ case CBUS_FUNCTION_9:
+ *value = ftdi->eeprom->cbus_function[8];
+ break;
+ case HIGH_CURRENT:
+ *value = ftdi->eeprom->high_current;
+ break;
+ case HIGH_CURRENT_A:
+ *value = ftdi->eeprom->high_current_a;
+ break;
+ case HIGH_CURRENT_B:
+ *value = ftdi->eeprom->high_current_b;
+ break;
+ case INVERT:
+ *value = ftdi->eeprom->invert;
+ break;
+ case GROUP0_DRIVE:
+ *value = ftdi->eeprom->group0_drive;
+ break;
+ case GROUP0_SCHMITT:
+ *value = ftdi->eeprom->group0_schmitt;
+ break;
+ case GROUP0_SLEW:
+ *value = ftdi->eeprom->group0_slew;
+ break;
+ case GROUP1_DRIVE:
+ *value = ftdi->eeprom->group1_drive;
+ break;
+ case GROUP1_SCHMITT:
+ *value = ftdi->eeprom->group1_schmitt;
+ break;
+ case GROUP1_SLEW:
+ *value = ftdi->eeprom->group1_slew;
+ break;
+ case GROUP2_DRIVE:
+ *value = ftdi->eeprom->group2_drive;
+ break;
+ case GROUP2_SCHMITT:
+ *value = ftdi->eeprom->group2_schmitt;
+ break;
+ case GROUP2_SLEW:
+ *value = ftdi->eeprom->group2_slew;
+ break;
+ case GROUP3_DRIVE:
+ *value = ftdi->eeprom->group3_drive;
+ break;
+ case GROUP3_SCHMITT:
+ *value = ftdi->eeprom->group3_schmitt;
+ break;
+ case GROUP3_SLEW:
+ *value = ftdi->eeprom->group3_slew;
+ break;
+ case POWER_SAVE:
+ *value = ftdi->eeprom->powersave;
+ break;
+ case CLOCK_POLARITY:
+ *value = ftdi->eeprom->clock_polarity;
+ break;
+ case DATA_ORDER:
+ *value = ftdi->eeprom->data_order;
+ break;
+ case FLOW_CONTROL:
+ *value = ftdi->eeprom->flow_control;
+ break;
+ case CHIP_TYPE:
+ *value = ftdi->eeprom->chip;
+ break;
+ case CHIP_SIZE:
+ *value = ftdi->eeprom->size;
+ break;
+ default:
+ ftdi_error_return(-1, "Request for unknown EEPROM value");
+ }
+ return 0;
+}
+
+/**
+ Set a value in the decoded EEPROM Structure
+ No parameter checking is performed
+
+ \param ftdi pointer to ftdi_context
+ \param value_name Enum of the value to set
+ \param value to set
+
+ \retval 0: all fine
+ \retval -1: Value doesn't exist
+ \retval -2: Value not user settable
+*/
+int ftdi_set_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int value)
+{
+ switch (value_name)
+ {
+ case VENDOR_ID:
+ ftdi->eeprom->vendor_id = value;
+ break;
+ case PRODUCT_ID:
+ ftdi->eeprom->product_id = value;
+ break;
+ case SELF_POWERED:
+ ftdi->eeprom->self_powered = value;
+ break;
+ case REMOTE_WAKEUP:
+ ftdi->eeprom->remote_wakeup = value;
+ break;
+ case IS_NOT_PNP:
+ ftdi->eeprom->is_not_pnp = value;
+ break;
+ case SUSPEND_DBUS7:
+ ftdi->eeprom->suspend_dbus7 = value;
+ break;
+ case IN_IS_ISOCHRONOUS:
+ ftdi->eeprom->in_is_isochronous = value;
+ break;
+ case SUSPEND_PULL_DOWNS:
+ ftdi->eeprom->suspend_pull_downs = value;
+ break;
+ case USE_SERIAL:
+ ftdi->eeprom->use_serial = value;
+ break;
+ case USB_VERSION:
+ ftdi->eeprom->usb_version = value;
+ break;
+ case MAX_POWER:
+ ftdi->eeprom->max_power = value;
+ break;
+ case CHANNEL_A_TYPE:
+ ftdi->eeprom->channel_a_type = value;
+ break;
+ case CHANNEL_B_TYPE:
+ ftdi->eeprom->channel_b_type = value;
+ break;
+ case CHANNEL_A_DRIVER:
+ ftdi->eeprom->channel_a_driver = value;
+ break;
+ case CHANNEL_B_DRIVER:
+ ftdi->eeprom->channel_b_driver = value;
+ break;
+ case CBUS_FUNCTION_0:
+ ftdi->eeprom->cbus_function[0] = value;
+ break;
+ case CBUS_FUNCTION_1:
+ ftdi->eeprom->cbus_function[1] = value;
+ break;
+ case CBUS_FUNCTION_2:
+ ftdi->eeprom->cbus_function[2] = value;
+ break;
+ case CBUS_FUNCTION_3:
+ ftdi->eeprom->cbus_function[3] = value;
+ break;
+ case CBUS_FUNCTION_4:
+ ftdi->eeprom->cbus_function[4] = value;
+ break;
+ case CBUS_FUNCTION_5:
+ ftdi->eeprom->cbus_function[5] = value;
+ break;
+ case CBUS_FUNCTION_6:
+ ftdi->eeprom->cbus_function[6] = value;
+ break;
+ case CBUS_FUNCTION_7:
+ ftdi->eeprom->cbus_function[7] = value;
+ break;
+ case CBUS_FUNCTION_8:
+ ftdi->eeprom->cbus_function[8] = value;
+ break;
+ case CBUS_FUNCTION_9:
+ ftdi->eeprom->cbus_function[9] = value;
+ break;
+ case HIGH_CURRENT:
+ ftdi->eeprom->high_current = value;
+ break;
+ case HIGH_CURRENT_A:
+ ftdi->eeprom->high_current_a = value;
+ break;
+ case HIGH_CURRENT_B:
+ ftdi->eeprom->high_current_b = value;
+ break;
+ case INVERT:
+ ftdi->eeprom->invert = value;
+ break;
+ case GROUP0_DRIVE:
+ ftdi->eeprom->group0_drive = value;
+ break;
+ case GROUP0_SCHMITT:
+ ftdi->eeprom->group0_schmitt = value;
+ break;
+ case GROUP0_SLEW:
+ ftdi->eeprom->group0_slew = value;
+ break;
+ case GROUP1_DRIVE:
+ ftdi->eeprom->group1_drive = value;
+ break;
+ case GROUP1_SCHMITT:
+ ftdi->eeprom->group1_schmitt = value;
+ break;
+ case GROUP1_SLEW:
+ ftdi->eeprom->group1_slew = value;
+ break;
+ case GROUP2_DRIVE:
+ ftdi->eeprom->group2_drive = value;
+ break;
+ case GROUP2_SCHMITT:
+ ftdi->eeprom->group2_schmitt = value;
+ break;
+ case GROUP2_SLEW:
+ ftdi->eeprom->group2_slew = value;
+ break;
+ case GROUP3_DRIVE:
+ ftdi->eeprom->group3_drive = value;
+ break;
+ case GROUP3_SCHMITT:
+ ftdi->eeprom->group3_schmitt = value;
+ break;
+ case GROUP3_SLEW:
+ ftdi->eeprom->group3_slew = value;
+ break;
+ case CHIP_TYPE:
+ ftdi->eeprom->chip = value;
+ break;
+ case POWER_SAVE:
+ ftdi->eeprom->powersave = value;
+ break;
+ case CLOCK_POLARITY:
+ ftdi->eeprom->clock_polarity = value;
+ break;
+ case DATA_ORDER:
+ ftdi->eeprom->data_order = value;
+ break;
+ case FLOW_CONTROL:
+ ftdi->eeprom->flow_control = value;
+ break;
+ case CHIP_SIZE:
+ ftdi_error_return(-2, "EEPROM Value can't be changed");
+ default :
+ ftdi_error_return(-1, "Request to unknown EEPROM value");
+ }
+ return 0;
+}
+
+/** Get the read-only buffer to the binary EEPROM content
+
+ \param ftdi pointer to ftdi_context
+ \param buf buffer to receive EEPROM content
+ \param size Size of receiving buffer
+
+ \retval 0: All fine
+ \retval -1: struct ftdi_contxt or ftdi_eeprom missing
+ \retval -2: Not enough room to store eeprom
+*/
+int ftdi_get_eeprom_buf(struct ftdi_context *ftdi, unsigned char * buf, int size)
+{
+ if (!ftdi || !(ftdi->eeprom))
+ ftdi_error_return(-1, "No appropriate structure");
+
+ if (!buf || size < ftdi->eeprom->size)
+ ftdi_error_return(-1, "Not enough room to store eeprom");
+
+ // Only copy up to FTDI_MAX_EEPROM_SIZE bytes
+ if (size > FTDI_MAX_EEPROM_SIZE)
+ size = FTDI_MAX_EEPROM_SIZE;
+
+ memcpy(buf, ftdi->eeprom->buf, size);
+
+ return 0;
+}
+
+/**
Read eeprom location
\param ftdi pointer to ftdi_context
for (i = 0; i < FTDI_MAX_EEPROM_SIZE/2; i++)
{
if (libusb_control_transfer(
- ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE,SIO_READ_EEPROM_REQUEST, 0, i,
- buf+(i*2), 2, ftdi->usb_read_timeout) != 2)
+ ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE,SIO_READ_EEPROM_REQUEST, 0, i,
+ buf+(i*2), 2, ftdi->usb_read_timeout) != 2)
ftdi_error_return(-1, "reading eeprom failed");
}
if (ftdi->type == TYPE_R)
ftdi->eeprom->size = 0x80;
- /* Guesses size of eeprom by comparing halves
+ /* Guesses size of eeprom by comparing halves
- will not work with blank eeprom */
else if (strrchr((const char *)buf, 0xff) == ((const char *)buf +FTDI_MAX_EEPROM_SIZE -1))
ftdi->eeprom->size = -1;
- else if(memcmp(buf,&buf[0x80],0x80) == 0)
+ else if (memcmp(buf,&buf[0x80],0x80) == 0)
ftdi->eeprom->size = 0x80;
- else if(memcmp(buf,&buf[0x40],0x40) == 0)
+ else if (memcmp(buf,&buf[0x40],0x40) == 0)
ftdi->eeprom->size = 0x40;
else
ftdi->eeprom->size = 0x100;
\retval -4: Device can't access unprotected area
\retval -5: Reading chip type failed
*/
-int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr,
+int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr,
unsigned short eeprom_val)
{
int chip_type_location;
if (ftdi == NULL || ftdi->usb_dev == NULL)
ftdi_error_return(-2, "USB device unavailable");
- if(eeprom_addr <0x80)
+ if (eeprom_addr <0x80)
ftdi_error_return(-2, "Invalid access to checksum protected area below 0x80");
switch (ftdi->type)
{
- case TYPE_BM:
- case TYPE_2232C:
- chip_type_location = 0x14;
- break;
- case TYPE_2232H:
- case TYPE_4232H:
- chip_type_location = 0x18;
- break;
- default:
- ftdi_error_return(-4, "Device can't access unprotected area");
+ case TYPE_BM:
+ case TYPE_2232C:
+ chip_type_location = 0x14;
+ break;
+ case TYPE_2232H:
+ case TYPE_4232H:
+ chip_type_location = 0x18;
+ break;
+ case TYPE_232H:
+ chip_type_location = 0x1e;
+ break;
+ default:
+ ftdi_error_return(-4, "Device can't access unprotected area");
}
- if (ftdi_read_eeprom_location( ftdi, chip_type_location>>1, &chip_type))
+ if (ftdi_read_eeprom_location( ftdi, chip_type_location>>1, &chip_type))
ftdi_error_return(-5, "Reading failed failed");
- fprintf(stderr," loc 0x%04x val 0x%04x\n", chip_type_location,chip_type);
- if((chip_type & 0xff) != 0x66)
+ fprintf(stderr," loc 0x%04x val 0x%04x\n", chip_type_location,chip_type);
+ if ((chip_type & 0xff) != 0x66)
{
ftdi_error_return(-6, "EEPROM is not of 93x66");
}
if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
- SIO_WRITE_EEPROM_REQUEST, eeprom_val, eeprom_addr,
- NULL, 0, ftdi->usb_write_timeout) != 0)
+ SIO_WRITE_EEPROM_REQUEST, eeprom_val, eeprom_addr,
+ NULL, 0, ftdi->usb_write_timeout) != 0)
ftdi_error_return(-1, "unable to write eeprom");
return 0;
Write eeprom
\param ftdi pointer to ftdi_context
-
+
\retval 0: all fine
\retval -1: read failed
\retval -2: USB device unavailable
if (ftdi == NULL || ftdi->usb_dev == NULL)
ftdi_error_return(-2, "USB device unavailable");
- if(ftdi->type == TYPE_R)
+ if (ftdi->type == TYPE_R)
{
ftdi->eeprom->chip = 0;
return 0;
}
- if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST,
+ if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST,
0, 0, NULL, 0, ftdi->usb_write_timeout) < 0)
ftdi_error_return(-1, "unable to erase eeprom");
-
+
/* detect chip type by writing 0x55AA as magic at word position 0xc0
Chip is 93x46 if magic is read at word position 0x00, as wraparound happens around 0x40
Chip is 93x56 if magic is read at word position 0x40, as wraparound happens around 0x80
Chip is 93x66 if magic is only read at word position 0xc0*/
if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
- SIO_WRITE_EEPROM_REQUEST, MAGIC, 0xc0,
- NULL, 0, ftdi->usb_write_timeout) != 0)
+ SIO_WRITE_EEPROM_REQUEST, MAGIC, 0xc0,
+ NULL, 0, ftdi->usb_write_timeout) != 0)
ftdi_error_return(-3, "Writing magic failed");
- if (ftdi_read_eeprom_location( ftdi, 0x00, &eeprom_value))
+ if (ftdi_read_eeprom_location( ftdi, 0x00, &eeprom_value))
ftdi_error_return(-4, "Reading failed failed");
- if(eeprom_value == MAGIC)
+ if (eeprom_value == MAGIC)
{
ftdi->eeprom->chip = 0x46;
}
- else
+ else
{
- if (ftdi_read_eeprom_location( ftdi, 0x40, &eeprom_value))
+ if (ftdi_read_eeprom_location( ftdi, 0x40, &eeprom_value))
ftdi_error_return(-4, "Reading failed failed");
- if(eeprom_value == MAGIC)
+ if (eeprom_value == MAGIC)
ftdi->eeprom->chip = 0x56;
- else
+ else
{
- if (ftdi_read_eeprom_location( ftdi, 0xc0, &eeprom_value))
+ if (ftdi_read_eeprom_location( ftdi, 0xc0, &eeprom_value))
ftdi_error_return(-4, "Reading failed failed");
- if(eeprom_value == MAGIC)
+ if (eeprom_value == MAGIC)
ftdi->eeprom->chip = 0x66;
else
{
}
}
}
- if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST,
+ if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST,
0, 0, NULL, 0, ftdi->usb_write_timeout) < 0)
ftdi_error_return(-1, "unable to erase eeprom");
return 0;
git://developer.intra2net.com / libftdi / blobdiff