{
if (ftdi && ftdi->usb_dev)
{
- libusb_close (ftdi->usb_dev);
- ftdi->usb_dev = NULL;
+ libusb_close (ftdi->usb_dev);
+ ftdi->usb_dev = NULL;
}
}
*curdev = (struct ftdi_device_list*)malloc(sizeof(struct ftdi_device_list));
if (!*curdev)
ftdi_error_return(-3, "out of memory");
-
+
(*curdev)->next = NULL;
(*curdev)->dev = dev;
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_4232H;
// Set default interface on dual/quad type chips
- switch(ftdi->type)
+ switch (ftdi->type)
{
case TYPE_2232C:
case TYPE_2232H:
\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;
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;
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,
\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
eeprom->product_id = 0x6010;
}
- if(ftdi->type == TYPE_R)
+ if (ftdi->type == TYPE_R)
{
eeprom->max_power = 90;
eeprom->size = 0x80;
eeprom= ftdi->eeprom;
output = eeprom->buf;
- if(eeprom->chip == -1)
+ if (eeprom->chip == -1)
ftdi_error_return(-5,"No connected EEPROM or EEPROM type unknown");
if ((eeprom->chip == 0x56) || (eeprom->chip == 0x66))
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;
}
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;
default:
// 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
// Strings start at 0x94 (TYPE_AM, TYPE_BM)
// 0x96 (TYPE_2232C), 0x98 (TYPE_R) and 0x9a (TYPE_x232H)
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_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] = (eeprom->channel_a_type);
+ 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] = (eeprom->channel_b_type);
+ 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] = (eeprom->channel_a_type);
+ 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] = (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->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:
+ fprintf(stderr,"FIXME: Build FT4232H specific EEPROM settings\n");
}
// calculate checksum
\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_driver = buf[0x00] & DRIVER_VCP;
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_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)
+
+ if (verbose)
{
char *channel_mode[] = {"UART","245","CPU", "unknown", "OPTO"};
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->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_2232C) && (ftdi->type != TYPE_R))
+ 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",
{
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
{
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 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 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");
+ 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 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 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;
}
{
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 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 CHIP_SIZE:
- ftdi_error_return(-2, "EEPROM Value can't be changed");
- default :
- ftdi_error_return(-1, "Request to unknown EEPROM value");
+ 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 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 CHIP_SIZE:
+ ftdi_error_return(-2, "EEPROM Value can't be changed");
+ default :
+ ftdi_error_return(-1, "Request to unknown EEPROM value");
}
return 0;
}
\retval 0: All fine
\retval -1: struct ftdi_contxt or ftdi_eeprom missing
*/
-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");
- memcpy(buf, ftdi->eeprom->buf, size);
- return 0;
- }
+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");
+ memcpy(buf, ftdi->eeprom->buf, size);
+ return 0;
+}
/**
Read eeprom location
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;
+ 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