if (eeprom == 0)
ftdi_error_return(-2, "Can't malloc struct ftdi_eeprom");
+ memset(eeprom, 0, sizeof(struct ftdi_eeprom);
ftdi->eeprom = eeprom;
/* All fine. Now allocate the readbuffer */
if (ftdi->eeprom != NULL)
{
+ if (ftdi->eeprom->manufacturer != 0)
+ {
+ free(ftdi->eeprom->manufacturer);
+ ftdi->eeprom->manufacturer = 0;
+ }
+ if (ftdi->eeprom->product != 0)
+ {
+ free(ftdi->eeprom->product);
+ ftdi->eeprom->product = 0;
+ }
+ if (ftdi->eeprom->serial != 0)
+ {
+ free(ftdi->eeprom->serial);
+ ftdi->eeprom->serial = 0;
+ }
free(ftdi->eeprom);
ftdi->eeprom = NULL;
}
/**
Init eeprom with default values.
\param ftdi pointer to ftdi_context
-
+ \param manufacturer String to use as Manufacturer
+ \param product String to use as Product description
+ \param serial String to use as Serial number description
+
+ \retval 0: all fine
+ \retval -1: No struct ftdi_context
+ \retval -2: No struct ftdi_eeprom
*/
-void ftdi_eeprom_initdefaults(struct ftdi_context *ftdi)
+int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char * manufacturer,
+ char * product, char * serial)
{
struct ftdi_eeprom *eeprom;
if (ftdi == NULL)
- return;
+ ftdi_error_return(-1, "No struct ftdi_context");
+
if (ftdi->eeprom == NULL)
- return;
+ ftdi_error_return(-2,"No struct ftdi_eeprom");
eeprom = ftdi->eeprom;
memset(eeprom, 0, sizeof(struct ftdi_eeprom));
eeprom->usb_version = 0x0101;
else
eeprom->usb_version = 0x0200;
- eeprom->max_power = 50;
+ eeprom->max_power = 100;
+ if (eeprom->manufacturer)
+ free (eeprom->manufacturer);
eeprom->manufacturer = NULL;
+ if (manufacturer)
+ {
+ eeprom->manufacturer = malloc(strlen(manufacturer)+1);
+ if (eeprom->manufacturer)
+ strcpy(eeprom->manufacturer, manufacturer);
+ }
+
+ if (eeprom->product)
+ free (eeprom->product);
eeprom->product = NULL;
+ {
+ eeprom->product = malloc(strlen(product)+1);
+ if (eeprom->product)
+ strcpy(eeprom->product, product);
+ }
+
+ if (eeprom->serial)
+ free (eeprom->serial);
eeprom->serial = NULL;
+ if (serial)
+ {
+ eeprom->serial = malloc(strlen(serial)+1);
+ if (eeprom->serial)
+ strcpy(eeprom->serial, serial);
+ }
+
if(ftdi->type == TYPE_R)
{
- eeprom->max_power = 45;
+ eeprom->max_power = 90;
eeprom->size = 0x80;
eeprom->cbus_function[0] = CBUS_TXLED;
eeprom->cbus_function[1] = CBUS_RXLED;
}
else
eeprom->size = -1;
-}
-
-/**
- Frees allocated memory in eeprom.
-
- \param ftdi pointer to ftdi_context
-*/
-void ftdi_eeprom_free(struct ftdi_context *ftdi)
-{
- if (!ftdi)
- return;
- if (ftdi->eeprom)
- {
- struct ftdi_eeprom *eeprom = ftdi->eeprom;
-
- if (eeprom->manufacturer != 0) {
- free(eeprom->manufacturer);
- eeprom->manufacturer = 0;
- }
- if (eeprom->product != 0) {
- free(eeprom->product);
- eeprom->product = 0;
- }
- if (eeprom->serial != 0) {
- free(eeprom->serial);
- eeprom->serial = 0;
- }
- }
+ return 0;
}
/**
size_check -= serial_size*2;
/* Space for the string type and pointer bytes */
- size_check -= -6;
+ size_check -= -9;
// eeprom size exceeded?
if (size_check < 0)
output[0x08] = j;
// Addr 09: Max power consumption: max power = value * 2 mA
- output[0x09] = eeprom->max_power;
+ output[0x09] = eeprom->max_power>>1;
if(ftdi->type != TYPE_AM)
{
output[i & k] = eeprom->serial[j], i++;
output[i & k] = 0x00, i++;
}
+ output[i & k] = 0x02; /* as seen when written with FTD2XX */
+ i++;
+ output[i & k] = 0x03; /* as seen when written with FTD2XX */
+ i++;
+ output[i & k] = eeprom->is_not_pnp; /* as seen when written with FTD2XX */
+ i++;
+
output[0x13] = serial_size*2 + 2;
+ if(ftdi->type > TYPE_AM) /*use_serial not used in AM devices*/
+ {
+ if (eeprom->use_serial == USE_SERIAL_NUM )
+ output[0x0A] |= USE_SERIAL_NUM;
+ else
+ output[0x0A] &= ~USE_SERIAL_NUM;
+ }
/* Fixme: ftd2xx seems to append 0x02, 0x03 and 0x01 for PnP = 0 or 0x00 else */
// calculate checksum
case TYPE_BM:
output[0x0C] = eeprom->usb_version & 0xff;
output[0x0D] = (eeprom->usb_version>>8) & 0xff;
- if (eeprom->use_serial == 1)
- output[0x0A] |= 0x8;
- else
- output[0x0A] &= ~0x8;
output[0x14] = eeprom->chip;
break;
case TYPE_2232C:
output[0x0A] |= 0x4;
else
output[0x0A] &= ~0x4;
- if (eeprom->use_serial == USE_SERIAL_NUM )
- output[0x0A] |= USE_SERIAL_NUM;
- else
- output[0x0A] &= ~0x8;
output[0x0C] = eeprom->usb_version & 0xff;
output[0x0D] = (eeprom->usb_version>>8) & 0xff;
output[0x14] = eeprom->chip;
output[0x0A] |= 0x4;
else
output[0x0A] &= ~0x4;
- if (eeprom->use_serial == USE_SERIAL_NUM)
- output[0x0A] |= USE_SERIAL_NUM;
- else
- output[0x0A] &= ~0x8;
output[0x0B] = eeprom->invert;
output[0x0C] = eeprom->usb_version & 0xff;
output[0x0D] = (eeprom->usb_version>>8) & 0xff;
else
output[0x01] &= ~SUSPEND_DBUS7;
+ if (eeprom->suspend_pull_downs == 1)
+ output[0x0A] |= 0x4;
+ else
+ output[0x0A] &= ~0x4;
+
if(eeprom->group0_drive > DRIVE_16MA)
output[0x0c] |= DRIVE_16MA;
else
// Addr 0E: Offset of the manufacturer string + 0x80, calculated later
// Addr 0F: Length of manufacturer string
manufacturer_size = buf[0x0F]/2;
+ if(eeprom->manufacturer)
+ free(eeprom->manufacturer);
if (manufacturer_size > 0)
{
eeprom->manufacturer = malloc(manufacturer_size);
// Addr 10: Offset of the product string + 0x80, calculated later
// Addr 11: Length of product string
+ if(eeprom->product)
+ free(eeprom->product);
product_size = buf[0x11]/2;
if (product_size > 0)
{
// Addr 12: Offset of the serial string + 0x80, calculated later
// Addr 13: Length of serial string
+ if(eeprom->serial)
+ free(eeprom->serial);
serial_size = buf[0x13]/2;
if (serial_size > 0)
{
}
else if ((ftdi->type == TYPE_2232H) ||(ftdi->type == TYPE_4232H))
{
- eeprom->high_current = buf[0x00] & HIGH_CURRENT_DRIVE_R;
+ 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;
fprintf(stdout, "Pull IO pins low during suspend\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",
channel_mode[eeprom->channel_a_type],
\param eeprom_val Value to be written
\retval 0: all fine
- \retval -1: read failed
+ \retval -1: write failed
\retval -2: USB device unavailable
+ \retval -3: Invalid access to checksum protected area below 0x80
+ \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, unsigned short eeprom_val)
+int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr,
+ unsigned short eeprom_val)
{
+ int chip_type_location;
+ unsigned short chip_type;
+
if (ftdi == NULL || ftdi->usb_dev == NULL)
ftdi_error_return(-2, "USB device unavailable");
+ 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");
+ }
+
+ 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)
+ {
+ 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)
git://developer.intra2net.com / libftdi / blobdiff